Z80Assembly Class

Definition

public static class Z80Assembly

View source

Properties

Name	Description
`A`	Register A.
`AF`	Register AF.
`AFShadow`	Register AF'.
`B`	Register B.
`BC`	Register BC.
`C`	Register or condition C.
`D`	Register D.
`DE`	Register DE.
`E`	Register E.
`F`	Register F.
`H`	Register H.
`HL`	Register HL.
`I`	Register I.
`IX`	Register IX.
`IXH`	Register IXH.
`IXL`	Register IXL.
`IY`	Register IY.
`IYH`	Register IYH.
`IYL`	Register IYL.
`L`	Register L.
`M`	Condition M.
`NC`	Condition NC.
`NZ`	Condition NZ.
`OpcodeDefinitions`
`P`	Condition P.
`PC`	Register PC.
`PE`	Condition PE.
`PO`	Condition PO.
`R`	Register R.
`SP`	Register SP.
`Z`	Condition Z.

Methods

Name	Description
`ADC(Z80Assembly.RegisterA, ReferenceOrByte)`
`ADC(Z80Assembly.RegisterHL, Z80Assembly.RegisterBC)`
`ADC(Z80Assembly.RegisterHL, Z80Assembly.RegisterDE)`
`ADC(Z80Assembly.RegisterHL, Z80Assembly.RegisterHL)`
`ADC(Z80Assembly.RegisterHL, Z80Assembly.RegisterSP)`
`ADC(Z80Assembly.RegisterA, ValueAt<Z80Assembly.RegisterHL>)`
`ADC(Z80Assembly.RegisterA, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`ADC(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`ADC(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`ADC(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`ADC(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterA)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterB)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterC)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterD)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterE)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterH)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterIXH)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterIXL)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterIYH)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterIYL)`
`ADC(Z80Assembly.RegisterA, Z80Assembly.RegisterL)`
`ADD(Z80Assembly.RegisterHL, Z80Assembly.RegisterBC)`
`ADD(Z80Assembly.RegisterHL, Z80Assembly.RegisterDE)`
`ADD(Z80Assembly.RegisterHL, Z80Assembly.RegisterHL)`
`ADD(Z80Assembly.RegisterHL, Z80Assembly.RegisterSP)`
`ADD(Z80Assembly.RegisterIX, Z80Assembly.RegisterBC)`
`ADD(Z80Assembly.RegisterIX, Z80Assembly.RegisterDE)`
`ADD(Z80Assembly.RegisterIX, Z80Assembly.RegisterIX)`
`ADD(Z80Assembly.RegisterIX, Z80Assembly.RegisterSP)`
`ADD(Z80Assembly.RegisterIY, Z80Assembly.RegisterBC)`
`ADD(Z80Assembly.RegisterIY, Z80Assembly.RegisterDE)`
`ADD(Z80Assembly.RegisterIY, Z80Assembly.RegisterIY)`
`ADD(Z80Assembly.RegisterIY, Z80Assembly.RegisterSP)`
`ADD(Z80Assembly.RegisterA, ValueAt<Z80Assembly.RegisterHL>)`
`ADD(Z80Assembly.RegisterA, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`ADD(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`ADD(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`ADD(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`ADD(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterA)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterB)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterC)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterD)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterE)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterH)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterIXH)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterIXL)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterIYH)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterIYL)`
`ADD(Z80Assembly.RegisterA, Z80Assembly.RegisterL)`
`ADD(Z80Assembly.RegisterA, ReferenceOrByte)`
`ALIGN(UInt16)`
`AND(ValueAt<Z80Assembly.RegisterHL>)`
`AND(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`AND(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`AND(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`AND(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`AND(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`AND(Z80Assembly.RegisterA)`
`AND(Z80Assembly.RegisterB)`
`AND(Z80Assembly.RegisterC)`
`AND(Z80Assembly.RegisterD)`
`AND(Z80Assembly.RegisterE)`
`AND(Z80Assembly.RegisterH)`
`AND(Z80Assembly.RegisterIXH)`
`AND(Z80Assembly.RegisterIXL)`
`AND(Z80Assembly.RegisterIYH)`
`AND(Z80Assembly.RegisterIYL)`
`AND(Z80Assembly.RegisterL)`
`AND(ReferenceOrByte)`	`AND NN` — Logical AND. Performs a bitwise AND of the operand with A, storing the result in A.
`At(ReferenceOrWord)`
`At<T>(T)`
`At<TRegister, TCondition>(RegisterOrCondition<TRegister, TCondition>)`
`At(Z80Assembly.RegisterIX)`
`At(Z80Assembly.RegisterIY)`
`BIT0(ValueAt<Z80Assembly.RegisterHL>)`
`BIT0(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT0(Z80Assembly.RegisterA)`
`BIT0(Z80Assembly.RegisterB)`
`BIT0(Z80Assembly.RegisterC)`
`BIT0(Z80Assembly.RegisterD)`
`BIT0(Z80Assembly.RegisterE)`
`BIT0(Z80Assembly.RegisterH)`
`BIT0(Z80Assembly.RegisterL)`
`BIT1(ValueAt<Z80Assembly.RegisterHL>)`
`BIT1(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT1(Z80Assembly.RegisterA)`
`BIT1(Z80Assembly.RegisterB)`
`BIT1(Z80Assembly.RegisterC)`
`BIT1(Z80Assembly.RegisterD)`
`BIT1(Z80Assembly.RegisterE)`
`BIT1(Z80Assembly.RegisterH)`
`BIT1(Z80Assembly.RegisterL)`
`BIT2(ValueAt<Z80Assembly.RegisterHL>)`
`BIT2(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT2(Z80Assembly.RegisterA)`
`BIT2(Z80Assembly.RegisterB)`
`BIT2(Z80Assembly.RegisterC)`
`BIT2(Z80Assembly.RegisterD)`
`BIT2(Z80Assembly.RegisterE)`
`BIT2(Z80Assembly.RegisterH)`
`BIT2(Z80Assembly.RegisterL)`
`BIT3(ValueAt<Z80Assembly.RegisterHL>)`
`BIT3(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT3(Z80Assembly.RegisterA)`
`BIT3(Z80Assembly.RegisterB)`
`BIT3(Z80Assembly.RegisterC)`
`BIT3(Z80Assembly.RegisterD)`
`BIT3(Z80Assembly.RegisterE)`
`BIT3(Z80Assembly.RegisterH)`
`BIT3(Z80Assembly.RegisterL)`
`BIT4(ValueAt<Z80Assembly.RegisterHL>)`
`BIT4(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT4(Z80Assembly.RegisterA)`
`BIT4(Z80Assembly.RegisterB)`
`BIT4(Z80Assembly.RegisterC)`
`BIT4(Z80Assembly.RegisterD)`
`BIT4(Z80Assembly.RegisterE)`
`BIT4(Z80Assembly.RegisterH)`
`BIT4(Z80Assembly.RegisterL)`
`BIT5(ValueAt<Z80Assembly.RegisterHL>)`
`BIT5(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT5(Z80Assembly.RegisterA)`
`BIT5(Z80Assembly.RegisterB)`
`BIT5(Z80Assembly.RegisterC)`
`BIT5(Z80Assembly.RegisterD)`
`BIT5(Z80Assembly.RegisterE)`
`BIT5(Z80Assembly.RegisterH)`
`BIT5(Z80Assembly.RegisterL)`
`BIT6(ValueAt<Z80Assembly.RegisterHL>)`
`BIT6(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT6(Z80Assembly.RegisterA)`
`BIT6(Z80Assembly.RegisterB)`
`BIT6(Z80Assembly.RegisterC)`
`BIT6(Z80Assembly.RegisterD)`
`BIT6(Z80Assembly.RegisterE)`
`BIT6(Z80Assembly.RegisterH)`
`BIT6(Z80Assembly.RegisterL)`
`BIT7(ValueAt<Z80Assembly.RegisterHL>)`
`BIT7(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`BIT7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`BIT7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`BIT7(Z80Assembly.RegisterA)`
`BIT7(Z80Assembly.RegisterB)`
`BIT7(Z80Assembly.RegisterC)`
`BIT7(Z80Assembly.RegisterD)`
`BIT7(Z80Assembly.RegisterE)`
`BIT7(Z80Assembly.RegisterH)`
`BIT7(Z80Assembly.RegisterL)`
`CALL(Z80Assembly.ConditionC, ReferenceOrWord)`
`CALL(Z80Assembly.ConditionM, ReferenceOrWord)`
`CALL(Z80Assembly.ConditionNC, ReferenceOrWord)`
`CALL(ReferenceOrWord)`	`CALL NNNN` — Call. Pushes the address of the next instruction onto the stack and jumps to the target address, optionally only if a condition is met.
`CALL(Z80Assembly.ConditionNZ, ReferenceOrWord)`
`CALL(Z80Assembly.ConditionP, ReferenceOrWord)`
`CALL(Z80Assembly.ConditionPE, ReferenceOrWord)`
`CALL(Z80Assembly.ConditionPO, ReferenceOrWord)`
`CALL(Z80Assembly.ConditionZ, ReferenceOrWord)`
`CCF()`	`CCF` — Complement Carry Flag. Inverts the carry flag.
`Comment(String)`
`CP(ValueAt<Z80Assembly.RegisterHL>)`
`CP(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`CP(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`CP(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`CP(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`CP(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`CP(Z80Assembly.RegisterA)`
`CP(Z80Assembly.RegisterB)`
`CP(Z80Assembly.RegisterC)`
`CP(Z80Assembly.RegisterD)`
`CP(Z80Assembly.RegisterE)`
`CP(Z80Assembly.RegisterH)`
`CP(Z80Assembly.RegisterIXH)`
`CP(Z80Assembly.RegisterIXL)`
`CP(Z80Assembly.RegisterIYH)`
`CP(Z80Assembly.RegisterIYL)`
`CP(Z80Assembly.RegisterL)`
`CP(ReferenceOrByte)`	`CP NN` — Compare. Subtracts the operand from A to set the flags, discarding the result.
`CPD()`	`CPD` — Compare and Decrement. Compares A with the byte at (HL), then decrements HL and BC.
`CPDR()`	`CPDR` — Compare and Decrement Repeated. Compares A with the byte at (HL), then decrements HL and BC, repeating until a match is found or BC is zero.
`CPI()`	`CPI` — Compare and Increment. Compares A with the byte at (HL), then increments HL and decrements BC.
`CPIR()`	`CPIR` — Compare and Increment Repeated. Compares A with the byte at (HL), then increments HL and decrements BC, repeating until a match is found or BC is zero.
`CPL()`	`CPL` — Complement. Inverts all the bits of A.
`DAA()`	`DAA` — Decimal Adjust Accumulator. Adjusts A for binary coded decimal arithmetic after an addition or subtraction.
`DEC(Z80Assembly.RegisterDE)`
`DEC(Z80Assembly.RegisterHL)`
`DEC(Z80Assembly.RegisterIX)`
`DEC(Z80Assembly.RegisterIY)`
`DEC(Z80Assembly.RegisterSP)`
`DEC(ValueAt<Z80Assembly.RegisterHL>)`
`DEC(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`DEC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`DEC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`DEC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`DEC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`DEC(Z80Assembly.RegisterA)`
`DEC(Z80Assembly.RegisterB)`
`DEC(Z80Assembly.RegisterBC)`
`DEC(Z80Assembly.RegisterC)`
`DEC(Z80Assembly.RegisterD)`
`DEC(Z80Assembly.RegisterE)`
`DEC(Z80Assembly.RegisterH)`
`DEC(Z80Assembly.RegisterIXH)`
`DEC(Z80Assembly.RegisterIXL)`
`DEC(Z80Assembly.RegisterIYH)`
`DEC(Z80Assembly.RegisterIYL)`
`DEC(Z80Assembly.RegisterL)`
`DEFB(ReadOnlySpan<DataValue>)`
`DEFB(ReadOnlySpan<Byte>)`
`DEFS(UInt16)`
`DEFS(UInt16, Byte)`
`DEFW(ReadOnlySpan<UInt16>)`
`DI()`	`DI` — Disable Interrupts. Disables maskable interrupts.
`DJNZ(ReferenceOrOffset)`	`DJNZ NN` — Decrement and Jump if Not Zero. Decrements B and jumps by the signed offset if B is not zero.
`EI()`	`EI` — Enable Interrupts. Enables maskable interrupts after the following instruction.
`END()`
`END(UInt16)`
`END(Location)`
`END(String)`
`EnumerateOpcodeDefinitions()`
`EQU(Byte)`
`EQU(UInt16)`
`EX(ValueAt<Z80Assembly.RegisterSP>, Z80Assembly.RegisterHL)`
`EX(ReadOnlySpan<Z80Assembly.RegisterSP>, Z80Assembly.RegisterHL)`
`EX(ValueAt<Z80Assembly.RegisterSP>, Z80Assembly.RegisterIX)`
`EX(ReadOnlySpan<Z80Assembly.RegisterSP>, Z80Assembly.RegisterIX)`
`EX(ValueAt<Z80Assembly.RegisterSP>, Z80Assembly.RegisterIY)`
`EX(ReadOnlySpan<Z80Assembly.RegisterSP>, Z80Assembly.RegisterIY)`
`EX(Z80Assembly.RegisterAF, Z80Assembly.ShadowRegisterAF)`
`EX(Z80Assembly.RegisterDE, Z80Assembly.RegisterHL)`
`EXX()`	`EXX` — Exchange Register Pairs. Exchanges BC, DE and HL with their shadow registers.
`HALT()`	`HALT` — Halt. Suspends the CPU until the next interrupt or reset.
`IM0()`	`IM 0` — Interrupt Mode. Sets the maskable interrupt mode.
`IM1()`	`IM 1` — Interrupt Mode. Sets the maskable interrupt mode.
`IM2()`	`IM 2` — Interrupt Mode. Sets the maskable interrupt mode.
`IN(Port<Z80Assembly.RegisterC>)`
`IN(ReadOnlySpan<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterA, Port<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterA, ReadOnlySpan<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterA, Port<ReferenceOrByte>)`
`IN(Z80Assembly.RegisterA, ReadOnlySpan<ReferenceOrByte>)`
`IN(Z80Assembly.RegisterB, Port<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterB, ReadOnlySpan<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterC, Port<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterC, ReadOnlySpan<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterD, Port<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterD, ReadOnlySpan<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterE, Port<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterE, ReadOnlySpan<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterH, Port<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterH, ReadOnlySpan<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterL, Port<Z80Assembly.RegisterC>)`
`IN(Z80Assembly.RegisterL, ReadOnlySpan<Z80Assembly.RegisterC>)`
`INC(Z80Assembly.RegisterBC)`
`INC(Z80Assembly.RegisterDE)`
`INC(Z80Assembly.RegisterHL)`
`INC(Z80Assembly.RegisterIX)`
`INC(Z80Assembly.RegisterIY)`
`INC(Z80Assembly.RegisterSP)`
`INC(ValueAt<Z80Assembly.RegisterHL>)`
`INC(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`INC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`INC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`INC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`INC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`INC(Z80Assembly.RegisterA)`
`INC(Z80Assembly.RegisterB)`
`INC(Z80Assembly.RegisterC)`
`INC(Z80Assembly.RegisterD)`
`INC(Z80Assembly.RegisterE)`
`INC(Z80Assembly.RegisterH)`
`INC(Z80Assembly.RegisterIXH)`
`INC(Z80Assembly.RegisterIXL)`
`INC(Z80Assembly.RegisterIYH)`
`INC(Z80Assembly.RegisterIYL)`
`INC(Z80Assembly.RegisterL)`
`IND()`	`IND` — Input and Decrement. Reads a byte from port (C) into (HL), then decrements HL and B.
`INDR()`	`INDR` — Input and Decrement Repeated. Reads a byte from port (C) into (HL), then decrements HL and B, repeating until B is zero.
`INI()`	`INI` — Input and Increment. Reads a byte from port (C) into (HL), then increments HL and decrements B.
`INIR()`	`INIR` — Input and Increment Repeated. Reads a byte from port (C) into (HL), then increments HL and decrements B, repeating until B is zero.
`JP(ValueAt<Z80Assembly.RegisterHL>)`
`JP(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`JP(ValueAt<Z80Assembly.RegisterIX>)`
`JP(ReadOnlySpan<Z80Assembly.RegisterIX>)`
`JP(ValueAt<Z80Assembly.RegisterIY>)`
`JP(ReadOnlySpan<Z80Assembly.RegisterIY>)`
`JP(Z80Assembly.ConditionC, ReferenceOrWord)`
`JP(Z80Assembly.ConditionM, ReferenceOrWord)`
`JP(Z80Assembly.ConditionNC, ReferenceOrWord)`
`JP(ReferenceOrWord)`	`JP NNNN` — Jump. Jumps to the target address, optionally only if a condition is met.
`JP(Z80Assembly.ConditionNZ, ReferenceOrWord)`
`JP(Z80Assembly.ConditionP, ReferenceOrWord)`
`JP(Z80Assembly.ConditionPE, ReferenceOrWord)`
`JP(Z80Assembly.ConditionPO, ReferenceOrWord)`
`JP(Z80Assembly.ConditionZ, ReferenceOrWord)`
`JR(Z80Assembly.ConditionC, ReferenceOrOffset)`
`JR(Z80Assembly.ConditionNC, ReferenceOrOffset)`
`JR(ReferenceOrOffset)`	`JR NN` — Jump Relative. Jumps by the signed offset, optionally only if a condition is met.
`JR(Z80Assembly.ConditionNZ, ReferenceOrOffset)`
`JR(Z80Assembly.ConditionZ, ReferenceOrOffset)`
`Label(String)`
`LD(ValueAt<ReferenceOrWord>, Z80Assembly.RegisterBC)`
`LD(ReadOnlySpan<ReferenceOrWord>, Z80Assembly.RegisterBC)`
`LD(ValueAt<ReferenceOrWord>, Z80Assembly.RegisterDE)`
`LD(ReadOnlySpan<ReferenceOrWord>, Z80Assembly.RegisterDE)`
`LD(ValueAt<ReferenceOrWord>, Z80Assembly.RegisterHL)`
`LD(ReadOnlySpan<ReferenceOrWord>, Z80Assembly.RegisterHL)`
`LD(ValueAt<ReferenceOrWord>, Z80Assembly.RegisterIX)`
`LD(ReadOnlySpan<ReferenceOrWord>, Z80Assembly.RegisterIX)`
`LD(ValueAt<ReferenceOrWord>, Z80Assembly.RegisterIY)`
`LD(ReadOnlySpan<ReferenceOrWord>, Z80Assembly.RegisterIY)`
`LD(ValueAt<ReferenceOrWord>, Z80Assembly.RegisterSP)`
`LD(ReadOnlySpan<ReferenceOrWord>, Z80Assembly.RegisterSP)`
`LD(Z80Assembly.RegisterBC, ValueAt<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterBC, ReadOnlySpan<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterBC, ReferenceOrWord)`
`LD(Z80Assembly.RegisterDE, ValueAt<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterDE, ReadOnlySpan<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterDE, ReferenceOrWord)`
`LD(Z80Assembly.RegisterHL, ValueAt<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterHL, ReadOnlySpan<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterHL, ReferenceOrWord)`
`LD(Z80Assembly.RegisterIX, ValueAt<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterIX, ReadOnlySpan<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterIX, ReferenceOrWord)`
`LD(Z80Assembly.RegisterIY, ValueAt<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterIY, ReadOnlySpan<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterIY, ReferenceOrWord)`
`LD(Z80Assembly.RegisterSP, ValueAt<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterSP, ReadOnlySpan<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterSP, Z80Assembly.RegisterHL)`
`LD(Z80Assembly.RegisterSP, Z80Assembly.RegisterIX)`
`LD(Z80Assembly.RegisterSP, Z80Assembly.RegisterIY)`
`LD(Z80Assembly.RegisterSP, ReferenceOrWord)`
`LD(ValueAt<Z80Assembly.RegisterBC>, Z80Assembly.RegisterA)`
`LD(ReadOnlySpan<Z80Assembly.RegisterBC>, Z80Assembly.RegisterA)`
`LD(ValueAt<Z80Assembly.RegisterDE>, Z80Assembly.RegisterA)`
`LD(ReadOnlySpan<Z80Assembly.RegisterDE>, Z80Assembly.RegisterA)`
`LD(ValueAt<Z80Assembly.RegisterHL>, Z80Assembly.RegisterA)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, Z80Assembly.RegisterA)`
`LD(ValueAt<Z80Assembly.RegisterHL>, Z80Assembly.RegisterB)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, Z80Assembly.RegisterB)`
`LD(ValueAt<Z80Assembly.RegisterHL>, Z80Assembly.RegisterC)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, Z80Assembly.RegisterC)`
`LD(ValueAt<Z80Assembly.RegisterHL>, Z80Assembly.RegisterD)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, Z80Assembly.RegisterD)`
`LD(ValueAt<Z80Assembly.RegisterHL>, Z80Assembly.RegisterE)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, Z80Assembly.RegisterE)`
`LD(ValueAt<Z80Assembly.RegisterHL>, Z80Assembly.RegisterH)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, Z80Assembly.RegisterH)`
`LD(ValueAt<Z80Assembly.RegisterHL>, Z80Assembly.RegisterL)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, Z80Assembly.RegisterL)`
`LD(ValueAt<Z80Assembly.RegisterHL>, ReferenceOrByte)`
`LD(ReadOnlySpan<Z80Assembly.RegisterHL>, ReferenceOrByte)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, ReferenceOrByte)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, ReferenceOrByte)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`LD(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, ReferenceOrByte)`
`LD(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, ReferenceOrByte)`
`LD(ValueAt<ReferenceOrWord>, Z80Assembly.RegisterA)`
`LD(ReadOnlySpan<ReferenceOrWord>, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterA, ValueAt<Z80Assembly.RegisterBC>)`
`LD(Z80Assembly.RegisterA, ReadOnlySpan<Z80Assembly.RegisterBC>)`
`LD(Z80Assembly.RegisterA, ValueAt<Z80Assembly.RegisterDE>)`
`LD(Z80Assembly.RegisterA, ReadOnlySpan<Z80Assembly.RegisterDE>)`
`LD(Z80Assembly.RegisterA, ValueAt<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterA, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterA, ValueAt<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterA, ReadOnlySpan<ReferenceOrWord>)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterH)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterI)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterIXH)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterIXL)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterIYH)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterIYL)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterL)`
`LD(Z80Assembly.RegisterA, ReferenceOrByte)`
`LD(Z80Assembly.RegisterA, Z80Assembly.RegisterR)`
`LD(Z80Assembly.RegisterB, ValueAt<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterB, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterB, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterB, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterB, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterB, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterH)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterIXH)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterIXL)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterIYH)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterIYL)`
`LD(Z80Assembly.RegisterB, Z80Assembly.RegisterL)`
`LD(Z80Assembly.RegisterB, ReferenceOrByte)`
`LD(Z80Assembly.RegisterC, ValueAt<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterC, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterC, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterC, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterC, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterC, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterH)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterIXH)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterIXL)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterIYH)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterIYL)`
`LD(Z80Assembly.RegisterC, Z80Assembly.RegisterL)`
`LD(Z80Assembly.RegisterC, ReferenceOrByte)`
`LD(Z80Assembly.RegisterD, ValueAt<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterD, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterD, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterD, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterD, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterD, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterH)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterIXH)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterIXL)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterIYH)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterIYL)`
`LD(Z80Assembly.RegisterD, Z80Assembly.RegisterL)`
`LD(Z80Assembly.RegisterD, ReferenceOrByte)`
`LD(Z80Assembly.RegisterE, ValueAt<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterE, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterE, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterE, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterE, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterE, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterH)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterIXH)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterIXL)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterIYH)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterIYL)`
`LD(Z80Assembly.RegisterE, Z80Assembly.RegisterL)`
`LD(Z80Assembly.RegisterE, ReferenceOrByte)`
`LD(Z80Assembly.RegisterH, ValueAt<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterH, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterH, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterH, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterH, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterH, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterH, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterH, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterH, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterH, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterH, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterH, Z80Assembly.RegisterH)`
`LD(Z80Assembly.RegisterH, Z80Assembly.RegisterL)`
`LD(Z80Assembly.RegisterH, ReferenceOrByte)`
`LD(Z80Assembly.RegisterI, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterIXH, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterIXH, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterIXH, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterIXH, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterIXH, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterIXH, Z80Assembly.RegisterIXH)`
`LD(Z80Assembly.RegisterIXH, Z80Assembly.RegisterIXL)`
`LD(Z80Assembly.RegisterIXH, ReferenceOrByte)`
`LD(Z80Assembly.RegisterIXL, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterIXL, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterIXL, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterIXL, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterIXL, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterIXL, Z80Assembly.RegisterIXH)`
`LD(Z80Assembly.RegisterIXL, Z80Assembly.RegisterIXL)`
`LD(Z80Assembly.RegisterIXL, ReferenceOrByte)`
`LD(Z80Assembly.RegisterIYH, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterIYH, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterIYH, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterIYH, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterIYH, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterIYH, Z80Assembly.RegisterIYH)`
`LD(Z80Assembly.RegisterIYH, Z80Assembly.RegisterIYL)`
`LD(Z80Assembly.RegisterIYH, ReferenceOrByte)`
`LD(Z80Assembly.RegisterIYL, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterIYL, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterIYL, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterIYL, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterIYL, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterIYL, Z80Assembly.RegisterIYH)`
`LD(Z80Assembly.RegisterIYL, Z80Assembly.RegisterIYL)`
`LD(Z80Assembly.RegisterIYL, ReferenceOrByte)`
`LD(Z80Assembly.RegisterL, ValueAt<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterL, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`LD(Z80Assembly.RegisterL, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterL, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`LD(Z80Assembly.RegisterL, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterL, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`LD(Z80Assembly.RegisterL, Z80Assembly.RegisterA)`
`LD(Z80Assembly.RegisterL, Z80Assembly.RegisterB)`
`LD(Z80Assembly.RegisterL, Z80Assembly.RegisterC)`
`LD(Z80Assembly.RegisterL, Z80Assembly.RegisterD)`
`LD(Z80Assembly.RegisterL, Z80Assembly.RegisterE)`
`LD(Z80Assembly.RegisterL, Z80Assembly.RegisterH)`
`LD(Z80Assembly.RegisterL, Z80Assembly.RegisterL)`
`LD(Z80Assembly.RegisterL, ReferenceOrByte)`
`LD(Z80Assembly.RegisterR, Z80Assembly.RegisterA)`
`LDD()`	`LDD` — Load and Decrement. Copies the byte at (HL) to (DE), then decrements HL, DE and BC.
`LDDR()`	`LDDR` — Load and Decrement Repeated. Copies the byte at (HL) to (DE), then decrements HL, DE and BC, repeating until BC is zero.
`LDI()`	`LDI` — Load and Increment. Copies the byte at (HL) to (DE), then increments HL and DE and decrements BC.
`LDIR()`	`LDIR` — Load and Increment Repeated. Copies the byte at (HL) to (DE), then increments HL and DE and decrements BC, repeating until BC is zero.
`NEG()`	`NEG` — Negate. Negates A, subtracting it from zero.
`NOP()`	`NOP` — No Operation. Does nothing.
`OR(ValueAt<Z80Assembly.RegisterHL>)`
`OR(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`OR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`OR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`OR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`OR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`OR(Z80Assembly.RegisterA)`
`OR(Z80Assembly.RegisterB)`
`OR(Z80Assembly.RegisterC)`
`OR(Z80Assembly.RegisterD)`
`OR(Z80Assembly.RegisterE)`
`OR(Z80Assembly.RegisterH)`
`OR(Z80Assembly.RegisterIXH)`
`OR(Z80Assembly.RegisterIXL)`
`OR(Z80Assembly.RegisterIYH)`
`OR(Z80Assembly.RegisterIYL)`
`OR(Z80Assembly.RegisterL)`
`OR(ReferenceOrByte)`	`OR NN` — Logical OR. Performs a bitwise OR of the operand with A, storing the result in A.
`ORG(UInt16)`
`ORG(Location)`
`OTDR()`	`OTDR` — Output and Decrement Repeated. Writes the byte at (HL) to port (C), then decrements HL and B, repeating until B is zero.
`OTIR()`	`OTIR` — Output and Increment Repeated. Writes the byte at (HL) to port (C), then increments HL and decrements B, repeating until B is zero.
`OUT(Port<Z80Assembly.RegisterC>, Z80Assembly.RegisterA)`
`OUT(ReadOnlySpan<Z80Assembly.RegisterC>, Z80Assembly.RegisterA)`
`OUT(Port<Z80Assembly.RegisterC>, Z80Assembly.RegisterB)`
`OUT(ReadOnlySpan<Z80Assembly.RegisterC>, Z80Assembly.RegisterB)`
`OUT(Port<Z80Assembly.RegisterC>, Z80Assembly.RegisterC)`
`OUT(ReadOnlySpan<Z80Assembly.RegisterC>, Z80Assembly.RegisterC)`
`OUT(Port<Z80Assembly.RegisterC>, Z80Assembly.RegisterD)`
`OUT(ReadOnlySpan<Z80Assembly.RegisterC>, Z80Assembly.RegisterD)`
`OUT(Port<Z80Assembly.RegisterC>, Z80Assembly.RegisterE)`
`OUT(ReadOnlySpan<Z80Assembly.RegisterC>, Z80Assembly.RegisterE)`
`OUT(Port<Z80Assembly.RegisterC>, Z80Assembly.RegisterH)`
`OUT(ReadOnlySpan<Z80Assembly.RegisterC>, Z80Assembly.RegisterH)`
`OUT(Port<Z80Assembly.RegisterC>, Z80Assembly.RegisterL)`
`OUT(ReadOnlySpan<Z80Assembly.RegisterC>, Z80Assembly.RegisterL)`
`OUT(Port<ReferenceOrByte>, Z80Assembly.RegisterA)`
`OUT(ReadOnlySpan<ReferenceOrByte>, Z80Assembly.RegisterA)`
`OUT0(Port<Z80Assembly.RegisterC>)`
`OUT0(ReadOnlySpan<Z80Assembly.RegisterC>)`
`OUTD()`	`OUTD` — Output and Decrement. Writes the byte at (HL) to port (C), then decrements HL and B.
`OUTI()`	`OUTI` — Output and Increment. Writes the byte at (HL) to port (C), then increments HL and decrements B.
`POP(Z80Assembly.RegisterAF)`
`POP(Z80Assembly.RegisterBC)`
`POP(Z80Assembly.RegisterDE)`
`POP(Z80Assembly.RegisterHL)`
`POP(Z80Assembly.RegisterIX)`
`POP(Z80Assembly.RegisterIY)`
`Port(ReferenceOrByte)`
`Port<TRegister, TCondition>(RegisterOrCondition<TRegister, TCondition>)`
`PUSH(Z80Assembly.RegisterAF)`
`PUSH(Z80Assembly.RegisterBC)`
`PUSH(Z80Assembly.RegisterDE)`
`PUSH(Z80Assembly.RegisterHL)`
`PUSH(Z80Assembly.RegisterIX)`
`PUSH(Z80Assembly.RegisterIY)`
`RES0(ValueAt<Z80Assembly.RegisterHL>)`
`RES0(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES0(Z80Assembly.RegisterA)`
`RES0(Z80Assembly.RegisterB)`
`RES0(Z80Assembly.RegisterC)`
`RES0(Z80Assembly.RegisterD)`
`RES0(Z80Assembly.RegisterE)`
`RES0(Z80Assembly.RegisterH)`
`RES0(Z80Assembly.RegisterL)`
`RES1(ValueAt<Z80Assembly.RegisterHL>)`
`RES1(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES1(Z80Assembly.RegisterA)`
`RES1(Z80Assembly.RegisterB)`
`RES1(Z80Assembly.RegisterC)`
`RES1(Z80Assembly.RegisterD)`
`RES1(Z80Assembly.RegisterE)`
`RES1(Z80Assembly.RegisterH)`
`RES1(Z80Assembly.RegisterL)`
`RES2(ValueAt<Z80Assembly.RegisterHL>)`
`RES2(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES2(Z80Assembly.RegisterA)`
`RES2(Z80Assembly.RegisterB)`
`RES2(Z80Assembly.RegisterC)`
`RES2(Z80Assembly.RegisterD)`
`RES2(Z80Assembly.RegisterE)`
`RES2(Z80Assembly.RegisterH)`
`RES2(Z80Assembly.RegisterL)`
`RES3(ValueAt<Z80Assembly.RegisterHL>)`
`RES3(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES3(Z80Assembly.RegisterA)`
`RES3(Z80Assembly.RegisterB)`
`RES3(Z80Assembly.RegisterC)`
`RES3(Z80Assembly.RegisterD)`
`RES3(Z80Assembly.RegisterE)`
`RES3(Z80Assembly.RegisterH)`
`RES3(Z80Assembly.RegisterL)`
`RES4(ValueAt<Z80Assembly.RegisterHL>)`
`RES4(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES4(Z80Assembly.RegisterA)`
`RES4(Z80Assembly.RegisterB)`
`RES4(Z80Assembly.RegisterC)`
`RES4(Z80Assembly.RegisterD)`
`RES4(Z80Assembly.RegisterE)`
`RES4(Z80Assembly.RegisterH)`
`RES4(Z80Assembly.RegisterL)`
`RES5(ValueAt<Z80Assembly.RegisterHL>)`
`RES5(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES5(Z80Assembly.RegisterA)`
`RES5(Z80Assembly.RegisterB)`
`RES5(Z80Assembly.RegisterC)`
`RES5(Z80Assembly.RegisterD)`
`RES5(Z80Assembly.RegisterE)`
`RES5(Z80Assembly.RegisterH)`
`RES5(Z80Assembly.RegisterL)`
`RES6(ValueAt<Z80Assembly.RegisterHL>)`
`RES6(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES6(Z80Assembly.RegisterA)`
`RES6(Z80Assembly.RegisterB)`
`RES6(Z80Assembly.RegisterC)`
`RES6(Z80Assembly.RegisterD)`
`RES6(Z80Assembly.RegisterE)`
`RES6(Z80Assembly.RegisterH)`
`RES6(Z80Assembly.RegisterL)`
`RES7(ValueAt<Z80Assembly.RegisterHL>)`
`RES7(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RES7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RES7(Z80Assembly.RegisterA)`
`RES7(Z80Assembly.RegisterB)`
`RES7(Z80Assembly.RegisterC)`
`RES7(Z80Assembly.RegisterD)`
`RES7(Z80Assembly.RegisterE)`
`RES7(Z80Assembly.RegisterH)`
`RES7(Z80Assembly.RegisterL)`
`RET()`	`RET` — Return. Pops the return address from the stack and jumps to it, optionally only if a condition is met.
`RET(Z80Assembly.ConditionC)`
`RET(Z80Assembly.ConditionM)`
`RET(Z80Assembly.ConditionNC)`
`RET(Z80Assembly.ConditionNZ)`
`RET(Z80Assembly.ConditionP)`
`RET(Z80Assembly.ConditionPE)`
`RET(Z80Assembly.ConditionPO)`
`RET(Z80Assembly.ConditionZ)`
`RETI()`	`RETI` — Return from Interrupt. Returns from a maskable interrupt handler.
`RETN()`	`RETN` — Return from Non-Maskable Interrupt. Returns from a non-maskable interrupt handler, restoring the interrupt enable state.
`RL(ValueAt<Z80Assembly.RegisterHL>)`
`RL(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RL(Z80Assembly.RegisterA)`
`RL(Z80Assembly.RegisterB)`
`RL(Z80Assembly.RegisterC)`
`RL(Z80Assembly.RegisterD)`
`RL(Z80Assembly.RegisterE)`
`RL(Z80Assembly.RegisterH)`
`RL(Z80Assembly.RegisterL)`
`RLA()`	`RLA` — Rotate Left Accumulator. Rotates A left one bit through the carry flag.
`RLC(ValueAt<Z80Assembly.RegisterHL>)`
`RLC(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RLC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RLC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RLC(Z80Assembly.RegisterA)`
`RLC(Z80Assembly.RegisterB)`
`RLC(Z80Assembly.RegisterC)`
`RLC(Z80Assembly.RegisterD)`
`RLC(Z80Assembly.RegisterE)`
`RLC(Z80Assembly.RegisterH)`
`RLC(Z80Assembly.RegisterL)`
`RLCA()`	`RLCA` — Rotate Left Circular Accumulator. Rotates A left one bit, copying bit 7 into both the carry flag and bit 0.
`RLD()`	`RLD` — Rotate Left Decimal. Rotates the low nibble of A and the two nibbles of (HL) left one nibble as a twelve bit value.
`RR(ValueAt<Z80Assembly.RegisterHL>)`
`RR(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RR(Z80Assembly.RegisterA)`
`RR(Z80Assembly.RegisterB)`
`RR(Z80Assembly.RegisterC)`
`RR(Z80Assembly.RegisterD)`
`RR(Z80Assembly.RegisterE)`
`RR(Z80Assembly.RegisterH)`
`RR(Z80Assembly.RegisterL)`
`RRA()`	`RRA` — Rotate Right Accumulator. Rotates A right one bit through the carry flag.
`RRC(ValueAt<Z80Assembly.RegisterHL>)`
`RRC(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`RRC(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RRC(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`RRC(Z80Assembly.RegisterA)`
`RRC(Z80Assembly.RegisterB)`
`RRC(Z80Assembly.RegisterC)`
`RRC(Z80Assembly.RegisterD)`
`RRC(Z80Assembly.RegisterE)`
`RRC(Z80Assembly.RegisterH)`
`RRC(Z80Assembly.RegisterL)`
`RRCA()`	`RRCA` — Rotate Right Circular Accumulator. Rotates A right one bit, copying bit 0 into both the carry flag and bit 7.
`RRD()`	`RRD` — Rotate Right Decimal. Rotates the low nibble of A and the two nibbles of (HL) right one nibble as a twelve bit value.
`RST00()`	`RST 00` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`RST08()`	`RST 08` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`RST10()`	`RST 10` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`RST18()`	`RST 18` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`RST20()`	`RST 20` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`RST28()`	`RST 28` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`RST30()`	`RST 30` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`RST38()`	`RST 38` — Restart. Pushes the address of the next instruction onto the stack and jumps to the fixed page zero address.
`SBC(Z80Assembly.RegisterHL, Z80Assembly.RegisterBC)`
`SBC(Z80Assembly.RegisterHL, Z80Assembly.RegisterDE)`
`SBC(Z80Assembly.RegisterHL, Z80Assembly.RegisterHL)`
`SBC(Z80Assembly.RegisterHL, Z80Assembly.RegisterSP)`
`SBC(Z80Assembly.RegisterA, ValueAt<Z80Assembly.RegisterHL>)`
`SBC(Z80Assembly.RegisterA, ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SBC(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SBC(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SBC(Z80Assembly.RegisterA, ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SBC(Z80Assembly.RegisterA, ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterA)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterB)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterC)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterD)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterE)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterH)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterIXH)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterIXL)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterIYH)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterIYL)`
`SBC(Z80Assembly.RegisterA, Z80Assembly.RegisterL)`
`SBC(Z80Assembly.RegisterA, ReferenceOrByte)`
`SCF()`	`SCF` — Set Carry Flag. Sets the carry flag.
`SET0(ValueAt<Z80Assembly.RegisterHL>)`
`SET0(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET0(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET0(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET0(Z80Assembly.RegisterA)`
`SET0(Z80Assembly.RegisterB)`
`SET0(Z80Assembly.RegisterC)`
`SET0(Z80Assembly.RegisterD)`
`SET0(Z80Assembly.RegisterE)`
`SET0(Z80Assembly.RegisterH)`
`SET0(Z80Assembly.RegisterL)`
`SET1(ValueAt<Z80Assembly.RegisterHL>)`
`SET1(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET1(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET1(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET1(Z80Assembly.RegisterA)`
`SET1(Z80Assembly.RegisterB)`
`SET1(Z80Assembly.RegisterC)`
`SET1(Z80Assembly.RegisterD)`
`SET1(Z80Assembly.RegisterE)`
`SET1(Z80Assembly.RegisterH)`
`SET1(Z80Assembly.RegisterL)`
`SET2(ValueAt<Z80Assembly.RegisterHL>)`
`SET2(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET2(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET2(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET2(Z80Assembly.RegisterA)`
`SET2(Z80Assembly.RegisterB)`
`SET2(Z80Assembly.RegisterC)`
`SET2(Z80Assembly.RegisterD)`
`SET2(Z80Assembly.RegisterE)`
`SET2(Z80Assembly.RegisterH)`
`SET2(Z80Assembly.RegisterL)`
`SET3(ValueAt<Z80Assembly.RegisterHL>)`
`SET3(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET3(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET3(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET3(Z80Assembly.RegisterA)`
`SET3(Z80Assembly.RegisterB)`
`SET3(Z80Assembly.RegisterC)`
`SET3(Z80Assembly.RegisterD)`
`SET3(Z80Assembly.RegisterE)`
`SET3(Z80Assembly.RegisterH)`
`SET3(Z80Assembly.RegisterL)`
`SET4(ValueAt<Z80Assembly.RegisterHL>)`
`SET4(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET4(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET4(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET4(Z80Assembly.RegisterA)`
`SET4(Z80Assembly.RegisterB)`
`SET4(Z80Assembly.RegisterC)`
`SET4(Z80Assembly.RegisterD)`
`SET4(Z80Assembly.RegisterE)`
`SET4(Z80Assembly.RegisterH)`
`SET4(Z80Assembly.RegisterL)`
`SET5(ValueAt<Z80Assembly.RegisterHL>)`
`SET5(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET5(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET5(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET5(Z80Assembly.RegisterA)`
`SET5(Z80Assembly.RegisterB)`
`SET5(Z80Assembly.RegisterC)`
`SET5(Z80Assembly.RegisterD)`
`SET5(Z80Assembly.RegisterE)`
`SET5(Z80Assembly.RegisterH)`
`SET5(Z80Assembly.RegisterL)`
`SET6(ValueAt<Z80Assembly.RegisterHL>)`
`SET6(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET6(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET6(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET6(Z80Assembly.RegisterA)`
`SET6(Z80Assembly.RegisterB)`
`SET6(Z80Assembly.RegisterC)`
`SET6(Z80Assembly.RegisterD)`
`SET6(Z80Assembly.RegisterE)`
`SET6(Z80Assembly.RegisterH)`
`SET6(Z80Assembly.RegisterL)`
`SET7(ValueAt<Z80Assembly.RegisterHL>)`
`SET7(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SET7(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET7(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SET7(Z80Assembly.RegisterA)`
`SET7(Z80Assembly.RegisterB)`
`SET7(Z80Assembly.RegisterC)`
`SET7(Z80Assembly.RegisterD)`
`SET7(Z80Assembly.RegisterE)`
`SET7(Z80Assembly.RegisterH)`
`SET7(Z80Assembly.RegisterL)`
`SLA(ValueAt<Z80Assembly.RegisterHL>)`
`SLA(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SLA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SLA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SLA(Z80Assembly.RegisterA)`
`SLA(Z80Assembly.RegisterB)`
`SLA(Z80Assembly.RegisterC)`
`SLA(Z80Assembly.RegisterD)`
`SLA(Z80Assembly.RegisterE)`
`SLA(Z80Assembly.RegisterH)`
`SLA(Z80Assembly.RegisterL)`
`SLL(ValueAt<Z80Assembly.RegisterHL>)`
`SLL(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SLL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SLL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SLL(Z80Assembly.RegisterA)`
`SLL(Z80Assembly.RegisterB)`
`SLL(Z80Assembly.RegisterC)`
`SLL(Z80Assembly.RegisterD)`
`SLL(Z80Assembly.RegisterE)`
`SLL(Z80Assembly.RegisterH)`
`SLL(Z80Assembly.RegisterL)`
`SRA(ValueAt<Z80Assembly.RegisterHL>)`
`SRA(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SRA(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SRA(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SRA(Z80Assembly.RegisterA)`
`SRA(Z80Assembly.RegisterB)`
`SRA(Z80Assembly.RegisterC)`
`SRA(Z80Assembly.RegisterD)`
`SRA(Z80Assembly.RegisterE)`
`SRA(Z80Assembly.RegisterH)`
`SRA(Z80Assembly.RegisterL)`
`SRL(ValueAt<Z80Assembly.RegisterHL>)`
`SRL(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterA)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterB)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterC)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterD)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterE)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterH)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>, Z80Assembly.RegisterL)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterA)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterB)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterC)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterD)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterE)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterH)`
`SRL(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SRL(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>, Z80Assembly.RegisterL)`
`SRL(Z80Assembly.RegisterA)`
`SRL(Z80Assembly.RegisterB)`
`SRL(Z80Assembly.RegisterC)`
`SRL(Z80Assembly.RegisterD)`
`SRL(Z80Assembly.RegisterE)`
`SRL(Z80Assembly.RegisterH)`
`SRL(Z80Assembly.RegisterL)`
`SUB(ValueAt<Z80Assembly.RegisterHL>)`
`SUB(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`SUB(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SUB(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`SUB(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SUB(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`SUB(Z80Assembly.RegisterA)`
`SUB(Z80Assembly.RegisterB)`
`SUB(Z80Assembly.RegisterC)`
`SUB(Z80Assembly.RegisterD)`
`SUB(Z80Assembly.RegisterE)`
`SUB(Z80Assembly.RegisterH)`
`SUB(Z80Assembly.RegisterIXH)`
`SUB(Z80Assembly.RegisterIXL)`
`SUB(Z80Assembly.RegisterIYH)`
`SUB(Z80Assembly.RegisterIYL)`
`SUB(Z80Assembly.RegisterL)`
`SUB(ReferenceOrByte)`	`SUB NN` — Subtract. Subtracts the operand from A.
`XOR(ValueAt<Z80Assembly.RegisterHL>)`
`XOR(ReadOnlySpan<Z80Assembly.RegisterHL>)`
`XOR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`XOR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIX>>)`
`XOR(ValueAt<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`XOR(ReadOnlySpan<RegisterWithOffset<Z80Assembly.RegisterIY>>)`
`XOR(Z80Assembly.RegisterA)`
`XOR(Z80Assembly.RegisterB)`
`XOR(Z80Assembly.RegisterC)`
`XOR(Z80Assembly.RegisterD)`
`XOR(Z80Assembly.RegisterE)`
`XOR(Z80Assembly.RegisterH)`
`XOR(Z80Assembly.RegisterIXH)`
`XOR(Z80Assembly.RegisterIXL)`
`XOR(Z80Assembly.RegisterIYH)`
`XOR(Z80Assembly.RegisterIYL)`
`XOR(Z80Assembly.RegisterL)`
`XOR(ReferenceOrByte)`	`XOR NN` — Logical Exclusive OR. Performs a bitwise exclusive OR of the operand with A, storing the result in A.

MrKWatkins.OakAsm

MrKWatkins.OakAsm.Assembly

MrKWatkins.OakAsm.Ast

MrKWatkins.OakAsm.Ast.Directives

MrKWatkins.OakAsm.Ast.Expressions

MrKWatkins.OakAsm.Ast.Literals

MrKWatkins.OakAsm.Ast.Resolution.Opcodes

MrKWatkins.OakAsm.Disassembly

MrKWatkins.OakAsm.Disassembly.OpcodeReader

MrKWatkins.OakAsm.Disassembly.Z80

MrKWatkins.OakAsm.Formatting

MrKWatkins.OakAsm.Formatting.Configuration

MrKWatkins.OakAsm.Formatting.Layout

MrKWatkins.OakAsm.IO

MrKWatkins.OakAsm.IO.ZXSpectrum

MrKWatkins.OakAsm.Parsing

MrKWatkins.OakAsm.Projects

MrKWatkins.OakAsm.Testing

MrKWatkins.OakAsm.Z80

MrKWatkins.OakAsm.Z80N

Z80Assembly Class

Definition

Properties

Methods

Z80Assembly Class ​

Definition ​

Properties ​

Methods ​

Z80Assembly Class

Definition

Properties

Methods