}

else

{

context.Assembler.Movq(dest, src1);

}

}

else

// that the OS will map all pages that we'll use. We do that by

// doing a dummy read on those pages, forcing a page fault and

// the OS to map them. If they are already mapped, nothing happens.

Operand rsp = Register(X86Register.Rsp);

Operand temp = Register(CallingConvention.GetIntReturnRegister());

}

else if (opCode is IOpCode32MemMult opMemMult)

{

rn = opMemMult.Rn;

wBack = opMemMult.PostOffset != 0;

isLoad = opMemMult.IsLoad;

throw new InvalidOperationException("Function entry point is not contained in a block.");

}

Block entryBlock = blocks[entryBlockId];

{

Block block = blocks[i];

{

break; // End of contiguous function.

}

{

Block block = blocks[i];

{

break; // End of contiguous function.

}

Debug.Assert((op.Size & 1) == 0 && op.RegisterSize == RegisterSize.Simd128);

Operand nCopy = context.Copy(GetVec(op.Rn));

Operand res = emit(emit(part0, part1), emit(part2, part3));

if ((op.Size & 1) == 0)

{

Operand zeroN = context.VectorZeroUpper64(n);

}

else /* if ((op.Size & 1) == 1) */

{

}

else /* if (op.RegisterSize == RegisterSize.Simd128) */

{

context.Copy(GetVec(op.Rd), emit(part0, part1));

}

if (Optimizations.UseGfni)

{

(0b10000000L << 56) |

(0b01000000L << 48) |

(0b00100000L << 40) |

(0b00000010L << 8) |

(0b00000001L << 0);

Operand res = context.AddIntrinsic(Intrinsic.X86Gf2p8affineqb, GetVec(op.Rn), vBitMatrix, Const(0));

Operand n = GetVec(op.Rn);

Operand res = context.AddIntrinsic(Intrinsic.X86Pshufb, n, mask);

if (op.Size == 0)

{

}

else /* if (op.Size == 1) */

{

}

Operand res = context.AddIntrinsic(Intrinsic.X86Pshufb, n, mask);

if (op.Size == 0)

{

}

else if (op.Size == 1)

{

}

else /* if (op.Size == 2) */

{

}

Operand res = context.AddIntrinsic(Intrinsic.X86Pshufb, n, mask);

public static ushort FPRoundCv(double real, ExecutionContext context)

{

bool sign;

double mantissa;

exponent++;

}

if (biasedExp == 0u)

{

}

if (biasedExp == 0u && (error != 0d || (context.Fpcr & FPCR.Ufe) != 0))

{

{

intMant++;

{

biasedExp = 1u;

}

{

biasedExp++;

intMant >>= 1;

if ((context.Fpcr & FPCR.Ahp) == 0)

{

{

resultBits = overflowToInf ? FPInfinity(sign) : FPMaxNormal(sign);

}

else

{

{

resultBits = (ushort)((sign ? 1u : 0u) << 15 | 0x7FFFu);

private static float FPRoundCv(double real, ExecutionContext context)

{

bool sign;

double mantissa;

exponent++;

}

{

context.Fpsr |= FPSR.Ufc;

return SoftFloat32.FPZero(sign);

}

if (biasedExp == 0u)

{

}

if (biasedExp == 0u && (error != 0d || (context.Fpcr & FPCR.Ufe) != 0))

{

{

intMant++;

{

biasedExp = 1u;

}

{

biasedExp++;

intMant >>= 1;

float result;

{

result = overflowToInf ? SoftFloat32.FPInfinity(sign) : SoftFloat32.FPMaxNormal(sign);

private static double FPRoundCv(double real, ExecutionContext context)

{

bool sign;

double mantissa;

exponent++;

}

{

context.Fpsr |= FPSR.Ufc;

return SoftFloat64.FPZero(sign);

}

if (biasedExp == 0u)

{

}

if (biasedExp == 0u && (error != 0d || (context.Fpcr & FPCR.Ufe) != 0))

{

{

intMant++;

{

biasedExp = 1u;

}

{

biasedExp++;

intMant >>= 1;

double result;

{

result = overflowToInf ? SoftFloat64.FPInfinity(sign) : SoftFloat64.FPMaxNormal(sign);

using System;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using static ARMeilleure.IntermediateRepresentation.Operand.Factory;

namespace ARMeilleure.Signal

{

if (OperatingSystem.IsMacOS())

{

if (RuntimeInformation.ProcessArchitecture == Architecture.Arm64)

{

return context.BitwiseAnd(esr, Const(0x40ul));

}

if (RuntimeInformation.ProcessArchitecture == Architecture.X64)

{

return context.BitwiseAnd(err, Const(2ul));

}

}

Operand loopLabel = Label();

Operand successLabel = Label();

context.MarkLabel(loopLabel);

// _aarch64_ctx::size

Operand size = context.Load(OperandType.I32, context.Add(auxPtr, Const(4ul)));

context.Copy(auxPtr, context.Add(auxPtr, context.ZeroExtend32(OperandType.I64, size)));

if (RuntimeInformation.ProcessArchitecture == Architecture.X64)

{

return context.BitwiseAnd(err, Const(2ul));

}

}

private void ReportProgress(object state)

{

AutoResetEvent endEvent = (AutoResetEvent)state;

count = newCount;

}

}

}

public static Hash128 ComputeHash(IMemoryManager memory, ulong address, ulong guestSize)

public void Process(CommandList context)

{

ulong currentOffset = CurrentOffset;

for (int y = 0; y < context.SampleCount; y++)

{

}

if (currentOffset >= CircularBufferSize)

{

}

}

}

[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]

private unsafe void ProcessDelayMono(ref DelayState state, float* outputBuffer, float* inputBuffer, uint sampleCount)

{

float feedbackGain = FixedPointHelper.ToFloat(Parameter.FeedbackGain, FixedPointPrecision);

float inGain = FixedPointHelper.ToFloat(Parameter.InGain, FixedPointPrecision);

float temp = input * inGain + delayLineValue * feedbackGain;

outputBuffer[i] = (input * dryGain + delayLineValue * outGain) / 64;

}

[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]

private unsafe void ProcessDelayStereo(ref DelayState state, Span<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)

{

float delayFeedbackBaseGain = state.DelayFeedbackBaseGain;

float delayFeedbackCrossGain = state.DelayFeedbackCrossGain;

Vector2 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;

*((float*)outputBuffers[0] + i) = (channelInput.X * dryGain + delayLineValues.X * outGain) / 64;

*((float*)outputBuffers[1] + i) = (channelInput.Y * dryGain + delayLineValues.Y * outGain) / 64;

[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]

private unsafe void ProcessDelayQuadraphonic(ref DelayState state, Span<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)

{

float delayFeedbackBaseGain = state.DelayFeedbackBaseGain;

float delayFeedbackCrossGain = state.DelayFeedbackCrossGain;

Vector4 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;

*((float*)outputBuffers[0] + i) = (channelInput.X * dryGain + delayLineValues.X * outGain) / 64;

*((float*)outputBuffers[1] + i) = (channelInput.Y * dryGain + delayLineValues.Y * outGain) / 64;

[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]

private unsafe void ProcessDelaySurround(ref DelayState state, Span<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)

{

float feedbackGain = FixedPointHelper.ToFloat(Parameter.FeedbackGain, FixedPointPrecision);

float delayFeedbackBaseGain = state.DelayFeedbackBaseGain;

Vector6 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;

*((float*)outputBuffers[0] + i) = (channelInput.X * dryGain + delayLineValues.X * outGain) / 64;

*((float*)outputBuffers[1] + i) = (channelInput.Y * dryGain + delayLineValues.Y * outGain) / 64;

ProcessDelay(context, ref state);

}

}

int channelCount = (int)device.GetChannelCount();

uint bufferCount = Math.Min(device.GetChannelCount(), InputCount);

uint inputCount;

inputCount = bufferCount;

}

for (int i = 0; i < bufferCount; i++)

{

{

outputBuffer[i + j * channelCount] = PcmHelper.Saturate(inputBuffer[j]);

}

}

}

}

private unsafe void ProcessReverb3dGeneric(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount, ReadOnlySpan<int> outputEarlyIndicesTable, ReadOnlySpan<int> targetEarlyDelayLineIndicesTable, ReadOnlySpan<int> targetOutputFeedbackIndicesTable)

{

bool isMono = Parameter.ChannelCount == 1;

bool isSurround = Parameter.ChannelCount == 6;

{

outputValues.Fill(0);

for (int i = 0; i < targetEarlyDelayLineIndicesTable.Length; i++)

{

int earlyDelayIndex = targetEarlyDelayLineIndicesTable[i];

int outputIndex = outputEarlyIndicesTable[earlyDelayIndex];

outputValues[outputIndex] += tempTapOut * state.EarlyGain[earlyDelayIndex];

}

ProcessReverb3d(context, ref state);

}

}

public static void ProcessWaveBuffers(IVirtualMemoryManager memoryManager, Span<float> outputBuffer, ref WaveBufferInformation info, Span<WaveBuffer> wavebuffers, ref VoiceUpdateState voiceState, uint targetSampleRate, int sampleCount)

{

float sampleRateRatio = (float)info.SourceSampleRate / targetSampleRate * info.Pitch;

int totalNeededSize = (int)MathF.Truncate(fraction + sampleRateRatio * sampleCount);

{

int sourceSampleCountToProcess = sampleCount;

bool isStarving = false;

}

}

}

float BlackmanWindow(float x)

{

}

Array20<float> result = new Array20<float>();

for (int i = 0; i < FilterBankLength; i++)

int inputBufferIndex = 0;

switch (state.Scale)

case 6.0f:

for (int i = 0; i < outputSampleCount; i++)

{

}

}

}

public uint Estimate(MixRampGroupedCommand command)

{

Debug.Assert(_sampleCount == 160 || _sampleCount == 240);

}

}

}

public uint Estimate(MixRampCommand command)

return 0;

}

}

MemoryPoolUserState outputState;

if (inputState != MemoryPoolUserState.RequestAttach && inputState != MemoryPoolUserState.RequestDetach)

{

return UpdateResult.Success;

}

{

return UpdateResult.InvalidParameter;

}

{

return UpdateResult.InvalidParameter;

}

}

}

}

using Ryujinx.Ava.UI.ViewModels;

using Ryujinx.Ava.UI.Windows;

using Ryujinx.Common.Configuration;

using Ryujinx.HLE.HOS;

using Ryujinx.Ui.Common.Helper;

using System;

using System.Collections.Generic;

private string GetSizeString()

{

string[] orders = { "GiB", "MiB", "KiB" };

foreach (string order in orders)

{

return $"{decimal.Divide(Size, max):##.##} {order}";

}

}

return "0 KiB";

}

}

OnPropertyChanged();

}

}

public double WindowWidth

{

get => _windowWidth;

var dominantColor = IconColorPicker.GetFilteredColor(gameIconBmp).ToPixel<Bgra32>();

Color progressFgColor = Color.FromRgb(dominantColor.R, dominantColor.G, dominantColor.B);

Color progressBgColor = Color.FromRgb(

ProgressBarForegroundColor = new SolidColorBrush(progressFgColor);

ProgressBarBackgroundColor = new SolidColorBrush(progressBgColor);

#endregion

}

using Ryujinx.HLE.HOS.Services.Time.TimeZone;

using Ryujinx.Ui.Common.Configuration;

using Ryujinx.Ui.Common.Configuration.System;

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

using System.Net.NetworkInformation;

using TimeZone = Ryujinx.Ava.UI.Models.TimeZone;

namespace Ryujinx.Ava.UI.ViewModels

{

return 0;

}

uint count = (uint)(Marshal.SizeOf<VMStatistics64>() / sizeof(int)); // HOST_VM_INFO64_COUNT

VMStatistics64 stats = new();

if (result != 0)

{

[LibraryImport(SystemLibraryName, SetLastError = true)]

private static partial int host_statistics64(uint host_priv, int host_flavor, ref VMStatistics64 host_info64_out, ref uint host_info64_outCnt);

}

[SupportedOSPlatform("macos")]

private void RegisterPosix()

{

(int readFd, int writeFd) = MakePipe();

_pipeReader = CreateFileDescriptorStream(readFd);

_pipeWriter = CreateFileDescriptorStream(writeFd);

using Ryujinx.Memory.Tracking;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading;

namespace Ryujinx.Graphics.Gpu.Memory

using System;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using VkBuffer = Silk.NET.Vulkan.Buffer;

namespace Ryujinx.Graphics.Vulkan

{

if (info.SpaceId != SaveDataSpaceId.User && info.SpaceId != SaveDataSpaceId.System)

return Result.Success;

BisPartitionId partitionId = info.SpaceId switch

{

if (rc.IsFailure()) return rc;

try

{

rc = hos.Fs.GetEntryType(out _, path);

}

}

}

foreach (var service in services)

{

ProcessCreationFlags.EnableAslr |

ProcessCreationFlags.AddressSpace64Bit |

ProcessCreationFlags.Is64Bit |

ProcessCreationFlags.PoolPartitionSystem;

uint[] defaultCapabilities = new uint[]

{

IsPaused = pause;

}

}

public ControllerKeys UpdateStickButtons(JoystickPosition leftStick, JoystickPosition rightStick)

{

ControllerKeys result = 0;

return result;

}

{

public static ushort CalculateCrc16(ReadOnlySpan<byte> data, int crc, bool reverseEndianess)

{

for (int i = 0; i < data.Length; i++)

{

if ((crc & 0x10000) != 0)

{

}

}

}

private void WriteMagicAndSize(ulong offset, int size)

{

_storage.GetRef<int>(offset + 0) = (int)BFTTFMagic;

_storage.GetRef<int>(offset + 4) = encryptedSize;

}

}

}

Name = name;

SmObjectFactory = smObjectFactory;

ProcessCreationFlags.EnableAslr |

ProcessCreationFlags.AddressSpace64Bit |

ProcessCreationFlags.Is64Bit |

ProcessCreationFlags.PoolPartitionSystem;

KernelStatic.StartInitialProcess(context, creationInfo, DefaultCapabilities, 44, Main);

}

return ResultCode.Success;

}

// http://switchbrew.org/index.php?title=System_Version_Title

using (MemoryStream ms = new MemoryStream(0x100))

{

BinaryWriter writer = new BinaryWriter(ms);

ms.Seek(0x28, SeekOrigin.Begin);

ms.Seek(0x68, SeekOrigin.Begin);

ms.Seek(0x80, SeekOrigin.Begin);

context.Memory.Write(replyPos, ms.ToArray());

}

private ulong GetA8B8G8R8LayerSize(int width, int height, out int pitch, out int alignment)

{

pitch = BitUtils.AlignUp(BitUtils.DivRoundUp(width * 32, 8), 64);

int memorySize = pitch * BitUtils.AlignUp(height, 64);

ulong requiredMemorySize = (ulong)BitUtils.AlignUp(memorySize, alignment);

}

[CommandCmif(2450)]

return ResultCode.Success;

}

}

public static byte[] ParseRawInstruction(string rawInstruction)

{

// Instructions are multi-word, with 32bit words. Split the raw instruction

// and parse each word into individual nybbles of bits.

var words = rawInstruction.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);

if (words.Length == 0)

{

{

string word = words[wordIndex];

{

throw new TamperCompilationException($"Invalid word length for {word} in Atmosphere cheat");

}

{

instruction[index] = byte.Parse(word.AsSpan(nybbleIndex, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture);

}

[Test]

public void DirtyRegionOrdering([Values] bool smart)

{

Random random = new();

List<int> odd = halfRange.Select(x => x * 2 + 1).ToList();

List<int> even = halfRange.Select(x => x * 2).ToList();

_tracking.VirtualMemoryEvent((ulong)i * PageSize, PageSize, true);

});

// Write to all the even pages.

RandomOrder(random, even, (i) =>

_tracking.VirtualMemoryEvent((ulong)i * PageSize, PageSize, true);

});

}

[Test]

// This is useful for situations where we know that the data was complete when the sequence number was set.

// ...essentially, when that data can only be updated on a future sequence number.

Random random = new();

List<int> odd = halfRange.Select(x => x * 2 + 1).ToList();

List<int> even = halfRange.Select(x => x * 2).ToList();

}, 1);

}

// Write to all pages.

// Only the even regions should be reported for sequence number 1.

oddRegionCount = 0;

Assert.AreEqual(oddRegionCount, 0); // Sequence number has not changed, so found no dirty subregions.

// With sequence number 2, all all pages should be reported as modified.

}

[Test]

// Smart multi region handles dynamically change their tracking granularity based on QueryMemory calls.

// This can save on reprotects on larger resources.

// Query some large regions to prep the subdivision of the tracking region.

public void DisposeMultiHandles([Values] bool smart)

{

// Create and initialize two overlapping Multi Region Handles, with PageSize granularity.

Assert.AreEqual(0, _tracking.GetRegionCount());

// Combined pages (and assuming overlapStart <= pageCount) should be pageCount after overlapStart.

Assert.AreEqual(totalPages, _tracking.GetRegionCount());

handleLow.Dispose(); // After disposing one, the pages for the other remain.

handleHigh.Dispose(); // After disposing the other, there are no pages left.

// This test should not throw or deadlock due to invalid state.

long finishedTime = 0;

Random globalRand = new();

for (int i = 0; i < handles.Length; i++)

// Dirty flag consumer threads

int dirtyFlagReprotects = 0;

{

int randSeed = i;

testThreads.Add(new Thread(() =>

{

while (Stopwatch.GetTimestamp() < finishedTime)

{

Random random = new(randSeed);

if (handle.Dirty)

{

// Write trigger threads

int writeTriggers = 0;

{

int randSeed = i;

testThreads.Add(new Thread(() =>

{

Random random = new(randSeed);

while (Stopwatch.GetTimestamp() < finishedTime)

{

Interlocked.Increment(ref writeTriggers);

}

}));

// Handle create/delete threads

int handleLifecycles = 0;

{

int randSeed = i;

testThreads.Add(new Thread(() =>

{

Random random = new(randSeed + 512);

while (Stopwatch.GetTimestamp() < finishedTime)

{

});

}

{

int randSeed = i;

signalThreads[i] = new Thread(() =>

{

Random random = new(randSeed);

{

_tracking.VirtualMemoryEvent((ulong)random.Next(PageSize), 4, false);

}

});

}

{

signalThreads[i].Start();

}

while (signalThreadsDone != -1)

{

{

signalThreadsDone = -1;

}

[Test]

public void MiscR()

{

/*

0x0000000000001000: MOV X0, #2

Opcode(0xD65F03C0);

ExecuteOpcodes();

Reset();

Opcode(0xD65F03C0);

ExecuteOpcodes();

}

[Explicit]

}

#endif

}

public void Dup_S_B([ValueSource(nameof(_8B_))] ulong a,

[Values(0u, 15u)] uint index)

{

uint opcode = 0x5E000420; // RESERVED

opcode |= (imm5 << 16);

public void Dup_S_H([ValueSource(nameof(_4H_))] ulong a,

[Values(0u, 7u)] uint index)

{

uint opcode = 0x5E000420; // RESERVED

opcode |= (imm5 << 16);

public void Dup_S_S([ValueSource(nameof(_2S_))] ulong a,

[Values(0u, 1u, 2u, 3u)] uint index)

{

uint opcode = 0x5E000420; // RESERVED

opcode |= (imm5 << 16);

public void Dup_S_D([ValueSource(nameof(_1D_))] ulong a,

[Values(0u, 1u)] uint index)

{

uint opcode = 0x5E000420; // RESERVED

opcode |= (imm5 << 16);

[Values(0u, 15u)] uint index,

[Values(0b0u, 0b1u)] uint q) // <8B, 16B>

{

uint opcode = 0x0E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[Values(0u, 7u)] uint index,

[Values(0b0u, 0b1u)] uint q) // <4H, 8H>

{

uint opcode = 0x0E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[Values(0u, 1u, 2u, 3u)] uint index,

[Values(0b0u, 0b1u)] uint q) // <2S, 4S>

{

uint opcode = 0x0E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[Values(0u, 1u)] uint index,

[Values(0b1u)] uint q) // <2D>

{

uint opcode = 0x0E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_W_))] uint wn,

[Values(0u, 15u)] uint index)

{

uint opcode = 0x4E001C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_W_))] uint wn,

[Values(0u, 7u)] uint index)

{

uint opcode = 0x4E001C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_W_))] uint wn,

[Values(0u, 1u, 2u, 3u)] uint index)

{

uint opcode = 0x4E001C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_X_))] ulong xn,

[Values(0u, 1u)] uint index)

{

uint opcode = 0x4E001C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[Values(0u, 15u)] uint dstIndex,

[Values(0u, 15u)] uint srcIndex)

{

uint opcode = 0x6E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[Values(0u, 7u)] uint dstIndex,

[Values(0u, 7u)] uint srcIndex)

{

uint opcode = 0x6E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[Values(0u, 1u, 2u, 3u)] uint dstIndex,

[Values(0u, 1u, 2u, 3u)] uint srcIndex)

{

uint opcode = 0x6E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[Values(0u, 1u)] uint dstIndex,

[Values(0u, 1u)] uint srcIndex)

{

uint opcode = 0x6E000400; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_8B_))] ulong a,

[Values(0u, 15u)] uint index)

{

uint opcode = 0x0E002C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_4H_))] ulong a,

[Values(0u, 7u)] uint index)

{

uint opcode = 0x0E002C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_8B_))] ulong a,

[Values(0u, 15u)] uint index)

{

uint opcode = 0x4E002C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_4H_))] ulong a,

[Values(0u, 7u)] uint index)

{

uint opcode = 0x4E002C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_2S_))] ulong a,

[Values(0u, 1u, 2u, 3u)] uint index)

{

uint opcode = 0x4E002C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_8B_))] ulong a,

[Values(0u, 15u)] uint index)

{

uint opcode = 0x0E003C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_4H_))] ulong a,

[Values(0u, 7u)] uint index)

{

uint opcode = 0x0E003C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_2S_))] ulong a,

[Values(0u, 1u, 2u, 3u)] uint index)

{

uint opcode = 0x0E003C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

[ValueSource(nameof(_1D_))] ulong a,

[Values(0u, 1u)] uint index)

{

uint opcode = 0x4E003C00; // RESERVED

opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);

}

#endif

}

#define SimdMemory32

using ARMeilleure.State;

using NUnit.Framework;

using System;

namespace Ryujinx.Tests.Cpu

#region "Helper methods"

private static ulong GenIdxsForTbls(int regs)

{

byte idxInRngMax = (byte)((16 * regs) - 1);

byte idxOutRngMin = (byte) (16 * regs);

ulong idxs = 0ul;

for (int cnt = 1; cnt <= 8; cnt++)

{

ulong idx = TestContext.CurrentContext.Random.NextBool() ? idxInRng : idxOutRng;

}

#endif

}

using LibHac.Common;

using LibHac.Fs;

using LibHac.Fs.Fsa;

using LibHac.FsSystem;

using LibHac.Loader;

using LibHac.Tools.Fs;

using LibHac.Tools.FsSystem;

using LibHac.Tools.FsSystem.NcaUtils;

return string.Empty;

}

{

Logger.Error?.Print(LogClass.Loader, "No main binary ExeFS found in ExeFS");

using var nsoFile = new UniqueRef<IFile>();

NsoReader reader = new NsoReader();

reader.Initialize(nsoFile.Release().AsStorage().AsFile(OpenMode.Read)).ThrowIfFailure();

return BitConverter.ToString(reader.Header.ModuleId.ItemsRo.ToArray()).Replace("-", "").ToUpper()[..16];

}

}

using Ryujinx.Ui.Common.Configuration.System;

using System;

using System.Collections.Generic;

using System.Globalization;

using System.IO;

using System.Reflection;

using System.Text;

using System.Text.Json;

using (destHandle)

{

rc = fs.GetFileSize(out long fileSize, sourceHandle);

if (rc.IsFailure()) return rc;

byte[] buffer = ArrayPool<byte>.Shared.Rent(bufferSize);

try