Merge 6a283190b3 into f15aa8fba0

Add the controller image back
Consolidate most logic into StickVisualizer.
2025-01-26 00:29:48 +01:00 · 2025-01-24 22:24:02 -06:00 · 2025-01-24 20:08:58 -06:00 · 2025-01-24 20:01:36 -06:00 · 2025-01-24 19:58:17 -06:00 · 2025-01-24 19:57:11 -06:00
694 changed files with 9270 additions and 10416 deletions
--- a/COMPILING.md
+++ b/COMPILING.md
@@ -10,7 +10,7 @@ Make sure your SDK version is higher or equal to the required version specified

 ### Step 2

-Either use `git clone https://github.com/Ryubing/Ryujinx` on the command line to clone the repository or use Code --> Download zip button to get the files.
+Either use `git clone https://github.com/GreemDev/Ryujinx` on the command line to clone the repository or use Code --> Download zip button to get the files.

 ### Step 3

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -14,13 +14,13 @@ We always welcome bug reports, feature proposals and overall feedback. Here are

 ### Finding Existing Issues

-Before filing a new issue, please search our [open issues](https://github.com/Ryubing/Ryujinx/issues) to check if it already exists.
+Before filing a new issue, please search our [open issues](https://github.com/GreemDev/Ryujinx/issues) to check if it already exists.

 If you do find an existing issue, please include your own feedback in the discussion. Do consider upvoting (👍 reaction) the original post, as this helps us prioritize popular issues in our backlog.

 ### Writing a Good Feature Request

-Please review any feature requests already opened to both check it has not already been suggested, and to familiarize yourself with the format. When ready to submit a proposal, please use the [Feature Request issue template](https://github.com/Ryubing/Ryujinx/issues/new?assignees=&labels=&projects=&template=feature_request.yml&title=%5BFeature+Request%5D).
+Please review any feature requests already opened to both check it has not already been suggested, and to familiarize yourself with the format. When ready to submit a proposal, please use the [Feature Request issue template](https://github.com/GreemDev/Ryujinx/issues/new?assignees=&labels=&projects=&template=feature_request.yml&title=%5BFeature+Request%5D).

 ### Writing a Good Bug Report

@@ -34,13 +34,13 @@ Ideally, a bug report should contain the following information:
 * A Ryujinx log file of the run instance where the issue occurred. Log files can be found in `[Executable Folder]/Logs` and are named chronologically.
 * Additional information, e.g. is it a regression from previous versions? Are there any known workarounds?

-When ready to submit a bug report, please use the [Bug Report issue template](https://github.com/Ryubing/Ryujinx/issues/new?assignees=&labels=bug&projects=&template=bug_report.yml&title=%5BBug%5D).
+When ready to submit a bug report, please use the [Bug Report issue template](https://github.com/GreemDev/Ryujinx/issues/new?assignees=&labels=bug&projects=&template=bug_report.yml&title=%5BBug%5D).

 ## Contributing Changes

 Project maintainers will merge changes that both improve the project and meet our standards for code quality.

-The [Pull Request Guide](docs/workflow/pr-guide.md) and [License](https://github.com/Ryubing/Ryujinx/blob/master/LICENSE.txt) docs define additional guidance.
+The [Pull Request Guide](docs/workflow/pr-guide.md) and [License](https://github.com/GreemDev/Ryujinx/blob/master/LICENSE.txt) docs define additional guidance.

 ### DOs and DON'Ts

@@ -74,14 +74,14 @@ We use and recommend the following workflow:
 3. In your fork, create a branch off of main (`git checkout -b mybranch`).
    - Branches are useful since they isolate your changes from incoming changes from upstream. They also enable you to create multiple PRs from the same fork.
 4. Make and commit your changes to your branch.
-    - [Build Instructions](https://github.com/Ryubing/Ryujinx/blob/master/COMPILING.md) explains how to build and test.
+    - [Build Instructions](https://github.com/GreemDev/Ryujinx/blob/master/COMPILING.md) explains how to build and test.
    - Commit messages should be clear statements of action and intent.
 6. Build the repository with your changes.
    - Make sure that the builds are clean.
    - Make sure that `dotnet format` has been run and any corrections tested and committed.
 7. Create a pull request (PR) against the Ryujinx/Ryujinx repository's **main** branch.
    - State in the description what issue or improvement your change is addressing.
-    - Check if all the Continuous Integration checks are passing. Refer to [Actions](https://github.com/Ryubing/Ryujinx/actions) to check for outstanding errors.
+    - Check if all the Continuous Integration checks are passing. Refer to [Actions](https://github.com/GreemDev/Ryujinx/actions) to check for outstanding errors.
 8. Wait for feedback or approval of your changes from the core development team
    - Details about the pull request [review procedure](docs/workflow/pr-guide.md).
 9. When the team members have signed off, and all checks are green, your PR will be merged.
@@ -90,7 +90,7 @@ We use and recommend the following workflow:

 ### Good First Issues

-The team marks the most straightforward issues as [good first issues](https://github.com/Ryubing/Ryujinx/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22). This set of issues is the place to start if you are interested in contributing but new to the codebase.
+The team marks the most straightforward issues as [good first issues](https://github.com/GreemDev/Ryujinx/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22). This set of issues is the place to start if you are interested in contributing but new to the codebase.

 ### Commit Messages

@@ -113,7 +113,7 @@ Also do your best to factor commits appropriately, not too large with unrelated

 ### PR - CI Process

-The [Ryujinx continuous integration](https://github.com/Ryubing/Ryujinx/actions) (CI) system will automatically perform the required builds and run tests (including the ones you are expected to run) for PRs. Builds and test runs must be clean or have bugs properly filed against flaky/unexpected failures that are unrelated to your change.
+The [Ryujinx continuous integration](https://github.com/GreemDev/Ryujinx/actions) (CI) system will automatically perform the required builds and run tests (including the ones you are expected to run) for PRs. Builds and test runs must be clean or have bugs properly filed against flaky/unexpected failures that are unrelated to your change.

 If the CI build fails for any reason, the PR actions tab should be consulted for further information on the failure. There are a few usual suspects for such a failure:
 * `dotnet format` has not been run on the PR and has outstanding stylistic issues.
@@ -134,5 +134,5 @@ Ryujinx uses some implementations and frameworks from other projects. The follow

 - The license of the file is [permissive](https://en.wikipedia.org/wiki/Permissive_free_software_licence).
 - The license of the file is left in-tact.
- The contribution is correctly attributed in the [3rd party notices](https://github.com/Ryubing/Ryujinx/blob/master/distribution/legal/THIRDPARTY.md) file in the repository, as needed.
+- The contribution is correctly attributed in the [3rd party notices](https://github.com/GreemDev/Ryujinx/blob/master/distribution/legal/THIRDPARTY.md) file in the repository, as needed.

--- a/README.md
+++ b/README.md
@@ -7,11 +7,11 @@
          
 # Ryujinx
          
-[![Release workflow](https://github.com/Ryubing/Ryujinx/actions/workflows/release.yml/badge.svg)](https://github.com/Ryubing/Ryujinx/actions/workflows/release.yml)
-[![Latest release](https://img.shields.io/github/v/release/GreemDev/Ryujinx)](https://github.com/Ryubing/Ryujinx/releases/latest)
+[![Release workflow](https://github.com/GreemDev/Ryujinx/actions/workflows/release.yml/badge.svg)](https://github.com/GreemDev/Ryujinx/actions/workflows/release.yml)
+[![Latest release](https://img.shields.io/github/v/release/GreemDev/Ryujinx)](https://github.com/GreemDev/Ryujinx/releases/latest)
  <br>
-[![Canary workflow](https://github.com/Ryubing/Ryujinx/actions/workflows/canary.yml/badge.svg)](https://github.com/Ryubing/Ryujinx/actions/workflows/canary.yml)
-[![Latest canary release](https://img.shields.io/github/v/release/Ryubing/Canary-Releases?label=canary)](https://github.com/Ryubing/Canary-Releases/releases/latest)
+[![Canary workflow](https://github.com/GreemDev/Ryujinx/actions/workflows/canary.yml/badge.svg)](https://github.com/GreemDev/Ryujinx/actions/workflows/canary.yml)
+[![Latest canary release](https://img.shields.io/github/v/release/GreemDev/Ryujinx-Canary?label=canary)](https://github.com/GreemDev/Ryujinx-Canary/releases/latest)
        </td>
    </tr>
 </table>
@@ -20,7 +20,7 @@
  Ryujinx is an open-source Nintendo Switch emulator, originally created by gdkchan, written in C#.
  This emulator aims at providing excellent accuracy and performance, a user-friendly interface and consistent builds.
  It was written from scratch and development on the project began in September 2017.
-  Ryujinx is available on GitHub under the <a href="https://github.com/Ryubing/Ryujinx/blob/master/LICENSE.txt" target="_blank">MIT license</a>.
+  Ryujinx is available on GitHub under the <a href="https://github.com/GreemDev/Ryujinx/blob/master/LICENSE.txt" target="_blank">MIT license</a>.
  <br />
 </p>
 <p align="center">
@@ -30,7 +30,7 @@
  <br>
  This is not a Ryujinx revival project. This is not a Phoenix project.
  <br>
-  Guides and documentation can be found on the <a href="https://github.com/Ryubing/Ryujinx/wiki">Wiki tab</a>.
+  Guides and documentation can be found on the <a href="https://github.com/GreemDev/Ryujinx/wiki">Wiki tab</a>.
 </p>
 <p align="center">
  If you would like a more preservative fork of Ryujinx, check out <a href="https://github.com/ryujinx-mirror/ryujinx">ryujinx-mirror</a>.
@@ -58,13 +58,13 @@ Stable builds are made every so often, based on the `master` branch, that then g
 These stable builds exist so that the end user can get a more **enjoyable and stable experience**.
 They are released every month or so, to ensure consistent updates, while not being an annoying amount of individual updates to download over the course of that month.

-You can find the latest stable release [here](https://github.com/Ryubing/Ryujinx/releases/latest).
+You can find the latest stable release [here](https://github.com/GreemDev/Ryujinx/releases/latest).

 Canary builds are compiled automatically for each commit on the `master` branch.
 While we strive to ensure optimal stability and performance prior to pushing an update, these builds **may be unstable or completely broken**.
 These canary builds are only recommended for experienced users.

-You can find the latest canary release [here](https://github.com/Ryubing/Canary-Releases/releases/latest).
+You can find the latest canary release [here](https://github.com/GreemDev/Ryujinx-Canary/releases/latest).

 ## Documentation

--- a/assets/amiibo/Amiibo.json
+++ b/assets/amiibo/Amiibo.json
--- a/docs/compatibility.csv
+++ b/docs/compatibility.csv
@@ -2483,7 +2483,7 @@
 0100A5200C2E0000,"Safety First!",,playable,2021-01-06 09:05:23
 0100A51013530000,"SaGa Frontier Remastered",nvdec,playable,2022-11-03 13:54:56
 010003A00D0B4000,"SaGa SCARLET GRACE: AMBITIONS™",,playable,2022-10-06 13:20:31
-01008D100D43E000,"Saints Row IV®: Re-Elected™",ldn-untested;LAN;deadlock,ingame,2025-02-02 16:57:53
+01008D100D43E000,"Saints Row IV®: Re-Elected™",ldn-untested;LAN,playable,2023-12-04 18:33:37
 0100DE600BEEE000,"SAINTS ROW®: THE THIRD™ - THE FULL PACKAGE",slow;LAN,playable,2023-08-24 02:40:58
 01007F000EB36000,"Sakai and...",nvdec,playable,2022-12-15 13:53:19
 0100B1400E8FE000,"Sakuna: Of Rice and Ruin",,playable,2023-07-24 13:47:13
--- a/docs/workflow/pr-guide.md
+++ b/docs/workflow/pr-guide.md
@@ -18,13 +18,13 @@ To merge pull requests, you must have write permissions in the repository.

 ## Pull Request Ownership

-Every pull request will automatically have labels and reviewers assigned. The label not only indicates the code segment which the change touches but also the area reviewers to be assigned.
+Every pull request will have automatically have labels and reviewers assigned. The label not only indicates the code segment which the change touches but also the area reviewers to be assigned.

 If during the code review process a merge conflict occurs, the PR author is responsible for its resolution. Help will be provided if necessary although GitHub makes this easier by allowing simple conflict resolution using the [conflict-editor](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/resolving-a-merge-conflict-on-github).

 ## Pull Request Builds

-When submitting a PR to the `Ryubing/Ryujinx` repository, various builds will run validating many areas to ensure we keep developer productivity and product quality high. These various workflows can be tracked in the [Actions](https://github.com/Ryubing/Ryujinx/actions) tab of the repository. If the job continues to completion, the build artifacts will be uploaded and posted as a comment in the PR discussion.
+When submitting a PR to the `GreemDev/Ryujinx` repository, various builds will run validating many areas to ensure we keep developer productivity and product quality high. These various workflows can be tracked in the [Actions](https://github.com/GreemDev/Ryujinx/actions) tab of the repository. If the job continues to completion, the build artifacts will be uploaded and posted as a comment in the PR discussion.

 ## Review Turnaround Times

@@ -42,7 +42,7 @@ Anyone with write access can merge a pull request manually when the following co

 * The PR has been approved by two reviewers and any other objections are addressed.
    * You can request follow up reviews from the original reviewers if they requested changes.
-* The PR successfully builds and passes all tests in the Continuous Integration (CI) system. In case of failures, refer to the [Actions](https://github.com/Ryubing/Ryujinx/actions) tab of your PR.
+* The PR successfully builds and passes all tests in the Continuous Integration (CI) system. In case of failures, refer to the [Actions](https://github.com/GreemDev/Ryujinx/actions) tab of your PR.

 Typically, PRs are merged as one commit (squash merges). It creates a simpler history than a Merge Commit. "Special circumstances" are rare, and typically mean that there are a series of cleanly separated changes that will be too hard to understand if squashed together, or for some reason we want to preserve the ability to dissect them.

--- a/src/ARMeilleure/CodeGen/Arm64/Arm64Optimizer.cs
+++ b/src/ARMeilleure/CodeGen/Arm64/Arm64Optimizer.cs
@@ -13,7 +13,7 @@ namespace ARMeilleure.CodeGen.Arm64

        public static void RunPass(ControlFlowGraph cfg)
        {
-            Dictionary<ulong, Operand> constants = new();
+            Dictionary<ulong, Operand> constants = new Dictionary<ulong, Operand>();

            Operand GetConstantCopy(BasicBlock block, Operation operation, Operand source)
            {
--- a/src/ARMeilleure/CodeGen/Arm64/CodeGenContext.cs
+++ b/src/ARMeilleure/CodeGen/Arm64/CodeGenContext.cs
@@ -42,7 +42,7 @@ namespace ARMeilleure.CodeGen.Arm64
            {
                Offset = offset;
                Symbol = symbol;
-                LdrOffsets = [];
+                LdrOffsets = new List<(Operand, int)>();
            }
        }

@@ -266,7 +266,7 @@ namespace ARMeilleure.CodeGen.Arm64
            }
            else
            {
-                relocInfo = new RelocInfo([]);
+                relocInfo = new RelocInfo(Array.Empty<RelocEntry>());
            }

            return (code, relocInfo);
--- a/src/ARMeilleure/CodeGen/Arm64/CodeGenerator.cs
+++ b/src/ARMeilleure/CodeGen/Arm64/CodeGenerator.cs
@@ -1079,7 +1079,7 @@ namespace ARMeilleure.CodeGen.Arm64

        private static UnwindInfo WritePrologue(CodeGenContext context)
        {
-            List<UnwindPushEntry> pushEntries = [];
+            List<UnwindPushEntry> pushEntries = new();

            Operand rsp = Register(SpRegister);

--- a/src/ARMeilleure/CodeGen/Arm64/HardwareCapabilities.cs
+++ b/src/ARMeilleure/CodeGen/Arm64/HardwareCapabilities.cs
@@ -140,8 +140,8 @@ namespace ARMeilleure.CodeGen.Arm64
            return false;
        }

-        private static readonly string[] _sysctlNames =
-        [
+        private static readonly string[] _sysctlNames = new string[]
+        {
            "hw.optional.floatingpoint",
            "hw.optional.AdvSIMD",
            "hw.optional.arm.FEAT_FP16",
@@ -150,8 +150,8 @@ namespace ARMeilleure.CodeGen.Arm64
            "hw.optional.arm.FEAT_LSE",
            "hw.optional.armv8_crc32",
            "hw.optional.arm.FEAT_SHA1",
-            "hw.optional.arm.FEAT_SHA256"
-        ];
+            "hw.optional.arm.FEAT_SHA256",
+        };

        [Flags]
        public enum MacOsFeatureFlags
--- a/src/ARMeilleure/CodeGen/Arm64/PreAllocator.cs
+++ b/src/ARMeilleure/CodeGen/Arm64/PreAllocator.cs
@@ -261,10 +261,10 @@ namespace ARMeilleure.CodeGen.Arm64

            Operand dest = operation.Destination;

-            List<Operand> sources =
-            [
-                operation.GetSource(0)
-            ];
+            List<Operand> sources = new()
+            {
+                operation.GetSource(0),
+            };

            int argsCount = operation.SourcesCount - 1;

@@ -365,10 +365,10 @@ namespace ARMeilleure.CodeGen.Arm64
            Operation node,
            Operation operation)
        {
-            List<Operand> sources =
-            [
-                operation.GetSource(0)
-            ];
+            List<Operand> sources = new()
+            {
+                operation.GetSource(0),
+            };

            int argsCount = operation.SourcesCount - 1;

@@ -468,8 +468,8 @@ namespace ARMeilleure.CodeGen.Arm64

                // Update the sources and destinations with split 64-bit halfs of the whole 128-bit values.
                // We also need a additional registers that will be used to store temporary information.
-                operation.SetDestinations([actualLow, actualHigh, Local(OperandType.I64), Local(OperandType.I64)]);
-                operation.SetSources([address, expectedLow, expectedHigh, desiredLow, desiredHigh]);
+                operation.SetDestinations(new[] { actualLow, actualHigh, Local(OperandType.I64), Local(OperandType.I64) });
+                operation.SetSources(new[] { address, expectedLow, expectedHigh, desiredLow, desiredHigh });

                // Add some dummy uses of the input operands, as the CAS operation will be a loop,
                // so they can't be used as destination operand.
@@ -486,7 +486,7 @@ namespace ARMeilleure.CodeGen.Arm64
            else
            {
                // We need a additional register where the store result will be written to.
-                node.SetDestinations([node.Destination, Local(OperandType.I32)]);
+                node.SetDestinations(new[] { node.Destination, Local(OperandType.I32) });

                // Add some dummy uses of the input operands, as the CAS operation will be a loop,
                // so they can't be used as destination operand.
--- a/src/ARMeilleure/CodeGen/CompiledFunction.cs
+++ b/src/ARMeilleure/CodeGen/CompiledFunction.cs
@@ -1,6 +1,7 @@
 using ARMeilleure.CodeGen.Linking;
 using ARMeilleure.CodeGen.Unwinding;
 using ARMeilleure.Translation.Cache;
+using System;
 using System.Runtime.InteropServices;

 namespace ARMeilleure.CodeGen
--- a/src/ARMeilleure/CodeGen/Linking/RelocInfo.cs
+++ b/src/ARMeilleure/CodeGen/Linking/RelocInfo.cs
@@ -10,7 +10,7 @@ namespace ARMeilleure.CodeGen.Linking
        /// <summary>
        /// Gets an empty <see cref="RelocInfo"/>.
        /// </summary>
-        public static RelocInfo Empty { get; } = new(null);
+        public static RelocInfo Empty { get; } = new RelocInfo(null);

        private readonly RelocEntry[] _entries;

--- a/src/ARMeilleure/CodeGen/RegisterAllocators/CopyResolver.cs
+++ b/src/ARMeilleure/CodeGen/RegisterAllocators/CopyResolver.cs
@@ -31,7 +31,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators

            public ParallelCopy()
            {
-                _copies = [];
+                _copies = new List<Copy>();
            }

            public void AddCopy(Register dest, Register source, OperandType type)
@@ -218,7 +218,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators

        public Operation[] Sequence()
        {
-            List<Operation> sequence = [];
+            List<Operation> sequence = new();

            if (_spillQueue != null)
            {
--- a/src/ARMeilleure/CodeGen/RegisterAllocators/LinearScanAllocator.cs
+++ b/src/ARMeilleure/CodeGen/RegisterAllocators/LinearScanAllocator.cs
@@ -115,7 +115,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
        {
            NumberLocals(cfg, regMasks.RegistersCount);

-            AllocationContext context = new(stackAlloc, regMasks, _intervals.Count);
+            AllocationContext context = new AllocationContext(stackAlloc, regMasks, _intervals.Count);

            BuildIntervals(cfg, context);

@@ -799,8 +799,8 @@ namespace ARMeilleure.CodeGen.RegisterAllocators

        private void NumberLocals(ControlFlowGraph cfg, int registersCount)
        {
-            _operationNodes = [];
-            _intervals = [];
+            _operationNodes = new List<(IntrusiveList<Operation>, Operation)>();
+            _intervals = new List<LiveInterval>();

            for (int index = 0; index < registersCount; index++)
            {
@@ -839,7 +839,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
                        {
                            dest.NumberLocal(_intervals.Count);

-                            LiveInterval interval = new(dest);
+                            LiveInterval interval = new LiveInterval(dest);
                            _intervals.Add(interval);

                            SetVisited(dest);
@@ -980,7 +980,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators

            _blockLiveIn = blkLiveIn;

-            _blockEdges = [];
+            _blockEdges = new HashSet<int>();

            // Compute lifetime intervals.
            int operationPos = _operationsCount;
--- a/src/ARMeilleure/CodeGen/X86/Assembler.cs
+++ b/src/ARMeilleure/CodeGen/X86/Assembler.cs
@@ -75,9 +75,9 @@ namespace ARMeilleure.CodeGen.X86
        {
            _stream = stream;
            _labels = new Dictionary<Operand, long>();
-            _jumps = [];
+            _jumps = new List<Jump>();

-            _relocs = relocatable ? [] : null;
+            _relocs = relocatable ? new List<Reloc>() : null;
        }

        public void MarkLabel(Operand label)
@@ -1412,14 +1412,14 @@ namespace ARMeilleure.CodeGen.X86
            _stream.Seek(0, SeekOrigin.Begin);

            using RecyclableMemoryStream codeStream = MemoryStreamManager.Shared.GetStream();
-            Assembler assembler = new(codeStream, HasRelocs);
+            Assembler assembler = new Assembler(codeStream, HasRelocs);

            bool hasRelocs = HasRelocs;
            int relocIndex = 0;
            int relocOffset = 0;
            RelocEntry[] relocEntries = hasRelocs
                ? new RelocEntry[relocs.Length]
-                : [];
+                : Array.Empty<RelocEntry>();

            for (int i = 0; i < jumps.Length; i++)
            {
@@ -1471,7 +1471,7 @@ namespace ARMeilleure.CodeGen.X86
            _stream.CopyTo(codeStream);

            byte[] code = codeStream.ToArray();
-            RelocInfo relocInfo = new(relocEntries);
+            RelocInfo relocInfo = new RelocInfo(relocEntries);

            return (code, relocInfo);
        }
--- a/src/ARMeilleure/CodeGen/X86/CodeGenerator.cs
+++ b/src/ARMeilleure/CodeGen/X86/CodeGenerator.cs
@@ -1748,7 +1748,7 @@ namespace ARMeilleure.CodeGen.X86

        private static UnwindInfo WritePrologue(CodeGenContext context)
        {
-            List<UnwindPushEntry> pushEntries = [];
+            List<UnwindPushEntry> pushEntries = new();

            Operand rsp = Register(X86Register.Rsp);

--- a/src/ARMeilleure/CodeGen/X86/HardwareCapabilities.cs
+++ b/src/ARMeilleure/CodeGen/X86/HardwareCapabilities.cs
@@ -40,12 +40,12 @@ namespace ARMeilleure.CodeGen.X86
                return 0;
            }

-            ReadOnlySpan<byte> asmGetXcr0 =
-            [
+            ReadOnlySpan<byte> asmGetXcr0 = new byte[]
+            {
                0x31, 0xc9, // xor ecx, ecx
                0xf, 0x01, 0xd0, // xgetbv
-                0xc3 // ret
-            ];
+                0xc3, // ret
+            };

            using MemoryBlock memGetXcr0 = new((ulong)asmGetXcr0.Length);

--- a/src/ARMeilleure/CodeGen/X86/PreAllocator.cs
+++ b/src/ARMeilleure/CodeGen/X86/PreAllocator.cs
@@ -124,13 +124,13 @@ namespace ARMeilleure.CodeGen.X86
                            {
                                int stackOffset = stackAlloc.Allocate(OperandType.I32);

-                                node.SetSources([Const(stackOffset), node.GetSource(0)]);
+                                node.SetSources(new Operand[] { Const(stackOffset), node.GetSource(0) });
                            }
                            else if (node.Intrinsic == Intrinsic.X86Stmxcsr)
                            {
                                int stackOffset = stackAlloc.Allocate(OperandType.I32);

-                                node.SetSources([Const(stackOffset)]);
+                                node.SetSources(new Operand[] { Const(stackOffset) });
                            }
                            break;
                    }
@@ -253,8 +253,8 @@ namespace ARMeilleure.CodeGen.X86
                            node = nodes.AddAfter(node, Operation(Instruction.VectorCreateScalar, dest, rax));
                            nodes.AddAfter(node, Operation(Instruction.VectorInsert, dest, dest, rdx, Const(1)));

-                            operation.SetDestinations([rdx, rax]);
-                            operation.SetSources([operation.GetSource(0), rdx, rax, rcx, rbx]);
+                            operation.SetDestinations(new Operand[] { rdx, rax });
+                            operation.SetSources(new Operand[] { operation.GetSource(0), rdx, rax, rcx, rbx });
                        }
                        else
                        {
@@ -274,7 +274,7 @@ namespace ARMeilleure.CodeGen.X86

                            nodes.AddBefore(node, Operation(Instruction.Copy, temp, newValue));

-                            node.SetSources([node.GetSource(0), rax, temp]);
+                            node.SetSources(new Operand[] { node.GetSource(0), rax, temp });

                            nodes.AddAfter(node, Operation(Instruction.Copy, dest, rax));

@@ -303,7 +303,7 @@ namespace ARMeilleure.CodeGen.X86

                            nodes.AddAfter(node, Operation(Instruction.Copy, dest, rax));

-                            node.SetSources([rdx, rax, node.GetSource(1)]);
+                            node.SetSources(new Operand[] { rdx, rax, node.GetSource(1) });
                            node.Destination = rax;
                        }

@@ -348,7 +348,7 @@ namespace ARMeilleure.CodeGen.X86

                        nodes.AddAfter(node, Operation(Instruction.Copy, dest, rdx));

-                        node.SetDestinations([rdx, rax]);
+                        node.SetDestinations(new Operand[] { rdx, rax });

                        break;
                    }
--- a/src/ARMeilleure/CodeGen/X86/PreAllocatorSystemV.cs
+++ b/src/ARMeilleure/CodeGen/X86/PreAllocatorSystemV.cs
@@ -14,10 +14,10 @@ namespace ARMeilleure.CodeGen.X86
        {
            Operand dest = node.Destination;

-            List<Operand> sources =
-            [
-                node.GetSource(0)
-            ];
+            List<Operand> sources = new()
+            {
+                node.GetSource(0),
+            };

            int argsCount = node.SourcesCount - 1;

@@ -117,10 +117,10 @@ namespace ARMeilleure.CodeGen.X86

        public static void InsertTailcallCopies(IntrusiveList<Operation> nodes, Operation node)
        {
-            List<Operand> sources =
-            [
-                node.GetSource(0)
-            ];
+            List<Operand> sources = new()
+            {
+                node.GetSource(0),
+            };

            int argsCount = node.SourcesCount - 1;

--- a/src/ARMeilleure/CodeGen/X86/PreAllocatorWindows.cs
+++ b/src/ARMeilleure/CodeGen/X86/PreAllocatorWindows.cs
@@ -321,7 +321,7 @@ namespace ARMeilleure.CodeGen.X86
                nodes.AddBefore(node, retCopyOp);
            }

-            node.SetSources([]);
+            node.SetSources(Array.Empty<Operand>());
        }
    }
 }
--- a/src/ARMeilleure/CodeGen/X86/X86Optimizer.cs
+++ b/src/ARMeilleure/CodeGen/X86/X86Optimizer.cs
@@ -13,7 +13,7 @@ namespace ARMeilleure.CodeGen.X86

        public static void RunPass(ControlFlowGraph cfg)
        {
-            Dictionary<ulong, Operand> constants = new();
+            Dictionary<ulong, Operand> constants = new Dictionary<ulong, Operand>();

            Operand GetConstantCopy(BasicBlock block, Operation operation, Operand source)
            {
--- a/src/ARMeilleure/Common/AddressTablePresets.cs
+++ b/src/ARMeilleure/Common/AddressTablePresets.cs
@@ -3,46 +3,52 @@ namespace ARMeilleure.Common
    public static class AddressTablePresets
    {
        private static readonly AddressTableLevel[] _levels64Bit =
-        [
-            new(31, 17),
+            new AddressTableLevel[]
+            {
+                new(31, 17),
                new(23,  8),
                new(15,  8),
                new( 7,  8),
-                new( 2,  5)
-        ];
+                new( 2,  5),
+            };

        private static readonly AddressTableLevel[] _levels32Bit =
-        [
-            new(31, 17),
+            new AddressTableLevel[]
+            {
+                new(31, 17),
                new(23,  8),
                new(15,  8),
                new( 7,  8),
-                new( 1,  6)
-        ];
+                new( 1,  6),
+            };

        private static readonly AddressTableLevel[] _levels64BitSparseTiny =
-        [
-            new( 11, 28),
-                new( 2, 9)
-        ];
+            new AddressTableLevel[]
+            {
+                new( 11, 28),
+                new( 2, 9),
+            };

        private static readonly AddressTableLevel[] _levels32BitSparseTiny =
-        [
-            new( 10, 22),
-                new( 1, 9)
-        ];
+            new AddressTableLevel[]
+            {
+                new( 10, 22),
+                new( 1, 9),
+            };

        private static readonly AddressTableLevel[] _levels64BitSparseGiant =
-        [
-            new( 38, 1),
-                new( 2, 36)
-        ];
+            new AddressTableLevel[]
+            {
+                new( 38, 1),
+                new( 2, 36),
+            };

        private static readonly AddressTableLevel[] _levels32BitSparseGiant =
-        [
-            new( 31, 1),
-                new( 1, 30)
-        ];
+            new AddressTableLevel[]
+            {
+                new( 31, 1),
+                new( 1, 30),
+            };

        //high power will run worse on DDR3 systems and some DDR4 systems due to the higher ram utilization
        //low power will never run worse than non-sparse, but for most systems it won't be necessary
--- a/src/ARMeilleure/Common/BitMap.cs
+++ b/src/ARMeilleure/Common/BitMap.cs
@@ -130,12 +130,12 @@ namespace ARMeilleure.Common
            if (count > _count)
            {
                long* oldMask = _masks;
-                Span<long> oldSpan = new(_masks, _count);
+                Span<long> oldSpan = new Span<long>(_masks, _count);

                _masks = _allocator.Allocate<long>((uint)count);
                _count = count;

-                Span<long> newSpan = new(_masks, _count);
+                Span<long> newSpan = new Span<long>(_masks, _count);

                oldSpan.CopyTo(newSpan);
                newSpan[oldSpan.Length..].Clear();
--- a/src/ARMeilleure/Common/BitUtils.cs
+++ b/src/ARMeilleure/Common/BitUtils.cs
@@ -5,7 +5,7 @@ namespace ARMeilleure.Common
 {
    static class BitUtils
    {
-        private static ReadOnlySpan<sbyte> HbsNibbleLut => [-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3];
+        private static ReadOnlySpan<sbyte> HbsNibbleLut => new sbyte[] { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };

        public static long FillWithOnes(int bits)
        {
--- a/src/ARMeilleure/Decoders/Block.cs
+++ b/src/ARMeilleure/Decoders/Block.cs
@@ -17,7 +17,7 @@ namespace ARMeilleure.Decoders

        public Block()
        {
-            OpCodes = [];
+            OpCodes = new List<OpCode>();
        }

        public Block(ulong address) : this()
--- a/src/ARMeilleure/Decoders/Decoder.cs
+++ b/src/ARMeilleure/Decoders/Decoder.cs
@@ -20,7 +20,7 @@ namespace ARMeilleure.Decoders

        public static Block[] Decode(IMemoryManager memory, ulong address, ExecutionMode mode, bool highCq, DecoderMode dMode)
        {
-            List<Block> blocks = [];
+            List<Block> blocks = new();

            Queue<Block> workQueue = new();

--- a/src/ARMeilleure/Decoders/OpCode32SimdMemPair.cs
+++ b/src/ARMeilleure/Decoders/OpCode32SimdMemPair.cs
@@ -5,12 +5,12 @@ namespace ARMeilleure.Decoders
    class OpCode32SimdMemPair : OpCode32, IOpCode32Simd
    {
        private static readonly int[] _regsMap =
-        [
+        {
            1, 1, 4, 2,
            1, 1, 3, 1,
            1, 1, 2, 1,
-            1, 1, 1, 1
-        ];
+            1, 1, 1, 1,
+        };

        public int Vd { get; }
        public int Rn { get; }
--- a/src/ARMeilleure/Decoders/OpCodeT16IfThen.cs
+++ b/src/ARMeilleure/Decoders/OpCodeT16IfThen.cs
@@ -12,7 +12,7 @@ namespace ARMeilleure.Decoders

        public OpCodeT16IfThen(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
        {
-            List<Condition> conds = [];
+            List<Condition> conds = new();

            int cond = (opCode >> 4) & 0xf;
            int mask = opCode & 0xf;
--- a/src/ARMeilleure/Decoders/OpCodeTable.cs
+++ b/src/ARMeilleure/Decoders/OpCodeTable.cs
@@ -29,9 +29,9 @@ namespace ARMeilleure.Decoders
            }
        }

-        private static readonly List<InstInfo> _allInstA32 = [];
-        private static readonly List<InstInfo> _allInstT32 = [];
-        private static readonly List<InstInfo> _allInstA64 = [];
+        private static readonly List<InstInfo> _allInstA32 = new();
+        private static readonly List<InstInfo> _allInstT32 = new();
+        private static readonly List<InstInfo> _allInstA64 = new();

        private static readonly InstInfo[][] _instA32FastLookup = new InstInfo[FastLookupSize][];
        private static readonly InstInfo[][] _instT32FastLookup = new InstInfo[FastLookupSize][];
@@ -1330,7 +1330,7 @@ namespace ARMeilleure.Decoders

            for (int index = 0; index < temp.Length; index++)
            {
-                temp[index] = [];
+                temp[index] = new List<InstInfo>();
            }

            foreach (InstInfo inst in allInsts)
--- a/src/ARMeilleure/Decoders/Optimizations/TailCallRemover.cs
+++ b/src/ARMeilleure/Decoders/Optimizations/TailCallRemover.cs
@@ -69,7 +69,7 @@ namespace ARMeilleure.Decoders.Optimizations
                }
            }

-            List<Block> newBlocks = new(blocks.Count);
+            List<Block> newBlocks = new List<Block>(blocks.Count);

            // Finally, rebuild decoded block list, ignoring blocks outside the contiguous range.
            for (int i = 0; i < blocks.Count; i++)
--- a/src/ARMeilleure/Diagnostics/IRDumper.cs
+++ b/src/ARMeilleure/Diagnostics/IRDumper.cs
@@ -285,7 +285,7 @@ namespace ARMeilleure.Diagnostics

        public static string GetDump(ControlFlowGraph cfg)
        {
-            IRDumper dumper = new(1);
+            IRDumper dumper = new IRDumper(1);

            for (BasicBlock block = cfg.Blocks.First; block != null; block = block.ListNext)
            {
--- a/src/ARMeilleure/Diagnostics/Symbols.cs
+++ b/src/ARMeilleure/Diagnostics/Symbols.cs
@@ -29,7 +29,7 @@ namespace ARMeilleure.Diagnostics
        static Symbols()
        {
            _symbols = new ConcurrentDictionary<ulong, string>();
-            _rangedSymbols = [];
+            _rangedSymbols = new List<RangedSymbol>();
        }

        public static string Get(ulong address)
--- a/src/ARMeilleure/Instructions/CryptoHelper.cs
+++ b/src/ARMeilleure/Instructions/CryptoHelper.cs
@@ -9,8 +9,8 @@ namespace ARMeilleure.Instructions
    {
        #region "LookUp Tables"
 #pragma warning disable IDE1006 // Naming rule violation
-        private static ReadOnlySpan<byte> _sBox =>
-        [
+        private static ReadOnlySpan<byte> _sBox => new byte[]
+        {
            0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
            0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
            0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
@@ -26,11 +26,11 @@ namespace ARMeilleure.Instructions
            0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
            0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
            0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-            0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
-        ];
+            0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
+        };

-        private static ReadOnlySpan<byte> _invSBox =>
-        [
+        private static ReadOnlySpan<byte> _invSBox => new byte[]
+        {
            0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
            0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
            0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
@@ -46,11 +46,11 @@ namespace ARMeilleure.Instructions
            0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
            0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
            0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
-            0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
-        ];
+            0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d,
+        };

-        private static ReadOnlySpan<byte> _gfMul02 =>
-        [
+        private static ReadOnlySpan<byte> _gfMul02 => new byte[]
+        {
            0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
            0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
            0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
@@ -66,11 +66,11 @@ namespace ARMeilleure.Instructions
            0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85,
            0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5,
            0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
-            0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5
-        ];
+            0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5,
+        };

-        private static ReadOnlySpan<byte> _gfMul03 =>
-        [
+        private static ReadOnlySpan<byte> _gfMul03 => new byte[]
+        {
            0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11,
            0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21,
            0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
@@ -86,11 +86,11 @@ namespace ARMeilleure.Instructions
            0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a,
            0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a,
            0x3b, 0x38, 0x3d, 0x3e, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
-            0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a
-        ];
+            0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a,
+        };

-        private static ReadOnlySpan<byte> _gfMul09 =>
-        [
+        private static ReadOnlySpan<byte> _gfMul09 => new byte[]
+        {
            0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
            0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7,
            0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
@@ -106,11 +106,11 @@ namespace ARMeilleure.Instructions
            0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed,
            0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d,
            0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
-            0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46
-        ];
+            0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46,
+        };

-        private static ReadOnlySpan<byte> _gfMul0B =>
-        [
+        private static ReadOnlySpan<byte> _gfMul0B => new byte[]
+        {
            0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69,
            0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9,
            0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
@@ -126,11 +126,11 @@ namespace ARMeilleure.Instructions
            0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68,
            0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8,
            0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
-            0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3
-        ];
+            0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3,
+        };

-        private static ReadOnlySpan<byte> _gfMul0D =>
-        [
+        private static ReadOnlySpan<byte> _gfMul0D => new byte[]
+        {
            0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b,
            0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b,
            0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
@@ -146,11 +146,11 @@ namespace ARMeilleure.Instructions
            0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc,
            0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c,
            0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
-            0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97
-        ];
+            0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97,
+        };

-        private static ReadOnlySpan<byte> _gfMul0E =>
-        [
+        private static ReadOnlySpan<byte> _gfMul0E => new byte[]
+        {
            0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a,
            0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba,
            0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
@@ -166,18 +166,18 @@ namespace ARMeilleure.Instructions
            0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6,
            0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56,
            0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
-            0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d
-        ];
+            0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d,
+        };

-        private static ReadOnlySpan<byte> _srPerm =>
-        [
-            0, 13, 10, 7, 4, 1, 14, 11, 8, 5, 2, 15, 12, 9, 6, 3
-        ];
+        private static ReadOnlySpan<byte> _srPerm => new byte[]
+        {
+            0, 13, 10, 7, 4, 1, 14, 11, 8, 5, 2, 15, 12, 9, 6, 3,
+        };

-        private static ReadOnlySpan<byte> _isrPerm =>
-        [
-            0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11
-        ];
+        private static ReadOnlySpan<byte> _isrPerm => new byte[]
+        {
+            0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11,
+        };
 #pragma warning restore IDE1006
        #endregion

--- a/src/ARMeilleure/Instructions/InstEmitSimdCvt32.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdCvt32.cs
@@ -245,8 +245,8 @@ namespace ARMeilleure.Instructions
            string name = nameof(Math.Round);

            MethodInfo info = (op.Size & 1) == 0
-                ? typeof(MathF).GetMethod(name, [typeof(float), typeof(MidpointRounding)])
-                : typeof(Math).GetMethod(name, [typeof(double), typeof(MidpointRounding)]);
+                ? typeof(MathF).GetMethod(name, new Type[] { typeof(float), typeof(MidpointRounding) })
+                : typeof(Math).GetMethod(name, new Type[] { typeof(double), typeof(MidpointRounding) });

            return context.Call(info, n, Const((int)roundMode));
        }
--- a/src/ARMeilleure/Instructions/InstEmitSimdHelper.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdHelper.cs
@@ -18,19 +18,19 @@ namespace ARMeilleure.Instructions
    static class InstEmitSimdHelper
    {
        #region "Masks"
-        public static readonly long[] EvenMasks =
-        [
+        public static readonly long[] EvenMasks = new long[]
+        {
            14L << 56 | 12L << 48 | 10L << 40 | 08L << 32 | 06L << 24 | 04L << 16 | 02L << 8 | 00L << 0, // B
            13L << 56 | 12L << 48 | 09L << 40 | 08L << 32 | 05L << 24 | 04L << 16 | 01L << 8 | 00L << 0, // H
-            11L << 56 | 10L << 48 | 09L << 40 | 08L << 32 | 03L << 24 | 02L << 16 | 01L << 8 | 00L << 0 // S
-        ];
+            11L << 56 | 10L << 48 | 09L << 40 | 08L << 32 | 03L << 24 | 02L << 16 | 01L << 8 | 00L << 0, // S
+        };

-        public static readonly long[] OddMasks =
-        [
+        public static readonly long[] OddMasks = new long[]
+        {
            15L << 56 | 13L << 48 | 11L << 40 | 09L << 32 | 07L << 24 | 05L << 16 | 03L << 8 | 01L << 0, // B
            15L << 56 | 14L << 48 | 11L << 40 | 10L << 32 | 07L << 24 | 06L << 16 | 03L << 8 | 02L << 0, // H
-            15L << 56 | 14L << 48 | 13L << 40 | 12L << 32 | 07L << 24 | 06L << 16 | 05L << 8 | 04L << 0 // S
-        ];
+            15L << 56 | 14L << 48 | 13L << 40 | 12L << 32 | 07L << 24 | 06L << 16 | 05L << 8 | 04L << 0, // S
+        };

        public const long ZeroMask = 128L << 56 | 128L << 48 | 128L << 40 | 128L << 32 | 128L << 24 | 128L << 16 | 128L << 8 | 128L << 0;

@@ -44,118 +44,118 @@ namespace ARMeilleure.Instructions
        #endregion

        #region "X86 SSE Intrinsics"
-        public static readonly Intrinsic[] X86PaddInstruction =
-        [
+        public static readonly Intrinsic[] X86PaddInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Paddb,
            Intrinsic.X86Paddw,
            Intrinsic.X86Paddd,
-            Intrinsic.X86Paddq
-        ];
+            Intrinsic.X86Paddq,
+        };

-        public static readonly Intrinsic[] X86PcmpeqInstruction =
-        [
+        public static readonly Intrinsic[] X86PcmpeqInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pcmpeqb,
            Intrinsic.X86Pcmpeqw,
            Intrinsic.X86Pcmpeqd,
-            Intrinsic.X86Pcmpeqq
-        ];
+            Intrinsic.X86Pcmpeqq,
+        };

-        public static readonly Intrinsic[] X86PcmpgtInstruction =
-        [
+        public static readonly Intrinsic[] X86PcmpgtInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pcmpgtb,
            Intrinsic.X86Pcmpgtw,
            Intrinsic.X86Pcmpgtd,
-            Intrinsic.X86Pcmpgtq
-        ];
+            Intrinsic.X86Pcmpgtq,
+        };

-        public static readonly Intrinsic[] X86PmaxsInstruction =
-        [
+        public static readonly Intrinsic[] X86PmaxsInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pmaxsb,
            Intrinsic.X86Pmaxsw,
-            Intrinsic.X86Pmaxsd
-        ];
+            Intrinsic.X86Pmaxsd,
+        };

-        public static readonly Intrinsic[] X86PmaxuInstruction =
-        [
+        public static readonly Intrinsic[] X86PmaxuInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pmaxub,
            Intrinsic.X86Pmaxuw,
-            Intrinsic.X86Pmaxud
-        ];
+            Intrinsic.X86Pmaxud,
+        };

-        public static readonly Intrinsic[] X86PminsInstruction =
-        [
+        public static readonly Intrinsic[] X86PminsInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pminsb,
            Intrinsic.X86Pminsw,
-            Intrinsic.X86Pminsd
-        ];
+            Intrinsic.X86Pminsd,
+        };

-        public static readonly Intrinsic[] X86PminuInstruction =
-        [
+        public static readonly Intrinsic[] X86PminuInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pminub,
            Intrinsic.X86Pminuw,
-            Intrinsic.X86Pminud
-        ];
+            Intrinsic.X86Pminud,
+        };

-        public static readonly Intrinsic[] X86PmovsxInstruction =
-        [
+        public static readonly Intrinsic[] X86PmovsxInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pmovsxbw,
            Intrinsic.X86Pmovsxwd,
-            Intrinsic.X86Pmovsxdq
-        ];
+            Intrinsic.X86Pmovsxdq,
+        };

-        public static readonly Intrinsic[] X86PmovzxInstruction =
-        [
+        public static readonly Intrinsic[] X86PmovzxInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Pmovzxbw,
            Intrinsic.X86Pmovzxwd,
-            Intrinsic.X86Pmovzxdq
-        ];
+            Intrinsic.X86Pmovzxdq,
+        };

-        public static readonly Intrinsic[] X86PsllInstruction =
-        [
+        public static readonly Intrinsic[] X86PsllInstruction = new Intrinsic[]
+        {
            0,
            Intrinsic.X86Psllw,
            Intrinsic.X86Pslld,
-            Intrinsic.X86Psllq
-        ];
+            Intrinsic.X86Psllq,
+        };

-        public static readonly Intrinsic[] X86PsraInstruction =
-        [
+        public static readonly Intrinsic[] X86PsraInstruction = new Intrinsic[]
+        {
            0,
            Intrinsic.X86Psraw,
-            Intrinsic.X86Psrad
-        ];
+            Intrinsic.X86Psrad,
+        };

-        public static readonly Intrinsic[] X86PsrlInstruction =
-        [
+        public static readonly Intrinsic[] X86PsrlInstruction = new Intrinsic[]
+        {
            0,
            Intrinsic.X86Psrlw,
            Intrinsic.X86Psrld,
-            Intrinsic.X86Psrlq
-        ];
+            Intrinsic.X86Psrlq,
+        };

-        public static readonly Intrinsic[] X86PsubInstruction =
-        [
+        public static readonly Intrinsic[] X86PsubInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Psubb,
            Intrinsic.X86Psubw,
            Intrinsic.X86Psubd,
-            Intrinsic.X86Psubq
-        ];
+            Intrinsic.X86Psubq,
+        };

-        public static readonly Intrinsic[] X86PunpckhInstruction =
-        [
+        public static readonly Intrinsic[] X86PunpckhInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Punpckhbw,
            Intrinsic.X86Punpckhwd,
            Intrinsic.X86Punpckhdq,
-            Intrinsic.X86Punpckhqdq
-        ];
+            Intrinsic.X86Punpckhqdq,
+        };

-        public static readonly Intrinsic[] X86PunpcklInstruction =
-        [
+        public static readonly Intrinsic[] X86PunpcklInstruction = new Intrinsic[]
+        {
            Intrinsic.X86Punpcklbw,
            Intrinsic.X86Punpcklwd,
            Intrinsic.X86Punpckldq,
-            Intrinsic.X86Punpcklqdq
-        ];
+            Intrinsic.X86Punpcklqdq,
+        };
        #endregion

        public static void EnterArmFpMode(EmitterContext context, Func<FPState, Operand> getFpFlag)
@@ -460,8 +460,8 @@ namespace ARMeilleure.Instructions
            IOpCodeSimd op = (IOpCodeSimd)context.CurrOp;

            MethodInfo info = (op.Size & 1) == 0
-                ? typeof(MathHelperF).GetMethod(name, [typeof(float)])
-                : typeof(MathHelper).GetMethod(name, [typeof(double)]);
+                ? typeof(MathHelperF).GetMethod(name, new Type[] { typeof(float) })
+                : typeof(MathHelper).GetMethod(name, new Type[] { typeof(double) });

            return context.Call(info, n);
        }
@@ -473,8 +473,8 @@ namespace ARMeilleure.Instructions
            string name = nameof(MathHelper.Round);

            MethodInfo info = (op.Size & 1) == 0
-                ? typeof(MathHelperF).GetMethod(name, [typeof(float), typeof(int)])
-                : typeof(MathHelper).GetMethod(name, [typeof(double), typeof(int)]);
+                ? typeof(MathHelperF).GetMethod(name, new Type[] { typeof(float), typeof(int) })
+                : typeof(MathHelper).GetMethod(name, new Type[] { typeof(double), typeof(int) });

            return context.Call(info, n, Const((int)roundMode));
        }
--- a/src/ARMeilleure/Instructions/InstEmitSimdMove.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdMove.cs
@@ -12,17 +12,17 @@ namespace ARMeilleure.Instructions
    static partial class InstEmit
    {
        #region "Masks"
-        private static readonly long[] _masksE0_Uzp =
-        [
+        private static readonly long[] _masksE0_Uzp = new long[]
+        {
            13L << 56 | 09L << 48 | 05L << 40 | 01L << 32 | 12L << 24 | 08L << 16 | 04L << 8 | 00L << 0,
-            11L << 56 | 10L << 48 | 03L << 40 | 02L << 32 | 09L << 24 | 08L << 16 | 01L << 8 | 00L << 0
-        ];
+            11L << 56 | 10L << 48 | 03L << 40 | 02L << 32 | 09L << 24 | 08L << 16 | 01L << 8 | 00L << 0,
+        };

-        private static readonly long[] _masksE1_Uzp =
-        [
+        private static readonly long[] _masksE1_Uzp = new long[]
+        {
            15L << 56 | 11L << 48 | 07L << 40 | 03L << 32 | 14L << 24 | 10L << 16 | 06L << 8 | 02L << 0,
-            15L << 56 | 14L << 48 | 07L << 40 | 06L << 32 | 13L << 24 | 12L << 16 | 05L << 8 | 04L << 0
-        ];
+            15L << 56 | 14L << 48 | 07L << 40 | 06L << 32 | 13L << 24 | 12L << 16 | 05L << 8 | 04L << 0,
+        };
        #endregion

        public static void Dup_Gp(ArmEmitterContext context)
@@ -601,7 +601,7 @@ namespace ARMeilleure.Instructions
            {
                Operand d = GetVec(op.Rd);

-                List<Operand> args = [];
+                List<Operand> args = new();

                if (!isTbl)
                {
--- a/src/ARMeilleure/Instructions/InstEmitSimdMove32.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdMove32.cs
@@ -13,17 +13,17 @@ namespace ARMeilleure.Instructions
    {
        #region "Masks"
        // Same as InstEmitSimdMove, as the instructions do the same thing.
-        private static readonly long[] _masksE0_Uzp =
-        [
+        private static readonly long[] _masksE0_Uzp = new long[]
+        {
            13L << 56 | 09L << 48 | 05L << 40 | 01L << 32 | 12L << 24 | 08L << 16 | 04L << 8 | 00L << 0,
-            11L << 56 | 10L << 48 | 03L << 40 | 02L << 32 | 09L << 24 | 08L << 16 | 01L << 8 | 00L << 0
-        ];
+            11L << 56 | 10L << 48 | 03L << 40 | 02L << 32 | 09L << 24 | 08L << 16 | 01L << 8 | 00L << 0,
+        };

-        private static readonly long[] _masksE1_Uzp =
-        [
+        private static readonly long[] _masksE1_Uzp = new long[]
+        {
            15L << 56 | 11L << 48 | 07L << 40 | 03L << 32 | 14L << 24 | 10L << 16 | 06L << 8 | 02L << 0,
-            15L << 56 | 14L << 48 | 07L << 40 | 06L << 32 | 13L << 24 | 12L << 16 | 05L << 8 | 04L << 0
-        ];
+            15L << 56 | 14L << 48 | 07L << 40 | 06L << 32 | 13L << 24 | 12L << 16 | 05L << 8 | 04L << 0,
+        };
        #endregion

        public static void Vmov_I(ArmEmitterContext context)
--- a/src/ARMeilleure/Instructions/InstEmitSimdShift.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdShift.cs
@@ -17,10 +17,10 @@ namespace ARMeilleure.Instructions
    static partial class InstEmit
    {
        #region "Masks"
-        private static readonly long[] _masks_SliSri =
-        [
-            0x0101010101010101L, 0x0001000100010001L, 0x0000000100000001L, 0x0000000000000001L
-        ];
+        private static readonly long[] _masks_SliSri = new long[] // Replication masks.
+        {
+            0x0101010101010101L, 0x0001000100010001L, 0x0000000100000001L, 0x0000000000000001L,
+        };
        #endregion

        public static void Rshrn_V(ArmEmitterContext context)
--- a/src/ARMeilleure/Instructions/SoftFallback.cs
+++ b/src/ARMeilleure/Instructions/SoftFallback.cs
@@ -211,7 +211,7 @@ namespace ARMeilleure.Instructions
            return (ulong)(size - 1);
        }

-        private static ReadOnlySpan<byte> ClzNibbleTbl => [4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0];
+        private static ReadOnlySpan<byte> ClzNibbleTbl => new byte[] { 4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };

        [UnmanagedCallersOnly]
        public static ulong CountLeadingZeros(ulong value, int size) // size is 8, 16, 32 or 64 (SIMD&FP or Base Inst.).
--- a/src/ARMeilleure/IntermediateRepresentation/BasicBlock.cs
+++ b/src/ARMeilleure/IntermediateRepresentation/BasicBlock.cs
@@ -27,7 +27,7 @@ namespace ARMeilleure.IntermediateRepresentation
        {
            get
            {
-                _domFrontiers ??= [];
+                _domFrontiers ??= new HashSet<BasicBlock>();

                return _domFrontiers;
            }
@@ -38,7 +38,7 @@ namespace ARMeilleure.IntermediateRepresentation
        public BasicBlock(int index)
        {
            Operations = new IntrusiveList<Operation>();
-            Predecessors = [];
+            Predecessors = new List<BasicBlock>();

            Index = index;
        }
--- a/src/ARMeilleure/IntermediateRepresentation/MemoryOperand.cs
+++ b/src/ARMeilleure/IntermediateRepresentation/MemoryOperand.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;

--- a/src/ARMeilleure/IntermediateRepresentation/Operand.cs
+++ b/src/ARMeilleure/IntermediateRepresentation/Operand.cs
@@ -304,7 +304,7 @@ namespace ARMeilleure.IntermediateRepresentation
                ushort newCount = checked((ushort)(count + 1));
                ushort newCapacity = (ushort)Math.Min(capacity * 2, ushort.MaxValue);

-                Span<T> oldSpan = new(data, count);
+                Span<T> oldSpan = new Span<T>(data, count);

                capacity = newCapacity;
                data = Allocators.References.Allocate<T>(capacity);
@@ -338,7 +338,7 @@ namespace ARMeilleure.IntermediateRepresentation
                    throw new OverflowException();
                }

-                Span<T> oldSpan = new(data, (int)count);
+                Span<T> oldSpan = new Span<T>(data, (int)count);

                capacity = newCapacity;
                data = Allocators.References.Allocate<T>(capacity);
@@ -352,7 +352,7 @@ namespace ARMeilleure.IntermediateRepresentation

        private static void Remove<T>(in T item, ref T* data, ref ushort count) where T : unmanaged
        {
-            Span<T> span = new(data, count);
+            Span<T> span = new Span<T>(data, count);

            for (int i = 0; i < span.Length; i++)
            {
@@ -372,7 +372,7 @@ namespace ARMeilleure.IntermediateRepresentation

        private static void Remove<T>(in T item, ref T* data, ref uint count) where T : unmanaged
        {
-            Span<T> span = new(data, (int)count);
+            Span<T> span = new Span<T>(data, (int)count);

            for (int i = 0; i < span.Length; i++)
            {
--- a/src/ARMeilleure/Native/JitSupportDarwin.cs
+++ b/src/ARMeilleure/Native/JitSupportDarwin.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;

--- a/src/ARMeilleure/Signal/NativeSignalHandlerGenerator.cs
+++ b/src/ARMeilleure/Signal/NativeSignalHandlerGenerator.cs
@@ -198,7 +198,7 @@ namespace ARMeilleure.Signal

            ControlFlowGraph cfg = context.GetControlFlowGraph();

-            OperandType[] argTypes = [OperandType.I32, OperandType.I64, OperandType.I64];
+            OperandType[] argTypes = new OperandType[] { OperandType.I32, OperandType.I64, OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, OperandType.None, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Code;
        }
@@ -252,7 +252,7 @@ namespace ARMeilleure.Signal

            ControlFlowGraph cfg = context.GetControlFlowGraph();

-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Code;
        }
--- a/src/ARMeilleure/Signal/TestMethods.cs
+++ b/src/ARMeilleure/Signal/TestMethods.cs
@@ -1,5 +1,6 @@
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.Translation;
+using System;
 using System.Runtime.InteropServices;
 using static ARMeilleure.IntermediateRepresentation.Operand.Factory;

@@ -29,7 +30,7 @@ namespace ARMeilleure.Signal

            ControlFlowGraph cfg = context.GetControlFlowGraph();

-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<DebugPartialUnmap>();
        }
@@ -46,7 +47,7 @@ namespace ARMeilleure.Signal

            ControlFlowGraph cfg = context.GetControlFlowGraph();

-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<DebugThreadLocalMapGetOrReserve>();
        }
@@ -75,7 +76,7 @@ namespace ARMeilleure.Signal

            ControlFlowGraph cfg = context.GetControlFlowGraph();

-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, OperandType.None, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<DebugNativeWriteLoop>();
        }
--- a/src/ARMeilleure/Signal/WindowsPartialUnmapHandler.cs
+++ b/src/ARMeilleure/Signal/WindowsPartialUnmapHandler.cs
@@ -1,6 +1,7 @@
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.Translation;
 using Ryujinx.Common.Memory.PartialUnmaps;
+using System;
 using System.Runtime.InteropServices;
 using static ARMeilleure.IntermediateRepresentation.Operand.Factory;

--- a/src/ARMeilleure/State/ExecutionContext.cs
+++ b/src/ARMeilleure/State/ExecutionContext.cs
@@ -1,4 +1,5 @@
 using ARMeilleure.Memory;
+using System;

 namespace ARMeilleure.State
 {
--- a/src/ARMeilleure/Translation/ArmEmitterContext.cs
+++ b/src/ARMeilleure/Translation/ArmEmitterContext.cs
@@ -6,6 +6,7 @@ using ARMeilleure.Instructions;
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.Memory;
 using ARMeilleure.State;
+using System;
 using System.Collections.Generic;
 using System.Reflection;
 using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
@@ -54,7 +55,7 @@ namespace ARMeilleure.Translation
        public Aarch32Mode Mode { get; }

        private int _ifThenBlockStateIndex = 0;
-        private Condition[] _ifThenBlockState = [];
+        private Condition[] _ifThenBlockState = Array.Empty<Condition>();
        public bool IsInIfThenBlock => _ifThenBlockStateIndex < _ifThenBlockState.Length;
        public Condition CurrentIfThenBlockCond => _ifThenBlockState[_ifThenBlockStateIndex];

--- a/src/ARMeilleure/Translation/Cache/CacheMemoryAllocator.cs
+++ b/src/ARMeilleure/Translation/Cache/CacheMemoryAllocator.cs
@@ -23,7 +23,7 @@ namespace ARMeilleure.Translation.Cache
            }
        }

-        private readonly List<MemoryBlock> _blocks = [];
+        private readonly List<MemoryBlock> _blocks = new();

        public CacheMemoryAllocator(int capacity)
        {
--- a/src/ARMeilleure/Translation/Cache/JitCache.cs
+++ b/src/ARMeilleure/Translation/Cache/JitCache.cs
@@ -25,7 +25,7 @@ namespace ARMeilleure.Translation.Cache

        private static CacheMemoryAllocator _cacheAllocator;

-        private static readonly List<CacheEntry> _cacheEntries = [];
+        private static readonly List<CacheEntry> _cacheEntries = new();

        private static readonly Lock _lock = new();
        private static bool _initialized;
--- a/src/ARMeilleure/Translation/Cache/JitCacheInvalidation.cs
+++ b/src/ARMeilleure/Translation/Cache/JitCacheInvalidation.cs
@@ -1,12 +1,13 @@
 using ARMeilleure.Memory;
+using System;
 using System.Runtime.InteropServices;

 namespace ARMeilleure.Translation.Cache
 {
    class JitCacheInvalidation
    {
-        private static readonly int[] _invalidationCode =
-        [
+        private static readonly int[] _invalidationCode = new int[]
+        {
            unchecked((int)0xd53b0022), // mrs  x2, ctr_el0
            unchecked((int)0xd3504c44), // ubfx x4, x2, #16, #4
            unchecked((int)0x52800083), // mov  w3, #0x4
@@ -34,8 +35,8 @@ namespace ARMeilleure.Translation.Cache
            unchecked((int)0x54ffffa8), // b.hi 54 <ic_clear_loop>
            unchecked((int)0xd5033b9f), // dsb  ish
            unchecked((int)0xd5033fdf), // isb
-            unchecked((int)0xd65f03c0) // ret
-        ];
+            unchecked((int)0xd65f03c0), // ret
+        };

        private delegate void InvalidateCache(ulong start, ulong end);

--- a/src/ARMeilleure/Translation/ControlFlowGraph.cs
+++ b/src/ARMeilleure/Translation/ControlFlowGraph.cs
@@ -47,8 +47,8 @@ namespace ARMeilleure.Translation
        {
            RemoveUnreachableBlocks(Blocks);

-            HashSet<BasicBlock> visited = [];
-            Stack<BasicBlock> blockStack = new();
+            HashSet<BasicBlock> visited = new HashSet<BasicBlock>();
+            Stack<BasicBlock> blockStack = new Stack<BasicBlock>();

            Array.Resize(ref _postOrderBlocks, Blocks.Count);
            Array.Resize(ref _postOrderMap, Blocks.Count);
@@ -88,8 +88,8 @@ namespace ARMeilleure.Translation

        private void RemoveUnreachableBlocks(IntrusiveList<BasicBlock> blocks)
        {
-            HashSet<BasicBlock> visited = [];
-            Queue<BasicBlock> workQueue = new();
+            HashSet<BasicBlock> visited = new HashSet<BasicBlock>();
+            Queue<BasicBlock> workQueue = new Queue<BasicBlock>();

            visited.Add(Entry);
            workQueue.Enqueue(Entry);
--- a/src/ARMeilleure/Translation/DelegateInfo.cs
+++ b/src/ARMeilleure/Translation/DelegateInfo.cs
@@ -1,3 +1,5 @@
+using System;
+
 namespace ARMeilleure.Translation
 {
    class DelegateInfo
--- a/src/ARMeilleure/Translation/DispatcherFunction.cs
+++ b/src/ARMeilleure/Translation/DispatcherFunction.cs
@@ -1,3 +1,5 @@
+using System;
+
 namespace ARMeilleure.Translation
 {
    delegate void DispatcherFunction(nint nativeContext, ulong startAddress);
--- a/src/ARMeilleure/Translation/GuestFunction.cs
+++ b/src/ARMeilleure/Translation/GuestFunction.cs
@@ -1,3 +1,5 @@
+using System;
+
 namespace ARMeilleure.Translation
 {
    delegate ulong GuestFunction(nint nativeContextPtr);
--- a/src/ARMeilleure/Translation/IntervalTree.cs
+++ b/src/ARMeilleure/Translation/IntervalTree.cs
@@ -108,7 +108,7 @@ namespace ARMeilleure.Translation
        /// <returns>A list of all values sorted by Key Order</returns>
        public List<TV> AsList()
        {
-            List<TV> list = [];
+            List<TV> list = new();

            AddToList(_root, list);

--- a/src/ARMeilleure/Translation/PTC/Ptc.cs
+++ b/src/ARMeilleure/Translation/PTC/Ptc.cs
@@ -3,8 +3,6 @@ using ARMeilleure.CodeGen.Linking;
 using ARMeilleure.CodeGen.Unwinding;
 using ARMeilleure.Common;
 using ARMeilleure.Memory;
-using ARMeilleure.State;
-using Humanizer;
 using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
@@ -32,8 +30,8 @@ namespace ARMeilleure.Translation.PTC
    {
        private const string OuterHeaderMagicString = "PTCohd\0\0";
        private const string InnerHeaderMagicString = "PTCihd\0\0";
-
-        private const uint InternalVersion = 7007; //! To be incremented manually for each change to the ARMeilleure project.
+        
+        private const uint InternalVersion = 6998; //! To be incremented manually for each change to the ARMeilleure project.

        private const string ActualDir = "0";
        private const string BackupDir = "1";
@@ -156,7 +154,7 @@ namespace ARMeilleure.Translation.PTC
        private void InitializeCarriers()
        {
            _infosStream = MemoryStreamManager.Shared.GetStream();
-            _codesList = [];
+            _codesList = new List<byte[]>();
            _relocsStream = MemoryStreamManager.Shared.GetStream();
            _unwindInfosStream = MemoryStreamManager.Shared.GetStream();
        }
@@ -186,36 +184,6 @@ namespace ARMeilleure.Translation.PTC
            InitializeCarriers();
        }

-        private bool ContainsBlacklistedFunctions()
-        {
-            List<ulong> blacklist = Profiler.GetBlacklistedFunctions();
-            bool containsBlacklistedFunctions = false;
-            _infosStream.Seek(0L, SeekOrigin.Begin);
-            bool foundBadFunction = false;
-
-            for (int index = 0; index < GetEntriesCount(); index++)
-            {
-                InfoEntry infoEntry = DeserializeStructure<InfoEntry>(_infosStream);
-                foreach (ulong address in blacklist)
-                {
-                    if (infoEntry.Address == address)
-                    {
-                        containsBlacklistedFunctions = true;
-                        Logger.Warning?.Print(LogClass.Ptc, "PPTC cache invalidated: Found blacklisted functions in PPTC cache");
-                        foundBadFunction = true;
-                        break;
-                    }
-                }
-
-                if (foundBadFunction)
-                {
-                    break;
-                }
-            }
-
-            return containsBlacklistedFunctions;
-        }
-
        private void PreLoad()
        {
            string fileNameActual = $"{CachePathActual}.cache";
@@ -564,7 +532,7 @@ namespace ARMeilleure.Translation.PTC

        public void LoadTranslations(Translator translator)
        {
-            if (AreCarriersEmpty() || ContainsBlacklistedFunctions())
+            if (AreCarriersEmpty())
            {
                return;
            }
@@ -782,7 +750,7 @@ namespace ARMeilleure.Translation.PTC
            UnwindInfo unwindInfo,
            bool highCq)
        {
-            CompiledFunction cFunc = new(code, unwindInfo, RelocInfo.Empty);
+            CompiledFunction cFunc = new CompiledFunction(code, unwindInfo, RelocInfo.Empty);
            GuestFunction gFunc = cFunc.MapWithPointer<GuestFunction>(out nint gFuncPointer);

            return new TranslatedFunction(gFunc, gFuncPointer, callCounter, guestSize, highCq);
@@ -797,7 +765,7 @@ namespace ARMeilleure.Translation.PTC

        private void StubCode(int index)
        {
-            _codesList[index] = [];
+            _codesList[index] = Array.Empty<byte>();
        }

        private void StubReloc(int relocEntriesCount)
@@ -867,18 +835,10 @@ namespace ARMeilleure.Translation.PTC
                while (profiledFuncsToTranslate.TryDequeue(out (ulong address, PtcProfiler.FuncProfile funcProfile) item))
                {
                    ulong address = item.address;
-                    ExecutionMode executionMode = item.funcProfile.Mode;
-                    bool highCq = item.funcProfile.HighCq;

                    Debug.Assert(Profiler.IsAddressInStaticCodeRange(address));

-                    TranslatedFunction func = translator.Translate(address, executionMode, highCq);
-
-                    if (func == null)
-                    {
-                        Profiler.UpdateEntry(address, executionMode, true, true);
-                        continue;
-                    }
+                    TranslatedFunction func = translator.Translate(address, item.funcProfile.Mode, item.funcProfile.HighCq);

                    bool isAddressUnique = translator.Functions.TryAdd(address, func.GuestSize, func);

@@ -924,11 +884,8 @@ namespace ARMeilleure.Translation.PTC
            sw.Stop();

            PtcStateChanged?.Invoke(PtcLoadingState.Loaded, _translateCount, _translateTotalCount);
-            
-            Logger.Info?.Print(LogClass.Ptc, 
-                $"{_translateCount} of {_translateTotalCount} functions translated in {sw.Elapsed.TotalSeconds} seconds " +
-                $"| {"function".ToQuantity(_translateTotalCount - _translateCount)} blacklisted " +
-                $"| Thread count: {degreeOfParallelism}");
+
+            Logger.Info?.Print(LogClass.Ptc, $"{_translateCount} of {_translateTotalCount} functions translated | Thread count: {degreeOfParallelism} in {sw.Elapsed.TotalSeconds} s");

            Thread preSaveThread = new(PreSave)
            {
@@ -988,7 +945,7 @@ namespace ARMeilleure.Translation.PTC
                WriteCode(code.AsSpan());

                // WriteReloc.
-                using BinaryWriter relocInfoWriter = new(_relocsStream, EncodingCache.UTF8NoBOM, true);
+                using BinaryWriter relocInfoWriter = new BinaryWriter(_relocsStream, EncodingCache.UTF8NoBOM, true);

                foreach (RelocEntry entry in relocInfo.Entries)
                {
@@ -998,7 +955,7 @@ namespace ARMeilleure.Translation.PTC
                }

                // WriteUnwindInfo.
-                using BinaryWriter unwindInfoWriter = new(_unwindInfosStream, EncodingCache.UTF8NoBOM, true);
+                using BinaryWriter unwindInfoWriter = new BinaryWriter(_unwindInfosStream, EncodingCache.UTF8NoBOM, true);

                unwindInfoWriter.Write(unwindInfo.PushEntries.Length);

--- a/src/ARMeilleure/Translation/PTC/PtcFormatter.cs
+++ b/src/ARMeilleure/Translation/PTC/PtcFormatter.cs
@@ -50,7 +50,7 @@ namespace ARMeilleure.Translation.PTC
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static List<T> DeserializeList<T>(Stream stream) where T : struct
        {
-            List<T> list = [];
+            List<T> list = new();

            int count = DeserializeStructure<int>(stream);

--- a/src/ARMeilleure/Translation/PTC/PtcProfiler.cs
+++ b/src/ARMeilleure/Translation/PTC/PtcProfiler.cs
@@ -24,13 +24,11 @@ namespace ARMeilleure.Translation.PTC
    {
        private const string OuterHeaderMagicString = "Pohd\0\0\0\0";

-        private const uint InternalVersion = 7007; //! Not to be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 5518; //! Not to be incremented manually for each change to the ARMeilleure project.

-        private static readonly uint[] _migrateInternalVersions = 
-        [
+        private static readonly uint[] _migrateInternalVersions = {
            1866,
-            5518,
-        ];
+        };

        private const int SaveInterval = 30; // Seconds.

@@ -78,30 +76,20 @@ namespace ARMeilleure.Translation.PTC
        private void TimerElapsed(object _, ElapsedEventArgs __) 
            => new Thread(PreSave) { Name = "Ptc.DiskWriter" }.Start();

-        public void AddEntry(ulong address, ExecutionMode mode, bool highCq, bool blacklist = false)
+        public void AddEntry(ulong address, ExecutionMode mode, bool highCq)
        {
            if (IsAddressInStaticCodeRange(address))
            {
                Debug.Assert(!highCq);

-                if (blacklist)
+                lock (_lock)
                {
-                    lock (_lock)
-                    {
-                        ProfiledFuncs[address] = new FuncProfile(mode, highCq: false, true);
-                    }
-                }
-                else
-                {
-                    lock (_lock)
-                    {
-                        ProfiledFuncs.TryAdd(address, new FuncProfile(mode, highCq: false, false));
-                    }
+                    ProfiledFuncs.TryAdd(address, new FuncProfile(mode, highCq: false));
                }
            }
        }

-        public void UpdateEntry(ulong address, ExecutionMode mode, bool highCq, bool? blacklist = null)
+        public void UpdateEntry(ulong address, ExecutionMode mode, bool highCq)
        {
            if (IsAddressInStaticCodeRange(address))
            {
@@ -111,7 +99,7 @@ namespace ARMeilleure.Translation.PTC
                {
                    Debug.Assert(ProfiledFuncs.ContainsKey(address));

-                    ProfiledFuncs[address] = new FuncProfile(mode, highCq: true, blacklist ?? ProfiledFuncs[address].Blacklist);
+                    ProfiledFuncs[address] = new FuncProfile(mode, highCq: true);
                }
            }
        }
@@ -123,11 +111,11 @@ namespace ARMeilleure.Translation.PTC

        public ConcurrentQueue<(ulong address, FuncProfile funcProfile)> GetProfiledFuncsToTranslate(TranslatorCache<TranslatedFunction> funcs)
        {
-            ConcurrentQueue<(ulong address, FuncProfile funcProfile)> profiledFuncsToTranslate = new();
+            ConcurrentQueue<(ulong address, FuncProfile funcProfile)> profiledFuncsToTranslate = new ConcurrentQueue<(ulong address, FuncProfile funcProfile)>();

            foreach (KeyValuePair<ulong, FuncProfile> profiledFunc in ProfiledFuncs)
            {
-                if (!funcs.ContainsKey(profiledFunc.Key) && !profiledFunc.Value.Blacklist)
+                if (!funcs.ContainsKey(profiledFunc.Key))
                {
                    profiledFuncsToTranslate.Enqueue((profiledFunc.Key, profiledFunc.Value));
                }
@@ -142,24 +130,6 @@ namespace ARMeilleure.Translation.PTC
            ProfiledFuncs.TrimExcess();
        }

-        public List<ulong> GetBlacklistedFunctions()
-        {
-            List<ulong> funcs = new List<ulong>();
-
-            foreach (var profiledFunc in ProfiledFuncs)
-            {
-                if (profiledFunc.Value.Blacklist)
-                {
-                    if (!funcs.Contains(profiledFunc.Key))
-                    {
-                        funcs.Add(profiledFunc.Key);
-                    }
-                }
-            }
-
-            return funcs;
-        }
-
        public void PreLoad()
        {
            _lastHash = default;
@@ -250,18 +220,13 @@ namespace ARMeilleure.Translation.PTC
                    return false;
                }

-                Func<ulong, FuncProfile, (ulong, FuncProfile)> migrateEntryFunc = null;
-
                switch (outerHeader.InfoFileVersion)
                {
                    case InternalVersion:
                        ProfiledFuncs = Deserialize(stream);
                        break;
                    case 1866:
-                        migrateEntryFunc = (address, profile) => (address + 0x500000UL, profile);
-                        goto case 5518;
-                    case 5518:
-                        ProfiledFuncs = DeserializeAddBlacklist(stream, migrateEntryFunc);
+                        ProfiledFuncs = Deserialize(stream, (address, profile) => (address + 0x500000UL, profile));
                        break;
                    default:
                        Logger.Error?.Print(LogClass.Ptc, $"No migration path for {nameof(outerHeader.InfoFileVersion)} '{outerHeader.InfoFileVersion}'. Discarding cache.");
@@ -291,16 +256,6 @@ namespace ARMeilleure.Translation.PTC
            return DeserializeDictionary<ulong, FuncProfile>(stream, DeserializeStructure<FuncProfile>);
        }

-        private static Dictionary<ulong, FuncProfile> DeserializeAddBlacklist(Stream stream, Func<ulong, FuncProfile, (ulong, FuncProfile)> migrateEntryFunc = null)
-        {
-            if (migrateEntryFunc != null)
-            {
-                return DeserializeAndUpdateDictionary(stream, (Stream stream) => { return new FuncProfile(DeserializeStructure<FuncProfilePreBlacklist>(stream)); }, migrateEntryFunc);
-            }
-
-            return DeserializeDictionary<ulong, FuncProfile>(stream, (Stream stream) => { return new FuncProfile(DeserializeStructure<FuncProfilePreBlacklist>(stream)); });
-        }
-
        private static ReadOnlySpan<byte> GetReadOnlySpan(MemoryStream memoryStream)
        {
            return new(memoryStream.GetBuffer(), (int)memoryStream.Position, (int)memoryStream.Length - (int)memoryStream.Position);
@@ -432,35 +387,13 @@ namespace ARMeilleure.Translation.PTC
            }
        }

-        [StructLayout(LayoutKind.Sequential, Pack = 1/*, Size = 6*/)]
+        [StructLayout(LayoutKind.Sequential, Pack = 1/*, Size = 5*/)]
        public struct FuncProfile
        {
            public ExecutionMode Mode;
            public bool HighCq;
-            public bool Blacklist;

-            public FuncProfile(ExecutionMode mode, bool highCq, bool blacklist)
-            {
-                Mode = mode;
-                HighCq = highCq;
-                Blacklist = blacklist;
-            }
-
-            public FuncProfile(FuncProfilePreBlacklist fp)
-            {
-                Mode = fp.Mode;
-                HighCq = fp.HighCq;
-                Blacklist = false;
-            }
-        }
-
-        [StructLayout(LayoutKind.Sequential, Pack = 1/*, Size = 5*/)]
-        public struct FuncProfilePreBlacklist
-        {
-            public ExecutionMode Mode;
-            public bool HighCq;
-
-            public FuncProfilePreBlacklist(ExecutionMode mode, bool highCq)
+            public FuncProfile(ExecutionMode mode, bool highCq)
            {
                Mode = mode;
                HighCq = highCq;
--- a/src/ARMeilleure/Translation/RegisterUsage.cs
+++ b/src/ARMeilleure/Translation/RegisterUsage.cs
@@ -95,7 +95,7 @@ namespace ARMeilleure.Translation
                // This is required because we have a implicit context load at the start of the function,
                // but if there is a jump to the start of the function, the context load would trash the modified values.
                // Here we insert a new entry block that will jump to the existing entry block.
-                BasicBlock newEntry = new(cfg.Blocks.Count);
+                BasicBlock newEntry = new BasicBlock(cfg.Blocks.Count);

                cfg.UpdateEntry(newEntry);
            }
--- a/src/ARMeilleure/Translation/SsaConstruction.cs
+++ b/src/ARMeilleure/Translation/SsaConstruction.cs
@@ -47,7 +47,7 @@ namespace ARMeilleure.Translation
            DefMap[] globalDefs = new DefMap[cfg.Blocks.Count];
            Operand[] localDefs = new Operand[cfg.LocalsCount + RegisterConsts.TotalCount];

-            Queue<BasicBlock> dfPhiBlocks = new();
+            Queue<BasicBlock> dfPhiBlocks = new Queue<BasicBlock>();

            for (BasicBlock block = cfg.Blocks.First; block != null; block = block.ListNext)
            {
--- a/src/ARMeilleure/Translation/TranslatedFunction.cs
+++ b/src/ARMeilleure/Translation/TranslatedFunction.cs
@@ -1,4 +1,5 @@
 using ARMeilleure.Common;
+using System;

 namespace ARMeilleure.Translation
 {
--- a/src/ARMeilleure/Translation/Translator.cs
+++ b/src/ARMeilleure/Translation/Translator.cs
@@ -5,6 +5,7 @@ using ARMeilleure.Diagnostics;
 using ARMeilleure.Instructions;
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.Memory;
+using ARMeilleure.Signal;
 using ARMeilleure.State;
 using ARMeilleure.Translation.Cache;
 using ARMeilleure.Translation.PTC;
@@ -221,7 +222,7 @@ namespace ARMeilleure.Translation

        internal TranslatedFunction Translate(ulong address, ExecutionMode mode, bool highCq, bool singleStep = false)
        {
-            ArmEmitterContext context = new(
+            ArmEmitterContext context = new ArmEmitterContext(
                Memory,
                CountTable,
                FunctionTable,
@@ -248,11 +249,6 @@ namespace ARMeilleure.Translation

            ControlFlowGraph cfg = EmitAndGetCFG(context, blocks, out Range funcRange, out Counter<uint> counter);

-            if (cfg == null)
-            {
-                return null;
-            }
-
            ulong funcSize = funcRange.End - funcRange.Start;

            Logger.EndPass(PassName.Translation, cfg);
@@ -264,7 +260,7 @@ namespace ARMeilleure.Translation
            Logger.EndPass(PassName.RegisterUsage);

            OperandType retType = OperandType.I64;
-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };

            CompilerOptions options = highCq ? CompilerOptions.HighCq : CompilerOptions.None;

@@ -411,11 +407,6 @@ namespace ARMeilleure.Translation
                        if (opCode.Instruction.Emitter != null)
                        {
                            opCode.Instruction.Emitter(context);
-                            if (opCode.Instruction.Name == InstName.Und && blkIndex == 0)
-                            {
-                                range = new Range(rangeStart, rangeEnd);
-                                return null;
-                            }
                        }
                        else
                        {
@@ -487,7 +478,7 @@ namespace ARMeilleure.Translation

        public void InvalidateJitCacheRegion(ulong address, ulong size)
        {
-            ulong[] overlapAddresses = [];
+            ulong[] overlapAddresses = Array.Empty<ulong>();

            int overlapsCount = Functions.GetOverlaps(address, size, ref overlapAddresses);

--- a/src/ARMeilleure/Translation/TranslatorQueue.cs
+++ b/src/ARMeilleure/Translation/TranslatorQueue.cs
@@ -36,7 +36,7 @@ namespace ARMeilleure.Translation
            Sync = new object();

            _requests = new Stack<RejitRequest>();
-            _requestAddresses = [];
+            _requestAddresses = new HashSet<ulong>();
        }

        /// <summary>
--- a/src/ARMeilleure/Translation/TranslatorStubs.cs
+++ b/src/ARMeilleure/Translation/TranslatorStubs.cs
@@ -4,6 +4,7 @@ using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.State;
 using ARMeilleure.Translation.Cache;
 using System;
+using System.Reflection;
 using System.Runtime.InteropServices;
 using static ARMeilleure.IntermediateRepresentation.Operand.Factory;

@@ -141,7 +142,7 @@ namespace ARMeilleure.Translation
        /// <returns>Generated <see cref="DispatchStub"/></returns>
        private nint GenerateDispatchStub()
        {
-            EmitterContext context = new();
+            EmitterContext context = new EmitterContext();

            Operand lblFallback = Label();
            Operand lblEnd = Label();
@@ -186,7 +187,7 @@ namespace ARMeilleure.Translation

            ControlFlowGraph cfg = context.GetControlFlowGraph();
            OperandType retType = OperandType.I64;
-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new[] { OperandType.I64 };

            GuestFunction func = Compiler.Compile(cfg, argTypes, retType, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<GuestFunction>();

@@ -199,7 +200,7 @@ namespace ARMeilleure.Translation
        /// <returns>Generated <see cref="SlowDispatchStub"/></returns>
        private nint GenerateSlowDispatchStub()
        {
-            EmitterContext context = new();
+            EmitterContext context = new EmitterContext();

            // Load the target guest address from the native context.
            Operand nativeContext = context.LoadArgument(OperandType.I64, 0);
@@ -211,7 +212,7 @@ namespace ARMeilleure.Translation

            ControlFlowGraph cfg = context.GetControlFlowGraph();
            OperandType retType = OperandType.I64;
-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new[] { OperandType.I64 };

            GuestFunction func = Compiler.Compile(cfg, argTypes, retType, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<GuestFunction>();

@@ -250,7 +251,7 @@ namespace ARMeilleure.Translation
        /// <returns><see cref="DispatchLoop"/> function</returns>
        private DispatcherFunction GenerateDispatchLoop()
        {
-            EmitterContext context = new();
+            EmitterContext context = new EmitterContext();

            Operand beginLbl = Label();
            Operand endLbl = Label();
@@ -280,7 +281,7 @@ namespace ARMeilleure.Translation

            ControlFlowGraph cfg = context.GetControlFlowGraph();
            OperandType retType = OperandType.None;
-            OperandType[] argTypes = [OperandType.I64, OperandType.I64];
+            OperandType[] argTypes = new[] { OperandType.I64, OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, retType, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<DispatcherFunction>();
        }
@@ -291,7 +292,7 @@ namespace ARMeilleure.Translation
        /// <returns><see cref="ContextWrapper"/> function</returns>
        private WrapperFunction GenerateContextWrapper()
        {
-            EmitterContext context = new();
+            EmitterContext context = new EmitterContext();

            Operand nativeContext = context.LoadArgument(OperandType.I64, 0);
            Operand guestMethod = context.LoadArgument(OperandType.I64, 1);
@@ -304,7 +305,7 @@ namespace ARMeilleure.Translation

            ControlFlowGraph cfg = context.GetControlFlowGraph();
            OperandType retType = OperandType.I64;
-            OperandType[] argTypes = [OperandType.I64, OperandType.I64];
+            OperandType[] argTypes = new[] { OperandType.I64, OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, retType, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<WrapperFunction>();
        }
--- a/src/ARMeilleure/Translation/TranslatorTestMethods.cs
+++ b/src/ARMeilleure/Translation/TranslatorTestMethods.cs
@@ -139,7 +139,7 @@ namespace ARMeilleure.Translation

            ControlFlowGraph cfg = context.GetControlFlowGraph();

-            OperandType[] argTypes = [OperandType.I64];
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };

            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<FpFlagsPInvokeTest>();
        }
--- a/src/Ryujinx.Audio.Backends.SDL2/SDL2HardwareDeviceSession.cs
+++ b/src/Ryujinx.Audio.Backends.SDL2/SDL2HardwareDeviceSession.cs
@@ -4,6 +4,7 @@ using Ryujinx.Common.Logging;
 using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Threading;

--- a/src/Ryujinx.Audio.Backends.SoundIo/Native/SoundIo.cs
+++ b/src/Ryujinx.Audio.Backends.SoundIo/Native/SoundIo.cs
@@ -1,4 +1,5 @@
 using Ryujinx.Common.Memory;
+using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;

--- a/src/Ryujinx.Audio.Backends.SoundIo/Native/SoundIoDeviceContext.cs
+++ b/src/Ryujinx.Audio.Backends.SoundIo/Native/SoundIoDeviceContext.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
--- a/src/Ryujinx.Audio.Backends.SoundIo/SoundIoHardwareDeviceSession.cs
+++ b/src/Ryujinx.Audio.Backends.SoundIo/SoundIoHardwareDeviceSession.cs
@@ -4,6 +4,7 @@ using Ryujinx.Audio.Common;
 using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using System.Threading;
--- a/src/Ryujinx.Audio/Backends/Common/DynamicRingBuffer.cs
+++ b/src/Ryujinx.Audio/Backends/Common/DynamicRingBuffer.cs
@@ -1,6 +1,7 @@
 using Ryujinx.Common;
 using Ryujinx.Common.Memory;
 using System;
+using System.Buffers;
 using System.Threading;

 namespace Ryujinx.Audio.Backends.Common
--- a/src/Ryujinx.Audio/Backends/CompatLayer/Downmixing.cs
+++ b/src/Ryujinx.Audio/Backends/CompatLayer/Downmixing.cs
@@ -31,19 +31,19 @@ namespace Ryujinx.Audio.Backends.CompatLayer
        private const int Minus6dBInQ15 = (int)(0.501f * RawQ15One);
        private const int Minus12dBInQ15 = (int)(0.251f * RawQ15One);

-        private static readonly long[] _defaultSurroundToStereoCoefficients =
-        [
+        private static readonly long[] _defaultSurroundToStereoCoefficients = new long[4]
+        {
            RawQ15One,
            Minus3dBInQ15,
            Minus12dBInQ15,
-            Minus3dBInQ15
-        ];
+            Minus3dBInQ15,
+        };

-        private static readonly long[] _defaultStereoToMonoCoefficients =
-        [
+        private static readonly long[] _defaultStereoToMonoCoefficients = new long[2]
+        {
            Minus6dBInQ15,
-            Minus6dBInQ15
-        ];
+            Minus6dBInQ15,
+        };

        private const int SurroundChannelCount = 6;
        private const int StereoChannelCount = 2;
--- a/src/Ryujinx.Audio/Constants.cs
+++ b/src/Ryujinx.Audio/Constants.cs
@@ -164,12 +164,12 @@ namespace Ryujinx.Audio
        /// <summary>
        /// The default coefficients used for standard 5.1 surround to stereo downmixing.
        /// </summary>
-        public static readonly float[] DefaultSurroundToStereoCoefficients =
-        [
+        public static readonly float[] DefaultSurroundToStereoCoefficients = new float[4]
+        {
            1.0f,
            0.707f,
            0.251f,
-            0.707f
-        ];
+            0.707f,
+        };
    }
 }
--- a/src/Ryujinx.Audio/Input/AudioInputManager.cs
+++ b/src/Ryujinx.Audio/Input/AudioInputManager.cs
@@ -173,7 +173,7 @@ namespace Ryujinx.Audio.Input
                // TODO: Detect if the driver supports audio input
            }

-            return [Constants.DefaultDeviceInputName];
+            return new[] { Constants.DefaultDeviceInputName };
        }

        /// <summary>
--- a/src/Ryujinx.Audio/Output/AudioOutputManager.cs
+++ b/src/Ryujinx.Audio/Output/AudioOutputManager.cs
@@ -167,7 +167,7 @@ namespace Ryujinx.Audio.Output
        /// <returns>The list of all audio outputs name</returns>
        public string[] ListAudioOuts()
        {
-            return [Constants.DefaultDeviceOutputName];
+            return new[] { Constants.DefaultDeviceOutputName };
        }

        /// <summary>
--- a/src/Ryujinx.Audio/Renderer/Device/VirtualDevice.cs
+++ b/src/Ryujinx.Audio/Renderer/Device/VirtualDevice.cs
@@ -10,14 +10,14 @@ namespace Ryujinx.Audio.Renderer.Device
        /// <summary>
        /// All the defined virtual devices.
        /// </summary>
-        public static readonly VirtualDevice[] Devices =
-        [
+        public static readonly VirtualDevice[] Devices = new VirtualDevice[5]
+        {
            new("AudioStereoJackOutput", 2, true),
            new("AudioBuiltInSpeakerOutput", 2, false),
            new("AudioTvOutput", 6, false),
            new("AudioUsbDeviceOutput", 2, true),
-            new("AudioExternalOutput", 6, true)
-        ];
+            new("AudioExternalOutput", 6, true),
+        };

        /// <summary>
        /// The name of the <see cref="VirtualDevice"/>.
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/CommandList.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/CommandList.cs
@@ -46,7 +46,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
            SampleRate = sampleRate;
            BufferCount = mixBufferCount + voiceChannelCountMax;
            Buffers = mixBuffer;
-            Commands = [];
+            Commands = new List<ICommand>();
            MemoryManager = memoryManager;

            _buffersEntryCount = Buffers.Length;
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/Reverb3dCommand.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/Reverb3dCommand.cs
@@ -9,29 +9,21 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 {
    public class Reverb3dCommand : ICommand
    {
-        private static readonly int[] _outputEarlyIndicesTableMono = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-        ];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableMono = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
-        ];
-        private static readonly int[] _targetOutputFeedbackIndicesTableMono = [0];
+        private static readonly int[] _outputEarlyIndicesTableMono = new int[20] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableMono = new int[20] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableMono = new int[1] { 0 };

-        private static readonly int[] _outputEarlyIndicesTableStereo = [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1
-        ];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableStereo = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
-        ];
-        private static readonly int[] _targetOutputFeedbackIndicesTableStereo = [0, 1];
+        private static readonly int[] _outputEarlyIndicesTableStereo = new int[20] { 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableStereo = new int[20] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableStereo = new int[2] { 0, 1 };

-        private static readonly int[] _outputEarlyIndicesTableQuadraphonic = [0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 3, 3, 3
-        ];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableQuadraphonic = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
-        ];
-        private static readonly int[] _targetOutputFeedbackIndicesTableQuadraphonic = [0, 1, 2, 3];
+        private static readonly int[] _outputEarlyIndicesTableQuadraphonic = new int[20] { 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 3, 3, 3 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableQuadraphonic = new int[20] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableQuadraphonic = new int[4] { 0, 1, 2, 3 };

-        private static readonly int[] _outputEarlyIndicesTableSurround = [4, 5, 0, 5, 0, 5, 1, 5, 1, 5, 1, 5, 1, 5, 2, 5, 2, 5, 2, 5, 1, 5, 1, 5, 1, 5, 0, 5, 0, 5, 0, 5, 0, 5, 3, 5, 3, 5, 3, 5
-        ];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableSurround = [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19
-        ];
-        private static readonly int[] _targetOutputFeedbackIndicesTableSurround = [0, 1, 2, 3, -1, 3];
+        private static readonly int[] _outputEarlyIndicesTableSurround = new int[40] { 4, 5, 0, 5, 0, 5, 1, 5, 1, 5, 1, 5, 1, 5, 2, 5, 2, 5, 2, 5, 1, 5, 1, 5, 1, 5, 0, 5, 0, 5, 0, 5, 0, 5, 3, 5, 3, 5, 3, 5 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableSurround = new int[40] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableSurround = new int[6] { 0, 1, 2, 3, -1, 3 };

        public bool Enabled { get; set; }

--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/ReverbCommand.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/ReverbCommand.cs
@@ -9,27 +9,25 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 {
    public class ReverbCommand : ICommand
    {
-        private static readonly int[] _outputEarlyIndicesTableMono = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableMono = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        private static readonly int[] _outputIndicesTableMono = [0, 0, 0, 0];
-        private static readonly int[] _targetOutputFeedbackIndicesTableMono = [0, 1, 2, 3];
+        private static readonly int[] _outputEarlyIndicesTableMono = new int[10] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableMono = new int[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+        private static readonly int[] _outputIndicesTableMono = new int[4] { 0, 0, 0, 0 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableMono = new int[4] { 0, 1, 2, 3 };

-        private static readonly int[] _outputEarlyIndicesTableStereo = [0, 0, 1, 1, 0, 1, 0, 0, 1, 1];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableStereo = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        private static readonly int[] _outputIndicesTableStereo = [0, 0, 1, 1];
-        private static readonly int[] _targetOutputFeedbackIndicesTableStereo = [2, 0, 3, 1];
+        private static readonly int[] _outputEarlyIndicesTableStereo = new int[10] { 0, 0, 1, 1, 0, 1, 0, 0, 1, 1 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableStereo = new int[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+        private static readonly int[] _outputIndicesTableStereo = new int[4] { 0, 0, 1, 1 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableStereo = new int[4] { 2, 0, 3, 1 };

-        private static readonly int[] _outputEarlyIndicesTableQuadraphonic = [0, 0, 1, 1, 0, 1, 2, 2, 3, 3];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableQuadraphonic = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        private static readonly int[] _outputIndicesTableQuadraphonic = [0, 1, 2, 3];
-        private static readonly int[] _targetOutputFeedbackIndicesTableQuadraphonic = [0, 1, 2, 3];
+        private static readonly int[] _outputEarlyIndicesTableQuadraphonic = new int[10] { 0, 0, 1, 1, 0, 1, 2, 2, 3, 3 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableQuadraphonic = new int[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+        private static readonly int[] _outputIndicesTableQuadraphonic = new int[4] { 0, 1, 2, 3 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableQuadraphonic = new int[4] { 0, 1, 2, 3 };

-        private static readonly int[] _outputEarlyIndicesTableSurround = [0, 5, 0, 5, 1, 5, 1, 5, 4, 5, 4, 5, 2, 5, 2, 5, 3, 5, 3, 5
-        ];
-        private static readonly int[] _targetEarlyDelayLineIndicesTableSurround = [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9
-        ];
-        private static readonly int[] _outputIndicesTableSurround = [0, 1, 2, 3, 4, 5];
-        private static readonly int[] _targetOutputFeedbackIndicesTableSurround = [0, 1, 2, 3, -1, 3];
+        private static readonly int[] _outputEarlyIndicesTableSurround = new int[20] { 0, 5, 0, 5, 1, 5, 1, 5, 4, 5, 4, 5, 2, 5, 2, 5, 3, 5, 3, 5 };
+        private static readonly int[] _targetEarlyDelayLineIndicesTableSurround = new int[20] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9 };
+        private static readonly int[] _outputIndicesTableSurround = new int[Constants.ChannelCountMax] { 0, 1, 2, 3, 4, 5 };
+        private static readonly int[] _targetOutputFeedbackIndicesTableSurround = new int[Constants.ChannelCountMax] { 0, 1, 2, 3, -1, 3 };

        public bool Enabled { get; set; }

--- a/src/Ryujinx.Audio/Renderer/Dsp/ResamplerHelper.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/ResamplerHelper.cs
@@ -10,8 +10,7 @@ namespace Ryujinx.Audio.Renderer.Dsp
    public static class ResamplerHelper
    {
        #region "Default Quality Lookup Tables"
-        private static readonly short[] _normalCurveLut0 =
-        [
+        private static readonly short[] _normalCurveLut0 = {
            6600,  19426, 6722,  3,     6479,  19424, 6845,  9,     6359,  19419, 6968,  15,    6239,  19412, 7093,  22,
            6121,  19403, 7219,  28,    6004,  19391, 7345,  34,    5888,  19377, 7472,  41,    5773,  19361, 7600,  48,
            5659,  19342, 7728,  55,    5546,  19321, 7857,  62,    5434,  19298, 7987,  69,    5323,  19273, 8118,  77,
@@ -43,11 +42,10 @@ namespace Ryujinx.Audio.Renderer.Dsp
            109,   8646,  19148, 4890,  101,   8513,  19183, 4997,  92,    8381,  19215, 5104,  84,    8249,  19245, 5213,
            77,    8118,  19273, 5323,  69,    7987,  19298, 5434,  62,    7857,  19321, 5546,  55,    7728,  19342, 5659,
            48,    7600,  19361, 5773,  41,    7472,  19377, 5888,  34,    7345,  19391, 6004,  28,    7219,  19403, 6121,
-            22,    7093,  19412, 6239,  15,    6968,  19419, 6359,  9,     6845,  19424, 6479,  3,     6722,  19426, 6600
-        ];
+            22,    7093,  19412, 6239,  15,    6968,  19419, 6359,  9,     6845,  19424, 6479,  3,     6722,  19426, 6600,
+        };

-        private static readonly short[] _normalCurveLut1 =
-        [
+        private static readonly short[] _normalCurveLut1 = {
            -68,   32639, 69,    -5,    -200,  32630, 212,   -15,   -328,  32613, 359,   -26,   -450,  32586, 512,   -36,
            -568,  32551, 669,   -47,   -680,  32507, 832,   -58,   -788,  32454, 1000,  -69,   -891,  32393, 1174,  -80,
            -990,  32323, 1352,  -92,   -1084, 32244, 1536,  -103,  -1173, 32157, 1724,  -115,  -1258, 32061, 1919,  -128,
@@ -79,11 +77,10 @@ namespace Ryujinx.Audio.Renderer.Dsp
            -180,  2747,  31593, -1554, -167,  2532,  31723, -1486, -153,  2322,  31844, -1414, -140,  2118,  31956, -1338,
            -128,  1919,  32061, -1258, -115,  1724,  32157, -1173, -103,  1536,  32244, -1084, -92,   1352,  32323, -990,
            -80,   1174,  32393, -891,  -69,   1000,  32454, -788,  -58,   832,   32507, -680,  -47,   669,   32551, -568,
-            -36,   512,   32586, -450,  -26,   359,   32613, -328,  -15,   212,   32630, -200,  -5,    69,    32639, -68
-        ];
+            -36,   512,   32586, -450,  -26,   359,   32613, -328,  -15,   212,   32630, -200,  -5,    69,    32639, -68,
+        };

-        private static readonly short[] _normalCurveLut2 =
-        [
+        private static readonly short[] _normalCurveLut2 = {
            3195,  26287, 3329,  -32,   3064,  26281, 3467,  -34,   2936,  26270, 3608,  -38,   2811,  26253, 3751,  -42,
            2688,  26230, 3897,  -46,   2568,  26202, 4046,  -50,   2451,  26169, 4199,  -54,   2338,  26130, 4354,  -58,
            2227,  26085, 4512,  -63,   2120,  26035, 4673,  -67,   2015,  25980, 4837,  -72,   1912,  25919, 5004,  -76,
@@ -115,13 +112,12 @@ namespace Ryujinx.Audio.Renderer.Dsp
            -98,   5701,  25621, 1531,  -92,   5522,  25704, 1622,  -87,   5347,  25780, 1716,  -81,   5174,  25852, 1813,
            -76,   5004,  25919, 1912,  -72,   4837,  25980, 2015,  -67,   4673,  26035, 2120,  -63,   4512,  26085, 2227,
            -58,   4354,  26130, 2338,  -54,   4199,  26169, 2451,  -50,   4046,  26202, 2568,  -46,   3897,  26230, 2688,
-            -42,   3751,  26253, 2811,  -38,   3608,  26270, 2936,  -34,   3467,  26281, 3064,  -32,   3329,  26287, 3195
-        ];
+            -42,   3751,  26253, 2811,  -38,   3608,  26270, 2936,  -34,   3467,  26281, 3064,  -32,   3329,  26287, 3195,
+        };
        #endregion

        #region "High Quality Lookup Tables"
-        private static readonly short[] _highCurveLut0 =
-        [
+        private static readonly short[] _highCurveLut0 = {
            -582, -23,  8740, 16386, 8833,  8,    -590,  0,    -573, -54,  8647, 16385, 8925,  40,   -598, -1,
            -565, -84,  8555, 16383, 9018,  72,   -606,  -1,   -557, -113, 8462, 16379, 9110,  105,  -614, -2,
            -549, -142, 8370, 16375, 9203,  139,  -622,  -2,   -541, -170, 8277, 16369, 9295,  173,  -630, -3,
@@ -185,11 +181,10 @@ namespace Ryujinx.Audio.Renderer.Dsp
            -5,   -646, 244,  9480,  16354, 8093, -225,  -525, -4,   -638, 208,  9387,  16362, 8185, -198, -533,
            -3,   -630, 173,  9295,  16369, 8277, -170,  -541, -2,   -622, 139,  9203,  16375, 8370, -142, -549,
            -2,   -614, 105,  9110,  16379, 8462, -113,  -557, -1,   -606, 72,   9018,  16383, 8555, -84,  -565,
-            -1,   -598, 40,   8925,  16385, 8647, -54,   -573, 0,    -590, 8,    8833,  16386, 8740, -23,  -582
-        ];
+            -1,   -598, 40,   8925,  16385, 8647, -54,   -573, 0,    -590, 8,    8833,  16386, 8740, -23,  -582,
+        };

-        private static readonly short[] _highCurveLut1 =
-        [
+        private static readonly short[] _highCurveLut1 = {
            -12,  47,   -134,  32767, 81,     -16,   2,     0,    -26,  108,  -345,   32760, 301,   -79,   17,   -1,
            -40,  168,  -552,  32745, 526,    -144,  32,    -2,   -53,  226,  -753,   32723, 755,   -210,  47,   -3,
            -66,  284,  -950,  32694, 989,    -277,  63,    -5,   -78,  340,  -1143,  32658, 1226,  -346,  79,   -6,
@@ -253,11 +248,10 @@ namespace Ryujinx.Audio.Renderer.Dsp
            -9,   113,  -486,  1715,  32564,  -1514, 447,   -101, -8,   96,   -415,   1469,  32615, -1331, 394,  -90,
            -6,   79,   -346,  1226,  32658,  -1143, 340,   -78,  -5,   63,   -277,   989,   32694, -950,  284,  -66,
            -3,   47,   -210,  755,   32723,  -753,  226,   -53,  -2,   32,   -144,   526,   32745, -552,  168,  -40,
-            -1,   17,   -79,   301,   32760,  -345,  108,   -26,  0,    2,    -16,    81,    32767, -134,  47,   -12
-        ];
+            -1,   17,   -79,   301,   32760,  -345,  108,   -26,  0,    2,    -16,    81,    32767, -134,  47,   -12,
+        };

-        private static readonly short[] _highCurveLut2 =
-        [
+        private static readonly short[] _highCurveLut2 = {
            418, -2538, 6118,  24615, 6298,  -2563, 417,   0,   420, -2512, 5939,  24611, 6479,  -2588, 415,   1,
            421, -2485, 5761,  24605, 6662,  -2612, 412,   2,   422, -2458, 5585,  24595, 6846,  -2635, 409,   3,
            423, -2430, 5410,  24582, 7030,  -2658, 406,   4,   423, -2402, 5236,  24565, 7216,  -2680, 403,   5,
@@ -321,8 +315,8 @@ namespace Ryujinx.Audio.Renderer.Dsp
            7,   395,   -2721, 7591,  24523, 4893,  -2343, 423, 6,   399,   -2701, 7403,  24546, 5064,  -2373, 423,
            5,   403,   -2680, 7216,  24565, 5236,  -2402, 423, 4,   406,   -2658, 7030,  24582, 5410,  -2430, 423,
            3,   409,   -2635, 6846,  24595, 5585,  -2458, 422, 2,   412,   -2612, 6662,  24605, 5761,  -2485, 421,
-            1,   415,   -2588, 6479,  24611, 5939,  -2512, 420, 0,   417,   -2563, 6298,  24615, 6118,  -2538, 418
-        ];
+            1,   415,   -2588, 6479,  24611, 5939,  -2512, 420, 0,   417,   -2563, 6298,  24615, 6118,  -2538, 418,
+        };
        #endregion

        private static readonly float[] _normalCurveLut0F;
--- a/src/Ryujinx.Audio/Renderer/Dsp/State/Reverb3dState.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/State/Reverb3dState.cs
@@ -6,14 +6,12 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
 {
    public struct Reverb3dState
    {
-        private readonly float[] _fdnDelayMinTimes = [5.0f, 6.0f, 13.0f, 14.0f];
-        private readonly float[] _fdnDelayMaxTimes = [45.704f, 82.782f, 149.94f, 271.58f];
-        private readonly float[] _decayDelayMaxTimes1 = [17.0f, 13.0f, 9.0f, 7.0f];
-        private readonly float[] _decayDelayMaxTimes2 = [19.0f, 11.0f, 10.0f, 6.0f];
-        private readonly float[] _earlyDelayTimes = [0.017136f, 0.059154f, 0.16173f, 0.39019f, 0.42526f, 0.45541f, 0.68974f, 0.74591f, 0.83384f, 0.8595f, 0.0f, 0.075024f, 0.16879f, 0.2999f, 0.33744f, 0.3719f, 0.59901f, 0.71674f, 0.81786f, 0.85166f
-        ];
-        public readonly float[] EarlyGain = [0.67096f, 0.61027f, 1.0f, 0.35680f, 0.68361f, 0.65978f, 0.51939f, 0.24712f, 0.45945f, 0.45021f, 0.64196f, 0.54879f, 0.92925f, 0.38270f, 0.72867f, 0.69794f, 0.5464f, 0.24563f, 0.45214f, 0.44042f
-        ];
+        private readonly float[] _fdnDelayMinTimes = new float[4] { 5.0f, 6.0f, 13.0f, 14.0f };
+        private readonly float[] _fdnDelayMaxTimes = new float[4] { 45.704f, 82.782f, 149.94f, 271.58f };
+        private readonly float[] _decayDelayMaxTimes1 = new float[4] { 17.0f, 13.0f, 9.0f, 7.0f };
+        private readonly float[] _decayDelayMaxTimes2 = new float[4] { 19.0f, 11.0f, 10.0f, 6.0f };
+        private readonly float[] _earlyDelayTimes = new float[20] { 0.017136f, 0.059154f, 0.16173f, 0.39019f, 0.42526f, 0.45541f, 0.68974f, 0.74591f, 0.83384f, 0.8595f, 0.0f, 0.075024f, 0.16879f, 0.2999f, 0.33744f, 0.3719f, 0.59901f, 0.71674f, 0.81786f, 0.85166f };
+        public readonly float[] EarlyGain = new float[20] { 0.67096f, 0.61027f, 1.0f, 0.35680f, 0.68361f, 0.65978f, 0.51939f, 0.24712f, 0.45945f, 0.45021f, 0.64196f, 0.54879f, 0.92925f, 0.38270f, 0.72867f, 0.69794f, 0.5464f, 0.24563f, 0.45214f, 0.44042f };

        public IDelayLine[] FdnDelayLines { get; }
        public DecayDelay[] DecayDelays1 { get; }
--- a/src/Ryujinx.Audio/Renderer/Dsp/State/ReverbState.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/State/ReverbState.cs
@@ -7,8 +7,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
 {
    public struct ReverbState
    {
-        private static readonly float[] _fdnDelayTimes =
-        [
+        private static readonly float[] _fdnDelayTimes = new float[20]
+        {
            // Room
            53.953247f, 79.192566f, 116.238770f, 130.615295f,
            // Hall
@@ -18,11 +18,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            // Cathedral
            47.03f, 71f, 103f, 170f,
            // Max delay (Hall is the one with the highest values so identical to Hall)
-            53.953247f, 79.192566f, 116.238770f, 170.615295f
-        ];
+            53.953247f, 79.192566f, 116.238770f, 170.615295f,
+        };

-        private static readonly float[] _decayDelayTimes =
-        [
+        private static readonly float[] _decayDelayTimes = new float[20]
+        {
            // Room
            7f, 9f, 13f, 17f,
            // Hall
@@ -32,11 +32,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            // Cathedral
            7f, 7f, 13f, 9f,
            // Max delay (Hall is the one with the highest values so identical to Hall)
-            7f, 9f, 13f, 17f
-        ];
+            7f, 9f, 13f, 17f,
+        };

-        private static readonly float[] _earlyDelayTimes =
-        [
+        private static readonly float[] _earlyDelayTimes = new float[50]
+        {
            // Room
            0.0f, 3.5f, 2.8f, 3.9f, 2.7f, 13.4f, 7.9f, 8.4f, 9.9f, 12.0f,
            // Chamber
@@ -46,11 +46,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            // Cathedral
            33.1f, 43.3f, 22.8f, 37.9f, 14.9f, 35.3f, 17.9f, 34.2f, 0.0f, 43.3f,
            // Disabled
-            0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
-        ];
+            0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+        };

-        private static readonly float[] _earlyGainBase =
-        [
+        private static readonly float[] _earlyGainBase = new float[50]
+        {
            // Room
            0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.68f, 0.68f,
            // Chamber
@@ -60,11 +60,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            // Cathedral
            0.93f, 0.92f, 0.87f, 0.86f, 0.94f, 0.81f, 0.80f, 0.77f, 0.76f, 0.65f,
            // Disabled
-            0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f
-        ];
+            0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f,
+        };

-        private static readonly float[] _preDelayTimes =
-        [
+        private static readonly float[] _preDelayTimes = new float[5]
+        {
            // Room
            12.5f,
            // Chamber
@@ -74,8 +74,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            // Cathedral
            50.0f,
            // Disabled
-            0.0f
-        ];
+            0.0f,
+        };

        public DelayLine[] FdnDelayLines { get; }
        public DecayDelay[] DecayDelays { get; }
--- a/src/Ryujinx.Audio/Renderer/Server/AudioRenderSystem.cs
+++ b/src/Ryujinx.Audio/Renderer/Server/AudioRenderSystem.cs
@@ -436,7 +436,7 @@ namespace Ryujinx.Audio.Renderer.Server
                    return result;
                }

-                PoolMapper poolMapper = new(_processHandle, _memoryPools, _behaviourContext.IsMemoryPoolForceMappingEnabled());
+                PoolMapper poolMapper = new PoolMapper(_processHandle, _memoryPools, _behaviourContext.IsMemoryPoolForceMappingEnabled());

                result = stateUpdater.UpdateVoices(_voiceContext, poolMapper);

--- a/src/Ryujinx.Audio/Renderer/Server/MemoryPool/MemoryPoolState.cs
+++ b/src/Ryujinx.Audio/Renderer/Server/MemoryPool/MemoryPoolState.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Runtime.InteropServices;
 using CpuAddress = System.UInt64;
 using DspAddress = System.UInt64;
--- a/src/Ryujinx.BuildValidationTasks/LocalesValidationTask.cs
+++ b/src/Ryujinx.BuildValidationTasks/LocalesValidationTask.cs
@@ -83,7 +83,7 @@ namespace Ryujinx.BuildValidationTasks
            if (isGitRunner && encounteredIssue)
                throw new JsonException("1 or more locales are invalid!");

-            JsonSerializerOptions jsonOptions = new()
+            JsonSerializerOptions jsonOptions = new JsonSerializerOptions()
            {
                WriteIndented = true,
                NewLine = "\n",
--- a/src/Ryujinx.Common/Collections/IntervalTree.cs
+++ b/src/Ryujinx.Common/Collections/IntervalTree.cs
@@ -106,7 +106,7 @@ namespace Ryujinx.Common.Collections
        /// <returns>A list of all RangeNodes sorted by Key Order</returns>
        public List<RangeNode<TKey, TValue>> AsList()
        {
-            List<RangeNode<TKey, TValue>> list = [];
+            List<RangeNode<TKey, TValue>> list = new();

            AddToList(Root, list);

--- a/src/Ryujinx.Common/Collections/TreeDictionary.cs
+++ b/src/Ryujinx.Common/Collections/TreeDictionary.cs
@@ -139,7 +139,7 @@ namespace Ryujinx.Common.Collections
        /// <param name="list">List to add the tree pairs into</param>
        public List<KeyValuePair<TKey, TValue>> AsLevelOrderList()
        {
-            List<KeyValuePair<TKey, TValue>> list = [];
+            List<KeyValuePair<TKey, TValue>> list = new();

            Queue<Node<TKey, TValue>> nodes = new();

@@ -168,7 +168,7 @@ namespace Ryujinx.Common.Collections
        /// <returns>A list of all KeyValuePairs sorted by Key Order</returns>
        public List<KeyValuePair<TKey, TValue>> AsList()
        {
-            List<KeyValuePair<TKey, TValue>> list = [];
+            List<KeyValuePair<TKey, TValue>> list = new();

            AddToList(Root, list);

--- a/src/Ryujinx.Common/Configuration/ModMetadata.cs
+++ b/src/Ryujinx.Common/Configuration/ModMetadata.cs
@@ -8,7 +8,7 @@ namespace Ryujinx.Common.Configuration

        public ModMetadata()
        {
-            Mods = [];
+            Mods = new List<Mod>();
        }
    }
 }
--- a/src/Ryujinx.Common/Configuration/VSyncMode.cs
+++ b/src/Ryujinx.Common/Configuration/VSyncMode.cs
@@ -6,16 +6,4 @@ namespace Ryujinx.Common.Configuration
        Unbounded,
        Custom
    }
-    
-    public static class VSyncModeExtensions
-    {
-        public static VSyncMode Next(this VSyncMode vsync, bool customEnabled = false) =>
-            vsync switch
-            {
-                VSyncMode.Switch => customEnabled ? VSyncMode.Custom : VSyncMode.Unbounded,
-                VSyncMode.Unbounded => VSyncMode.Switch,
-                VSyncMode.Custom => VSyncMode.Unbounded,
-                _ => VSyncMode.Switch
-            };
-    }
 }
--- a/src/Ryujinx.Common/Extensions/SequenceReaderExtensions.cs
+++ b/src/Ryujinx.Common/Extensions/SequenceReaderExtensions.cs
@@ -164,7 +164,7 @@ namespace Ryujinx.Common.Extensions
            // Not enough data in the current segment, try to peek for the data we need.
            T buffer = default;

-            Span<byte> tempSpan = new(&buffer, sizeof(T));
+            Span<byte> tempSpan = new Span<byte>(&buffer, sizeof(T));

            if (!reader.TryCopyTo(tempSpan))
            {
--- a/src/Ryujinx.Common/Helpers/FileAssociationHelper.cs
+++ b/src/Ryujinx.Common/Helpers/FileAssociationHelper.cs
@@ -1,4 +1,5 @@
 using Microsoft.Win32;
+using Ryujinx.Common;
 using Ryujinx.Common.Logging;
 using System;
 using System.Diagnostics;
--- a/src/Ryujinx.Common/Helpers/ObjectiveC.cs
+++ b/src/Ryujinx.Common/Helpers/ObjectiveC.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;

--- a/src/Ryujinx.Common/Helpers/Patterns.cs
+++ b/src/Ryujinx.Common/Helpers/Patterns.cs
@@ -1,118 +0,0 @@
-using System.Text.RegularExpressions;
-
-namespace Ryujinx.Common.Helper
-{
-    public static partial class Patterns
-    {
-        #region Accessors
-
-        public static readonly Regex Numeric = NumericRegex();
-
-        public static readonly Regex AmdGcn = AmdGcnRegex();
-        public static readonly Regex NvidiaConsumerClass = NvidiaConsumerClassRegex();
-
-        public static readonly Regex DomainLp1Ns = DomainLp1NsRegex();
-        public static readonly Regex DomainLp1Lp1Npln = DomainLp1Lp1NplnRegex();
-        public static readonly Regex DomainLp1Znc = DomainLp1ZncRegex();
-        public static readonly Regex DomainSbApi = DomainSbApiRegex();
-        public static readonly Regex DomainSbAccounts = DomainSbAccountsRegex();
-        public static readonly Regex DomainAccounts = DomainAccountsRegex();
-
-        public static readonly Regex Module = ModuleRegex();
-        public static readonly Regex FsSdk = FsSdkRegex();
-        public static readonly Regex SdkMw = SdkMwRegex();
-
-        // ReSharper disable once InconsistentNaming
-        public static readonly Regex CJK = CJKRegex();
-
-        public static readonly Regex LdnPassphrase = LdnPassphraseRegex();
-
-        public static readonly Regex CleanText = CleanTextRegex();
-
-        #endregion
-
-        #region Generated pattern stubs
-
-        #region Numeric validation
-
-        [GeneratedRegex("[0-9]|.")]
-        internal static partial Regex NumericRegex();
-
-        #endregion
-
-        #region GPU names
-
-        [GeneratedRegex(
-            "Radeon (((HD|R(5|7|9|X)) )?((M?[2-6]\\d{2}(\\D|$))|([7-8]\\d{3}(\\D|$))|Fury|Nano))|(Pro Duo)")]
-        internal static partial Regex AmdGcnRegex();
-
-        [GeneratedRegex("NVIDIA GeForce (R|G)?TX? (\\d{3}\\d?)M?")]
-        internal static partial Regex NvidiaConsumerClassRegex();
-
-        #endregion
-
-        #region DNS blocking
-
-        public static readonly Regex[] BlockedHosts =
-        [
-            DomainLp1Ns,
-            DomainLp1Lp1Npln,
-            DomainLp1Znc,
-            DomainSbApi,
-            DomainSbAccounts,
-            DomainAccounts
-        ];
-
-        const RegexOptions DnsRegexOpts =
-            RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture;
-
-        [GeneratedRegex(@"^(.*)\-lp1\.(n|s)\.n\.srv\.nintendo\.net$", DnsRegexOpts)]
-        internal static partial Regex DomainLp1NsRegex();
-
-        [GeneratedRegex(@"^(.*)\-lp1\.lp1\.t\.npln\.srv\.nintendo\.net$", DnsRegexOpts)]
-        internal static partial Regex DomainLp1Lp1NplnRegex();
-
-        [GeneratedRegex(@"^(.*)\-lp1\.(znc|p)\.srv\.nintendo\.net$", DnsRegexOpts)]
-        internal static partial Regex DomainLp1ZncRegex();
-
-        [GeneratedRegex(@"^(.*)\-sb\-api\.accounts\.nintendo\.com$", DnsRegexOpts)]
-        internal static partial Regex DomainSbApiRegex();
-
-        [GeneratedRegex(@"^(.*)\-sb\.accounts\.nintendo\.com$", DnsRegexOpts)]
-        internal static partial Regex DomainSbAccountsRegex();
-
-        [GeneratedRegex(@"^accounts\.nintendo\.com$", DnsRegexOpts)]
-        internal static partial Regex DomainAccountsRegex();
-
-        #endregion
-
-        #region Executable information
-
-        [GeneratedRegex(@"[a-z]:[\\/][ -~]{5,}\.nss", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
-        internal static partial Regex ModuleRegex();
-
-        [GeneratedRegex(@"sdk_version: ([0-9.]*)")]
-        internal static partial Regex FsSdkRegex();
-
-        [GeneratedRegex(@"SDK MW[ -~]*")]
-        internal static partial Regex SdkMwRegex();
-
-        #endregion
-
-        #region CJK
-
-        [GeneratedRegex(
-            "\\p{IsHangulJamo}|\\p{IsCJKRadicalsSupplement}|\\p{IsCJKSymbolsandPunctuation}|\\p{IsEnclosedCJKLettersandMonths}|\\p{IsCJKCompatibility}|\\p{IsCJKUnifiedIdeographsExtensionA}|\\p{IsCJKUnifiedIdeographs}|\\p{IsHangulSyllables}|\\p{IsCJKCompatibilityForms}")]
-        private static partial Regex CJKRegex();
-
-        #endregion
-
-        [GeneratedRegex("Ryujinx-[0-9a-f]{8}")]
-        private static partial Regex LdnPassphraseRegex();
-
-        [GeneratedRegex(@"[^\u0000\u0009\u000A\u000D\u0020-\uFFFF]..")]
-        private static partial Regex CleanTextRegex();
-
-        #endregion
-    }
-}
--- a/src/Ryujinx.Common/Helpers/RefEvent.cs
+++ b/src/Ryujinx.Common/Helpers/RefEvent.cs
@@ -1,58 +0,0 @@
-using Gommon;
-using System.Collections.Generic;
-using System.Threading;
-
-namespace Ryujinx.Common.Helper
-{
-    public class RefEvent<T>
-    {
-        public delegate void Handler(ref T arg);
-        
-        private readonly Lock _subLock = new();
-        private readonly List<Handler> _subscriptions = [];
-    
-        public bool HasSubscribers
-        {
-            get
-            {
-                lock (_subLock)
-                    return _subscriptions.Count != 0;
-            }
-        }
-
-        public IReadOnlyList<Handler> Subscriptions
-        {
-            get
-            {
-                lock (_subLock)
-                    return _subscriptions;
-            }
-        }
-
-        public void Add(Handler subscriber)
-        {
-            Guard.Require(subscriber, nameof(subscriber));
-            lock (_subLock)
-                _subscriptions.Add(subscriber);
-        }
-
-        public void Remove(Handler subscriber)
-        {
-            Guard.Require(subscriber, nameof(subscriber));
-            lock (_subLock)
-                _subscriptions.Remove(subscriber);
-        }
-
-        public void Clear()
-        {
-            lock (_subLock)
-                _subscriptions.Clear();
-        }
-
-        public void Call(ref T arg)
-        {
-            foreach (Handler subscription in Subscriptions)
-                subscription(ref arg);
-        }
-    }
-}
--- a/src/Ryujinx.Common/Helpers/RunningPlatform.cs
+++ b/src/Ryujinx.Common/Helpers/RunningPlatform.cs
@@ -10,18 +10,14 @@ namespace Ryujinx.Common.Helper
        public static bool IsMacOS => OperatingSystem.IsMacOS();
        public static bool IsWindows => OperatingSystem.IsWindows();
        public static bool IsLinux => OperatingSystem.IsLinux();
-        
-        public static bool IsArm => RuntimeInformation.OSArchitecture is Architecture.Arm64;
-        
-        public static bool IsX64 => RuntimeInformation.OSArchitecture is Architecture.X64;

-        public static bool IsIntelMac => IsMacOS && IsX64;
-        public static bool IsArmMac => IsMacOS && IsArm;
+        public static bool IsIntelMac => IsMacOS && RuntimeInformation.OSArchitecture is Architecture.X64;
+        public static bool IsArmMac => IsMacOS && RuntimeInformation.OSArchitecture is Architecture.Arm64;
        
-        public static bool IsX64Windows => IsWindows && IsX64;
-        public static bool IsArmWindows => IsWindows && IsArm;
+        public static bool IsX64Windows => IsWindows && (RuntimeInformation.OSArchitecture is Architecture.X64);
+        public static bool IsArmWindows => IsWindows && (RuntimeInformation.OSArchitecture is Architecture.Arm64);
        
-        public static bool IsX64Linux => IsLinux && IsX64;
-        public static bool IsArmLinux => IsLinux && IsArmMac;
+        public static bool IsX64Linux => IsLinux && (RuntimeInformation.OSArchitecture is Architecture.X64);
+        public static bool IsArmLinux => IsLinux && (RuntimeInformation.OSArchitecture is Architecture.Arm64);
    }
 }
--- a/src/Ryujinx.Common/Logging/Logger.cs
+++ b/src/Ryujinx.Common/Logging/Logger.cs
@@ -132,7 +132,7 @@ namespace Ryujinx.Common.Logging
                _enabledClasses[index] = true;
            }

-            _logTargets = [];
+            _logTargets = new List<ILogTarget>();

            _time = Stopwatch.StartNew();

@@ -203,7 +203,7 @@ namespace Ryujinx.Common.Logging

        public static IReadOnlyCollection<LogLevel> GetEnabledLevels()
        {
-            Log?[] logs = [Debug, Info, Warning, Error, Guest, AccessLog, Stub, Trace];
+            Log?[] logs = new[] { Debug, Info, Warning, Error, Guest, AccessLog, Stub, Trace };
            List<LogLevel> levels = new(logs.Length);
            foreach (Log? log in logs)
            {
--- a/src/Ryujinx.Common/PreciseSleep/NanosleepPool.cs
+++ b/src/Ryujinx.Common/PreciseSleep/NanosleepPool.cs
@@ -125,8 +125,8 @@ namespace Ryujinx.Common.PreciseSleep
        }

        private readonly Lock _lock = new();
-        private readonly List<NanosleepThread> _threads = [];
-        private readonly List<NanosleepThread> _active = [];
+        private readonly List<NanosleepThread> _threads = new();
+        private readonly List<NanosleepThread> _active = new();
        private readonly Stack<NanosleepThread> _free = new();
        private readonly AutoResetEvent _signalTarget;

--- a/src/Ryujinx.Common/PreciseSleep/WindowsGranularTimer.cs
+++ b/src/Ryujinx.Common/PreciseSleep/WindowsGranularTimer.cs
@@ -51,7 +51,7 @@ namespace Ryujinx.Common.SystemInterop
        private long _lastId;

        private readonly Lock _lock = new();
-        private readonly List<WaitingObject> _waitingObjects = [];
+        private readonly List<WaitingObject> _waitingObjects = new();

        private WindowsGranularTimer()
        {
--- a/src/Ryujinx.Common/TitleIDs.cs
+++ b/src/Ryujinx.Common/TitleIDs.cs
@@ -3,6 +3,7 @@ using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Helper;
 using System;
 using System.Linq;
+using System.Runtime.InteropServices;

 namespace Ryujinx.Common
 {
@@ -29,11 +30,10 @@ namespace Ryujinx.Common
        
        public static readonly string[] GreatMetalTitles =
        [
-            "01009b500007c000", // ARMS
+            "010076f0049a2000", // Bayonetta
            "0100a5c00d162000", // Cuphead
            "010023800d64a000", // Deltarune
            "01003a30012c0000", // LEGO City Undercover
-            "010048701995e000", // Luigi's Manion 2 HD
            "010028600EBDA000", // Mario 3D World
            "0100152000022000", // Mario Kart 8 Deluxe
            "010075a016a3a000", // Persona 4 Arena Ultimax
@@ -47,16 +47,11 @@ namespace Ryujinx.Common
            "01006f8002326000", // Animal Crossings: New Horizons
            "01009bf0072d4000", // Captain Toad: Treasure Tracker
            "01009510001ca000", // Fast RMX
-            "01005CA01580E000", // Persona 5 Royal
-            "0100b880154fc000", // Persona 5 The Royal (Japan)
-            "010015100b514000", // Super Mario Bros. Wonder
+            "01005CA01580E000", // Persona 5 Royale
            "0100000000010000", // Super Mario Odyssey

-            // Further testing is appreciated, I did not test the entire game:
-            "01007300020fa000", // Astral Chain
-            "010076f0049a2000", // Bayonetta
-            "0100cf5010fec000", // Bayonetta Origins: Cereza and the Lost Demon
-            "0100f4300bf2c000", // New Pokemon Snap
+            //Isaac claims it has a issue in level 2, but I am not able to replicate it on my M3. More testing would be appreciated:
+            "010015100b514000", // Super Mario Bros. Wonder
        ];
        
        public static string GetDiscordGameAsset(string titleId) 
@@ -110,7 +105,6 @@ namespace Ryujinx.Common
            "0100b04011742000", // Monster Hunter Rise 
                          
                          //Mario Franchise
-            "010021d00812a000", // Arcade Archives VS. SUPER MARIO BROS.
            "01006d0017f7a000", // Mario & Luigi: Brothership
            "010003000e146000", // Mario & Sonic at the Olympic Games Tokyo 2020
            "010067300059a000", // Mario + Rabbids: Kingdom Battle
@@ -218,41 +212,32 @@ namespace Ryujinx.Common
                          //Misc Games
            "010056e00853a000", // A Hat in Time
            "0100fd1014726000", // Baldurs Gate: Dark Alliance
-            "0100c6800b934000", // Brawlhalla
            "0100dbf01000a000", // Burnout Paradise Remastered
            "0100744001588000", // Cars 3: Driven to Win
            "0100b41013c82000", // Cruis'n Blast
            "010085900337e000", // Death Squared
            "01001b300b9be000", // Diablo III: Eternal Collection
-            "010027400cdc6000", // Divinity Original 2 - Definitive Edition
            "01008c8012920000", // Dying Light Platinum Edition
            "01001cc01b2d4000", // Goat Simulator 3
            "01003620068ea000", // Hand of Fate 2
            "010085500130a000", // Lego City: Undercover
            "010073c01af34000", // LEGO Horizon Adventures
-            "0100d71004694000", // Minecraft
-            "01007430037f6000", // Monopoly
            "0100853015e86000", // No Man's Sky
            "01007bb017812000", // Portal
            "0100abd01785c000", // Portal 2
            "01008e200c5c2000", // Muse Dash
            "01007820196a6000", // Red Dead Redemption
-            "0100e8300a67a000", // Risk
            "01002f7013224000", // Rune Factory 5
            "01008d100d43e000", // Saints Row IV
            "0100de600beee000", // Saints Row: The Third - The Full Package
            "01001180021fa000", // Shovel Knight: Specter of Torment
-            "0100e65002bb8000", // Stardew Valley
            "0100d7a01b7a2000", // Star Wars: Bounty Hunter
            "0100800015926000", // Suika Game
-            "01007ad00013e000", // Super Bomberman R
            "0100e46006708000", // Terraria
-            "0100605008268000", // Titan Quest
            "01000a10041ea000", // The Elder Scrolls V: Skyrim
            "010057a01e4d4000", // TSUKIHIME -A piece of blue glass moon-
            "010080b00ad66000", // Undertale
            "010069401adb8000", // Unicorn Overlord
-            "01005c600ac68000", // Valkyria Chronicles 4
            "0100534009ff2000", // Yonder - The cloud catcher chronicles
        ];
    }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Evan Husted	cbf92a2204	Merge `6a283190b3` into `f15aa8fba0`	2025-01-26 00:29:48 +01:00
Evan Husted	6a283190b3	Add the controller image back	2025-01-24 22:24:02 -06:00
MutantAura	85547874c8	Consolidate most logic into `StickVisualizer`.	2025-01-24 20:08:58 -06:00
MutantAura	16ca8e5005	Move most logic into new `StickVisualizer` class and add keyboard support.	2025-01-24 20:01:36 -06:00
MutantAura	cfa5ad0757	Simplfy clamping and fix bug on window close.	2025-01-24 19:58:17 -06:00
MutantAura	43ece083b2	Move some backing fields to match others. formatting pt.2	2025-01-24 19:57:11 -06:00
MutantAura	e1f5c501b0	Fix some issues with stick magnitude.	2025-01-24 19:56:21 -06:00
MutantAura	ffe366d953	Cleanup AXAML and hide sticks when only one is present on guest controller.	2025-01-24 19:52:57 -06:00
MutantAura	75c7a29278	style and analyzers	2025-01-24 19:52:52 -06:00
MutantAura	3a0d9c1435	whitespace	2025-01-24 19:52:47 -06:00
MutantAura	93d1476a2a	Remove unused grid definitions.	2025-01-24 19:52:39 -06:00
MutantAura	ce13830063	Clean up some magic numbers between code and axaml.	2025-01-24 19:52:24 -06:00
MutantAura	aa3f2824e0	Polish the aesthetic and include deadzone visualization.	2025-01-24 19:51:44 -06:00
MutantAura	d2bb580aea	Initial implementation of analog stick visualization.	2025-01-24 19:50:09 -06:00