Allow "reinterpretation" of framebuffer/zeta formats (#418)

* (Re)Implement format reinterpretation, other changes

* Implement writeback to guest memory, some refactoring

* More refactoring, implement reinterpretation the old way again

* Clean up

* Some fixes on M2MF (old Dma engine), added partial support for P2MF, fix conditional ssy, add Z24S8 zeta format, other fixes

* nit: Formatting

* Address PR feedback

10 files changed, 129 insertions, 142 deletions

diff --git a/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs b/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs
index ac34400e..60fe91c2 100644
--- a/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs
+++ b/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs
@@ -641,6 +641,7 @@ namespace Ryujinx.Graphics.Gal.Shader
 
                     default:
                         SB.AppendLine(Identation + GetSrcExpr(Op, true) + ";");
+
                         break;
                 }
             }
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs
index c2ee474b..0a3c0da9 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs
@@ -6,32 +6,32 @@ namespace Ryujinx.Graphics.Gal.Shader
 {
     static partial class ShaderDecode
     {
-        public static void Bfe_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bfe_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitBfe(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Bfe_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bfe_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitBfe(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Bfe_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bfe_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitBfe(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fadd_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFadd(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fadd_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFadd(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fadd_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
             ShaderIrNode OperB = OpCode.Immf32_20();
@@ -49,47 +49,47 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Fadd_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFadd(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Ffma_CR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_CR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Ffma_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Ffma_RC(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_RC(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.RC);
         }
 
-        public static void Ffma_RR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_RR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fmnmx_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmnmx_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmnmx(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fmnmx_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmnmx_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmnmx(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fmnmx_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmnmx_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmnmx(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fmul_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
             ShaderIrNode OperB = OpCode.Immf32_20();
@@ -99,62 +99,62 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Fmul_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmul(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fmul_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmul(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fmul_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmul(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fset_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fset_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFset(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fset_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fset_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFset(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fset_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fset_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFset(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fsetp_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fsetp_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFsetp(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fsetp_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fsetp_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFsetp(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fsetp_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fsetp_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFsetp(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Iadd_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iadd_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iadd_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
             ShaderIrNode OperB = OpCode.Imm32_20();
@@ -168,42 +168,42 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Iadd_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Iadd3_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd3_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd3(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iadd3_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd3_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd3(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iadd3_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd3_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd3(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Imnmx_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Imnmx_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitImnmx(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Imnmx_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Imnmx_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitImnmx(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Imnmx_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Imnmx_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitImnmx(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Ipa(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ipa(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Abuf28();
             ShaderIrNode OperB = OpCode.Gpr20();
@@ -217,52 +217,52 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Iscadd_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iscadd_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIscadd(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iscadd_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iscadd_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIscadd(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iscadd_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iscadd_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIscadd(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Iset_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iset_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIset(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iset_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iset_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIset(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iset_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iset_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIset(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Isetp_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isetp_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIsetp(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Isetp_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isetp_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIsetp(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Isetp_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isetp_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIsetp(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Lop_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             int SubOp = OpCode.Read(53, 3);
 
@@ -296,22 +296,22 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Lop_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitLop(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Lop_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitLop(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Lop_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitLop(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Mufu(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mufu(ShaderIrBlock Block, long OpCode, int Position)
         {
             int SubOp = OpCode.Read(20, 0xf);
 
@@ -340,7 +340,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Psetp(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Psetp(ShaderIrBlock Block, long OpCode, int Position)
         {
             bool NegA = OpCode.Read(15);
             bool NegB = OpCode.Read(32);
@@ -394,47 +394,47 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op)));
         }
 
-        public static void Rro_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Rro_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitRro(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Rro_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Rro_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitRro(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Rro_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Rro_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitRro(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Shl_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shl_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.CR, ShaderIrInst.Lsl);
         }
 
-        public static void Shl_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shl_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.Imm, ShaderIrInst.Lsl);
         }
 
-        public static void Shl_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shl_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.RR, ShaderIrInst.Lsl);
         }
 
-        public static void Shr_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shr_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.CR, GetShrInst(OpCode));
         }
 
-        public static void Shr_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shr_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.Imm, GetShrInst(OpCode));
         }
 
-        public static void Shr_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shr_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.RR, GetShrInst(OpCode));
         }
@@ -446,7 +446,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             return Signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr;
         }
 
-        public static void Vmad(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Vmad(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
 
@@ -481,22 +481,22 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Final)));
         }
 
-        public static void Xmad_CR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_CR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Xmad_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Xmad_RC(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_RC(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.RC);
         }
 
-        public static void Xmad_RR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_RR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.RR);
         }
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs
index dfd10e00..bc2539bd 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs
@@ -1,12 +1,10 @@
 using System;
 
-using static Ryujinx.Graphics.Gal.Shader.ShaderDecodeHelper;
-
 namespace Ryujinx.Graphics.Gal.Shader
 {
     static partial class ShaderDecode
     {
-        public static void Bra(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bra(ShaderIrBlock Block, long OpCode, int Position)
         {
             if ((OpCode & 0x20) != 0)
             {
@@ -15,14 +13,12 @@ namespace Ryujinx.Graphics.Gal.Shader
                 throw new NotImplementedException();
             }
 
-            int Target = OpCode.Branch();
-
-            ShaderIrOperImm Imm = new ShaderIrOperImm(Target);
+            ShaderIrOperImm Imm = new ShaderIrOperImm(Position + OpCode.Branch());
 
             Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Bra, Imm)));
         }
 
-        public static void Exit(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Exit(ShaderIrBlock Block, long OpCode, int Position)
         {
             int CCode = (int)OpCode & 0x1f;
 
@@ -31,15 +27,14 @@ namespace Ryujinx.Graphics.Gal.Shader
             {
                 Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Exit)));
             }
-
         }
 
-        public static void Kil(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Kil(ShaderIrBlock Block, long OpCode, int Position)
         {
             Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Kil)));
         }
 
-        public static void Ssy(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ssy(ShaderIrBlock Block, long OpCode, int Position)
         {
             if ((OpCode & 0x20) != 0)
             {
@@ -48,19 +43,14 @@ namespace Ryujinx.Graphics.Gal.Shader
                 throw new NotImplementedException();
             }
 
-            int Offset = OpCode.Branch();
-
-            int Target = (int)(Position + Offset);
-
-            ShaderIrOperImm Imm = new ShaderIrOperImm(Target);
+            ShaderIrOperImm Imm = new ShaderIrOperImm(Position + OpCode.Branch());
 
             Block.AddNode(new ShaderIrOp(ShaderIrInst.Ssy, Imm));
         }
 
-        public static void Sync(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sync(ShaderIrBlock Block, long OpCode, int Position)
         {
             //TODO: Implement Sync condition codes
-
             Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Sync)));
         }
     }
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecode.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFunc.cs
index 73625f65..73248aa0 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecode.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFunc.cs
@@ -1,4 +1,4 @@
 namespace Ryujinx.Graphics.Gal.Shader
 {
-    delegate void ShaderDecodeFunc(ShaderIrBlock Block, long OpCode, long Position);
+    delegate void ShaderDecodeFunc(ShaderIrBlock Block, long OpCode, int Position);
 }
\ No newline at end of file
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs
index 010f06aa..ebacd53a 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace Ryujinx.Graphics.Gal.Shader
 {
     static class ShaderDecodeHelper
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs
index 508a0205..cd655995 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs
@@ -31,7 +31,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             { RGB_, RG_A, R_BA, _GBA, RGBA, ____, ____, ____ }
         };
 
-        public static void Ld_A(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ld_A(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode[] Opers = OpCode.Abuf20();
 
@@ -50,7 +50,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Ld_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ld_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             int CbufPos   = OpCode.Read(22, 0x3fff);
             int CbufIndex = OpCode.Read(36, 0x1f);
@@ -97,7 +97,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void St_A(ShaderIrBlock Block, long OpCode, long Position)
+        public static void St_A(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode[] Opers = OpCode.Abuf20();
 
@@ -113,7 +113,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Texq(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Texq(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperD = OpCode.Gpr0();
             ShaderIrNode OperA = OpCode.Gpr8();
@@ -132,12 +132,12 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperA, Op1))); //Is this right?
         }
 
-        public static void Tex(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Tex(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTex(Block, OpCode, GprHandle: false);
         }
 
-        public static void Tex_B(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Tex_B(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTex(Block, OpCode, GprHandle: true);
         }
@@ -202,12 +202,12 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Texs(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Texs(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTexs(Block, OpCode, ShaderIrInst.Texs);
         }
 
-        public static void Tlds(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Tlds(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTexs(Block, OpCode, ShaderIrInst.Txlf);
         }
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs
index add39402..cd602db7 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs
@@ -25,67 +25,67 @@ namespace Ryujinx.Graphics.Gal.Shader
             F64 = 3
         }
 
-        public static void F2f_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2f_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2f(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void F2f_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2f_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2f(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void F2f_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2f_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2f(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void F2i_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2i_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2i(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void F2i_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2i_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2i(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void F2i_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2i_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2i(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void I2f_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2f_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2f(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void I2f_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2f_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2f(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void I2f_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2f_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2f(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void I2i_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2i_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2i(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void I2i_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2i_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2i(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void I2i_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2i_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2i(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Isberd(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isberd(ShaderIrBlock Block, long OpCode, int Position)
         {
             //This instruction seems to be used to translate from an address to a vertex index in a GS
             //Stub it as such
@@ -95,50 +95,50 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OpCode.Gpr8())));
         }
 
-        public static void Mov_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperCbuf Cbuf = OpCode.Cbuf34();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Cbuf)));
         }
 
-        public static void Mov_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperImm Imm = OpCode.Imm19_20();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm)));
         }
 
-        public static void Mov_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperImm Imm = OpCode.Imm32_20();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm)));
         }
 
-        public static void Mov_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperGpr Gpr = OpCode.Gpr20();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Gpr)));
         }
 
-        public static void Sel_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sel_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitSel(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Sel_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sel_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitSel(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Sel_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sel_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitSel(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Mov_S(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_S(ShaderIrBlock Block, long OpCode, int Position)
         {
             Block.AddNode(new ShaderIrCmnt("Stubbed."));
 
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs
index c3e42654..35abdb76 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs
@@ -1,10 +1,8 @@
-using static Ryujinx.Graphics.Gal.Shader.ShaderDecodeHelper;
-
-namespace Ryujinx.Graphics.Gal.Shader
+namespace Ryujinx.Graphics.Gal.Shader
 {
     static partial class ShaderDecode
     {
-        public static void Out_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Out_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             //TODO: Those registers have to be used for something
             ShaderIrOperGpr Gpr0  = OpCode.Gpr0();
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecoder.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecoder.cs
index 81d8f312..ac6ae8d5 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderDecoder.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecoder.cs
@@ -10,12 +10,14 @@ namespace Ryujinx.Graphics.Gal.Shader
 
         public static ShaderIrBlock[] Decode(IGalMemory Memory, long Start)
         {
-            Dictionary<long, ShaderIrBlock> Visited    = new Dictionary<long, ShaderIrBlock>();
-            Dictionary<long, ShaderIrBlock> VisitedEnd = new Dictionary<long, ShaderIrBlock>();
+            Dictionary<int, ShaderIrBlock> Visited    = new Dictionary<int, ShaderIrBlock>();
+            Dictionary<int, ShaderIrBlock> VisitedEnd = new Dictionary<int, ShaderIrBlock>();
 
             Queue<ShaderIrBlock> Blocks = new Queue<ShaderIrBlock>();
 
-            ShaderIrBlock Enqueue(long Position, ShaderIrBlock Source = null)
+            long Beginning = Start + HeaderSize;
+
+            ShaderIrBlock Enqueue(int Position, ShaderIrBlock Source = null)
             {
                 if (!Visited.TryGetValue(Position, out ShaderIrBlock Output))
                 {
@@ -34,13 +36,13 @@ namespace Ryujinx.Graphics.Gal.Shader
                 return Output;
             }
 
-            ShaderIrBlock Entry = Enqueue(Start + HeaderSize);
+            ShaderIrBlock Entry = Enqueue(0);
 
             while (Blocks.Count > 0)
             {
                 ShaderIrBlock Current = Blocks.Dequeue();
 
-                FillBlock(Memory, Current, Start + HeaderSize);
+                FillBlock(Memory, Current, Beginning);
 
                 //Set child blocks. "Branch" is the block the branch instruction
                 //points to (when taken), "Next" is the block at the next address,
@@ -54,20 +56,18 @@ namespace Ryujinx.Graphics.Gal.Shader
 
                     if (InnerOp?.Inst == ShaderIrInst.Bra)
                     {
-                        int Offset = ((ShaderIrOperImm)InnerOp.OperandA).Value;
-
-                        long Target = Current.EndPosition + Offset;
+                        int Target = ((ShaderIrOperImm)InnerOp.OperandA).Value;
 
                         Current.Branch = Enqueue(Target, Current);
                     }
 
                     foreach (ShaderIrNode Node in Current.Nodes)
                     {
-                        if (Node is ShaderIrOp CurrOp && CurrOp.Inst == ShaderIrInst.Ssy)
-                        {
-                            int Offset = ((ShaderIrOperImm)CurrOp.OperandA).Value;
+                        InnerOp = GetInnermostOp(Node);
 
-                            long Target = Offset;
+                        if (InnerOp is ShaderIrOp CurrOp && CurrOp.Inst == ShaderIrInst.Ssy)
+                        {
+                            int Target = ((ShaderIrOperImm)CurrOp.OperandA).Value;
 
                             Current.Branch = Enqueue(Target, Current);
                         }
@@ -112,15 +112,15 @@ namespace Ryujinx.Graphics.Gal.Shader
 
             while (Visited.Count > 0)
             {
-                ulong FirstPos = ulong.MaxValue;
+                uint FirstPos = uint.MaxValue;
 
                 foreach (ShaderIrBlock Block in Visited.Values)
                 {
-                    if (FirstPos > (ulong)Block.Position)
-                        FirstPos = (ulong)Block.Position;
+                    if (FirstPos > (uint)Block.Position)
+                        FirstPos = (uint)Block.Position;
                 }
 
-                ShaderIrBlock Current = Visited[(long)FirstPos];
+                ShaderIrBlock Current = Visited[(int)FirstPos];
 
                 do
                 {
@@ -138,20 +138,20 @@ namespace Ryujinx.Graphics.Gal.Shader
 
         private static void FillBlock(IGalMemory Memory, ShaderIrBlock Block, long Beginning)
         {
-            long Position = Block.Position;
+            int Position = Block.Position;
 
             do
             {
                 //Ignore scheduling instructions, which are written every 32 bytes.
-                if (((Position - Beginning) & 0x1f) == 0)
+                if ((Position & 0x1f) == 0)
                 {
                     Position += 8;
 
                     continue;
                 }
 
-                uint Word0 = (uint)Memory.ReadInt32(Position + 0);
-                uint Word1 = (uint)Memory.ReadInt32(Position + 4);
+                uint Word0 = (uint)Memory.ReadInt32(Position + Beginning + 0);
+                uint Word1 = (uint)Memory.ReadInt32(Position + Beginning + 4);
 
                 Position += 8;
 
@@ -161,7 +161,7 @@ namespace Ryujinx.Graphics.Gal.Shader
 
                 if (AddDbgComments)
                 {
-                    string DbgOpCode = $"0x{(Position - Beginning - 8):x16}: 0x{OpCode:x16} ";
+                    string DbgOpCode = $"0x{(Position - 8):x16}: 0x{OpCode:x16} ";
 
                     DbgOpCode += (Decode?.Method.Name ?? "???");
 
@@ -169,7 +169,7 @@ namespace Ryujinx.Graphics.Gal.Shader
                     {
                         int Offset = ((int)(OpCode >> 20) << 8) >> 8;
 
-                        long Target = Position + Offset - Beginning;
+                        long Target = Position + Offset;
 
                         DbgOpCode += " (0x" + Target.ToString("x16") + ")";
                     }
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderIrBlock.cs b/Ryujinx.Graphics/Gal/Shader/ShaderIrBlock.cs
index 50e563b8..782f9626 100644
--- a/Ryujinx.Graphics/Gal/Shader/ShaderIrBlock.cs
+++ b/Ryujinx.Graphics/Gal/Shader/ShaderIrBlock.cs
@@ -4,8 +4,8 @@ namespace Ryujinx.Graphics.Gal.Shader
 {
     class ShaderIrBlock
     {
-        public long Position    { get; set; }
-        public long EndPosition { get; set; }
+        public int Position    { get; set; }
+        public int EndPosition { get; set; }
 
         public ShaderIrBlock Next   { get; set; }
         public ShaderIrBlock Branch { get; set; }
@@ -14,7 +14,7 @@ namespace Ryujinx.Graphics.Gal.Shader
 
         public List<ShaderIrNode> Nodes { get; private set; }
 
-        public ShaderIrBlock(long Position)
+        public ShaderIrBlock(int Position)
         {
             this.Position = Position;