diff --git a/Enthusiast/Splatoon_2880p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..fc1dde29
--- /dev/null
+++ b/Enthusiast/Splatoon_2880p/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 2880
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.09502547, 0.17728101, 0.13421680, 0.08118479, 0.03910895, 0.01493251, 0.00448942, 0.00105364, 0.00019089, 0.00002632, 0.00000271, 0.00000020, 0.00000001 );
+uniform float offset[] = float[]( 0.00000000, 1.47887324, 3.45070423, 5.42253521, 7.39436620, 9.36619718, 11.33802817, 13.30985915, 15.28169014, 17.25352113, 19.22535211, 21.19718310, 23.16901408 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<13; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Enthusiast/Splatoon_2880p/34eaf9e211e76379_00000000000003c9_ps.txt b/Enthusiast/Splatoon_2880p/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Enthusiast/Splatoon_2880p/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..63c1fa9c 100644
--- a/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 2880
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.08123271, 0.15437530, 0.12585196, 0.08706739, 0.05105315, 0.02532582, 0.01060251, 0.00373415, 0.00110209, 0.00027128 );
+uniform float offset[] = float[]( 0.00000000, 1.48453608, 3.46391753, 5.44329897, 7.42268041, 9.40206186, 11.38144330, 13.36082474, 15.34020619, 17.31958763 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<10; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..6671781a 100644
--- a/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 2880
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.08123271, 0.15437530, 0.12585196, 0.08706739, 0.05105315, 0.02532582, 0.01060251, 0.00373415, 0.00110209, 0.00027128 );
+uniform float offset[] = float[]( 0.00000000, 1.48453608, 3.46391753, 5.44329897, 7.42268041, 9.40206186, 11.38144330, 13.36082474, 15.34020619, 17.31958763 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<10; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 30 --reduce 30 37 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Enthusiast/Splatoon_2880p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..b8f4f26d
--- /dev/null
+++ b/Enthusiast/Splatoon_2880p/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 2880
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.09502547, 0.17728101, 0.13421680, 0.08118479, 0.03910895, 0.01493251, 0.00448942, 0.00105364, 0.00019089, 0.00002632, 0.00000271, 0.00000020, 0.00000001 );
+uniform float offset[] = float[]( 0.00000000, 1.47887324, 3.45070423, 5.42253521, 7.39436620, 9.36619718, 11.33802817, 13.30985915, 15.28169014, 17.25352113, 19.22535211, 21.19718310, 23.16901408 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<13; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 9 --reduce 9 53 --linear
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}
diff --git a/Enthusiast/Splatoon_4320p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..7d5741c9
--- /dev/null
+++ b/Enthusiast/Splatoon_4320p/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 4320
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.07731484, 0.14762709, 0.12265258, 0.08781380, 0.05412785, 0.02868527, 0.01304628, 0.00508044, 0.00168915, 0.00047786, 0.00011455, 0.00002316, 0.00000393, 0.00000055, 0.00000006, 0.00000001 );
+uniform float offset[] = float[]( 0.00000000, 1.48598131, 3.46728972, 5.44859813, 7.42990654, 9.41121495, 11.39252336, 13.37383178, 15.35514019, 17.33644860, 19.31775701, 21.29906542, 23.28037383, 25.26168224, 27.24299065, 29.22429907 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<16; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Enthusiast/Splatoon_4320p/34eaf9e211e76379_00000000000003c9_ps.txt b/Enthusiast/Splatoon_4320p/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Enthusiast/Splatoon_4320p/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..6bbe5aa5 100644
--- a/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 4320
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.05721114, 0.11153873, 0.10071616, 0.08380551, 0.06425089, 0.04537556, 0.02951030, 0.01766751, 0.00973277, 0.00493097, 0.00229618, 0.00098211, 0.00038554, 0.00013879, 0.00004577, 0.00001382, 0.00000381 );
+uniform float offset[] = float[]( 0.00000000, 1.49230769, 3.48205128, 5.47179487, 7.46153846, 9.45128205, 11.44102564, 13.43076923, 15.42051282, 17.41025641, 19.40000000, 21.38974359, 23.37948718, 25.36923077, 27.35897436, 29.34871795, 31.33846154 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<17; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..0ae50a4a 100644
--- a/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 4320
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.05721114, 0.11153873, 0.10071616, 0.08380551, 0.06425089, 0.04537556, 0.02951030, 0.01766751, 0.00973277, 0.00493097, 0.00229618, 0.00098211, 0.00038554, 0.00013879, 0.00004577, 0.00001382, 0.00000381 );
+uniform float offset[] = float[]( 0.00000000, 1.49230769, 3.48205128, 5.47179487, 7.46153846, 9.45128205, 11.44102564, 13.43076923, 15.42051282, 17.41025641, 19.40000000, 21.38974359, 23.37948718, 25.36923077, 27.35897436, 29.34871795, 31.33846154 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<17; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 65 --reduce 65 65 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Enthusiast/Splatoon_4320p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..4f21399e
--- /dev/null
+++ b/Enthusiast/Splatoon_4320p/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 4320
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.07731484, 0.14762709, 0.12265258, 0.08781380, 0.05412785, 0.02868527, 0.01304628, 0.00508044, 0.00168915, 0.00047786, 0.00011455, 0.00002316, 0.00000393, 0.00000055, 0.00000006, 0.00000001 );
+uniform float offset[] = float[]( 0.00000000, 1.48598131, 3.46728972, 5.44859813, 7.42990654, 9.41121495, 11.39252336, 13.37383178, 15.35514019, 17.33644860, 19.31775701, 21.29906542, 23.28037383, 25.26168224, 27.24299065, 29.22429907 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<16; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 15 --reduce 15 77 --linear
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}
diff --git a/Enthusiast/Splatoon_5760p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..827d08cd
--- /dev/null
+++ b/Enthusiast/Splatoon_5760p/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 5760
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.06731324, 0.12996513, 0.11288345, 0.08757379, 0.06065717, 0.03748843, 0.02065758, 0.01013916, 0.00442739, 0.00171752, 0.00059095, 0.00017999, 0.00004843, 0.00001148, 0.00000239, 0.00000044, 0.00000007, 0.00000001 );
+uniform float offset[] = float[]( 0.00000000, 1.48936170, 3.47517730, 5.46099291, 7.44680851, 9.43262411, 11.41843972, 13.40425532, 15.39007092, 17.37588652, 19.36170213, 21.34751773, 23.33333333, 25.31914894, 27.30496454, 29.29078014, 31.27659574, 33.26241135 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<18; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Enthusiast/Splatoon_5760p/34eaf9e211e76379_00000000000003c9_ps.txt b/Enthusiast/Splatoon_5760p/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Enthusiast/Splatoon_5760p/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..24ecc2ed 100644
--- a/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 5760
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.04202302, 0.08289284, 0.07843703, 0.07101047, 0.06150497, 0.05096469, 0.04039985, 0.03063492, 0.02222034, 0.01541512, 0.01022743, 0.00648881, 0.00393634, 0.00228295, 0.00126565, 0.00067063, 0.00033957, 0.00016428, 0.00007592, 0.00003351, 0.00001412, 0.00000568, 0.00000218, 0.00000080, 0.00000028, 0.00000009 );
+uniform float offset[] = float[]( 0.00000000, 1.49584488, 3.49030471, 5.48476454, 7.47922438, 9.47368421, 11.46814404, 13.46260388, 15.45706371, 17.45152355, 19.44598338, 21.44044321, 23.43490305, 25.42936288, 27.42382271, 29.41828255, 31.41274238, 33.40720222, 35.40166205, 37.39612188, 39.39058172, 41.38504155, 43.37950139, 45.37396122, 47.36842105, 49.36288089 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<26; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..8d112154 100644
--- a/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 5760
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.04202302, 0.08289284, 0.07843703, 0.07101047, 0.06150497, 0.05096469, 0.04039985, 0.03063492, 0.02222034, 0.01541512, 0.01022743, 0.00648881, 0.00393634, 0.00228295, 0.00126565, 0.00067063, 0.00033957, 0.00016428, 0.00007592, 0.00003351, 0.00001412, 0.00000568, 0.00000218, 0.00000080, 0.00000028, 0.00000009 );
+uniform float offset[] = float[]( 0.00000000, 1.49584488, 3.49030471, 5.48476454, 7.47922438, 9.47368421, 11.46814404, 13.46260388, 15.45706371, 17.45152355, 19.44598338, 21.44044321, 23.43490305, 25.42936288, 27.42382271, 29.41828255, 31.41274238, 33.40720222, 35.40166205, 37.39612188, 39.39058172, 41.38504155, 43.37950139, 45.37396122, 47.36842105, 49.36288089 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<26; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 130 --reduce 130 101 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Enthusiast/Splatoon_5760p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..da4b3260
--- /dev/null
+++ b/Enthusiast/Splatoon_5760p/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 5760
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.06731324, 0.12996513, 0.11288345, 0.08757379, 0.06065717, 0.03748843, 0.02065758, 0.01013916, 0.00442739, 0.00171752, 0.00059095, 0.00017999, 0.00004843, 0.00001148, 0.00000239, 0.00000044, 0.00000007, 0.00000001 );
+uniform float offset[] = float[]( 0.00000000, 1.48936170, 3.47517730, 5.46099291, 7.44680851, 9.43262411, 11.41843972, 13.40425532, 15.39007092, 17.37588652, 19.36170213, 21.34751773, 23.33333333, 25.31914894, 27.30496454, 29.29078014, 31.27659574, 33.26241135 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<18; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 18 --reduce 18 105 --linear
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}
diff --git a/Quality/Splatoon_1080p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1080p/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..63345e4a
--- /dev/null
+++ b/Quality/Splatoon_1080p/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 1080
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 );
+uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<6; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/Splatoon_1080p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1080p/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Quality/Splatoon_1080p/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..23cb8128 100644
--- a/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 1080
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.20064856, 0.30320227, 0.09647345 );
+uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<3; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..4c7003e7 100644
--- a/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 1080
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.20064856, 0.30320227, 0.09647345 );
+uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<3; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 4 --reduce 4 9 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1080p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1080p/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..d1aa277a
--- /dev/null
+++ b/Quality/Splatoon_1080p/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 1080
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 );
+uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<6; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 3 --reduce 3 --linear 21
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}
diff --git a/Quality/Splatoon_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..63345e4a
--- /dev/null
+++ b/Quality/Splatoon_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 1080
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 );
+uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<6; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/Splatoon_1080pUW/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1080pUW/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Quality/Splatoon_1080pUW/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..23cb8128 100644
--- a/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 1080
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.20064856, 0.30320227, 0.09647345 );
+uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<3; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..4c7003e7 100644
--- a/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 1080
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.20064856, 0.30320227, 0.09647345 );
+uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<3; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 4 --reduce 4 9 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..d1aa277a
--- /dev/null
+++ b/Quality/Splatoon_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 1080
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 );
+uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<6; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 3 --reduce 3 --linear 21
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}
diff --git a/Quality/Splatoon_1440p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1440p/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..fb356115
--- /dev/null
+++ b/Quality/Splatoon_1440p/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 1440
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.13206230, 0.23145657, 0.13626880, 0.05184139, 0.01244193, 0.00181033, 0.00014982 );
+uniform float offset[] = float[]( 0.00000000, 1.45945946, 3.40540541, 5.35135135, 7.29729730, 9.24324324, 11.18918919 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<7; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/Splatoon_1440p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1440p/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Quality/Splatoon_1440p/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..067ef96b 100644
--- a/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 1440
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.15644460, 0.26148598, 0.12689761, 0.03339411 );
+uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<4; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..805d99b0 100644
--- a/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 1440
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.15644460, 0.26148598, 0.12689761, 0.03339411 );
+uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<4; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 7 --reduce 7 13 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1440p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1440p/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..3a50efbf
--- /dev/null
+++ b/Quality/Splatoon_1440p/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 1440
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.13206230, 0.23145657, 0.13626880, 0.05184139, 0.01244193, 0.00181033, 0.00014982 );
+uniform float offset[] = float[]( 0.00000000, 1.45945946, 3.40540541, 5.35135135, 7.29729730, 9.24324324, 11.18918919 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<7; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 6 --reduce 6 25 --linear
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}
diff --git a/Quality/Splatoon_1800p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1800p/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..9e3b805f
--- /dev/null
+++ b/Quality/Splatoon_1800p/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 1800
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.11960420, 0.21450752, 0.13860486, 0.06270220, 0.01960345, 0.00414992, 0.00057699, 0.00005037, 0.00000258 );
+uniform float offset[] = float[]( 0.00000000, 1.46666667, 3.42222222, 5.37777778, 7.33333333, 9.28888889, 11.24444444, 13.20000000, 15.15555556 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<9; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/Splatoon_1800p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1800p/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Quality/Splatoon_1800p/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..16404f45 100644
--- a/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 1800
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.12618160, 0.22395869, 0.13875701, 0.05806447, 0.01612902 );
+uniform float offset[] = float[]( 0.00000000, 1.46341463, 3.41463415, 5.36585366, 7.31707317 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<5; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..cfad281d 100644
--- a/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 1800
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.12618160, 0.22395869, 0.13875701, 0.05806447, 0.01612902 );
+uniform float offset[] = float[]( 0.00000000, 1.46341463, 3.41463415, 5.36585366, 7.31707317 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<5; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 12 --reduce 12 17 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1800p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1800p/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..88c76a97
--- /dev/null
+++ b/Quality/Splatoon_1800p/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 1800
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.11960420, 0.21450752, 0.13860486, 0.06270220, 0.01960345, 0.00414992, 0.00057699, 0.00005037, 0.00000258 );
+uniform float offset[] = float[]( 0.00000000, 1.46666667, 3.42222222, 5.37777778, 7.33333333, 9.28888889, 11.24444444, 13.20000000, 15.15555556 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<9; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 6 --reduce 6 33 --linear
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}
diff --git a/Quality/Splatoon_2160p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_2160p/0457fe3efc9a772f_0000000000000079_ps.txt
new file mode 100644
index 00000000..84091aa4
--- /dev/null
+++ b/Quality/Splatoon_2160p/0457fe3efc9a772f_0000000000000079_ps.txt
@@ -0,0 +1,38 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Vertical Bloom 2160
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.10807685, 0.19765286, 0.13814447, 0.07221188, 0.02803520, 0.00799803, 0.00165142, 0.00024167, 0.00002435, 0.00000162, 0.00000007 );
+uniform float offset[] = float[]( 0.00000000, 1.47272727, 3.43636364, 5.40000000, 7.36363636, 9.32727273, 11.29090909, 13.25454545, 15.21818182, 17.18181818, 19.14545455 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<11; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/Splatoon_2160p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_2160p/34eaf9e211e76379_00000000000003c9_ps.txt
new file mode 100644
index 00000000..77843360
--- /dev/null
+++ b/Quality/Splatoon_2160p/34eaf9e211e76379_00000000000003c9_ps.txt
@@ -0,0 +1,102 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 34eaf9e211e76379 // bloom pre-blur
+uniform ivec4 uf_remappedPS[4];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
+layout(location = 2) in vec4 passParameterSem2;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec2 R1f = vec2(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem0;
+R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point
+vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
+float count = 0.0;
+for( int x=-r; x<=r; x++ ) {
+	for( int y=-r; y<=r; y++ ) {
+		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
+			R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res );
+			count += 1.0;
+			}
+		}
+	}
+PV0f.yxwz = R2f/count;
+
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+// 0
+backupReg0f = R0f.x;
+
+R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w));
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PS0f = R127f.w;
+// 1
+
+R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z));
+PS1f = R127f.z;
+// 2
+
+// 3
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.y, 0.0);
+PV1f.z = max(PV0f.z, 0.0);
+PV1f.w = max(PV0f.x, 0.0);
+// 4
+R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000));
+PV0f.x = R127f.x;
+R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000));
+PV0f.y = R127f.y;
+R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000));
+PV0f.z = R126f.z;
+R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000));
+PV0f.w = R126f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w)));
+tempf.x = clamp(tempf.x, 0.0, 1.0);
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x);
+PV0f.y = R123f.y;
+// 7
+PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z));
+// 8
+R2f.x = mul_nonIEEE(R127f.x, PV1f.x);
+R2f.y = mul_nonIEEE(R127f.y, PV1f.x);
+R2f.z = mul_nonIEEE(R126f.z, PV1f.x);
+R2f.w = mul_nonIEEE(R126f.w, PV1f.x);
+// export
+passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}
diff --git a/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt
index 9fe7817e..656e8aeb 100644
--- a/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt
+++ b/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt
@@ -1,29 +1,35 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 45d85f1d25e7d0de
-// Used for: Vertical Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 45d85f1d25e7d0de // vertical blur 2160
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.10621973, 0.19485826, 0.13789364, 0.07373992, 0.02961301, 0.00884599, 0.00193931 );
+uniform float offset[] = float[]( 0.00000000, 1.47368421, 3.43859649, 5.40350877, 7.36842105, 9.33333333, 11.29824561 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<7; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
diff --git a/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt
index dff2978b..22e96a23 100644
--- a/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt
+++ b/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt
@@ -1,28 +1,38 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4dc5fdeced670c5e
-// Used for: Horizontal Blur
-const float blurFactor = 1.0; //Higher is less blur
-
-// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
-layout(binding = 0) uniform sampler2D textureUnitPS0;
+// shader 4dc5fdeced670c5e // horizontal blur 2160
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.10621973, 0.19485826, 0.13789364, 0.07373992, 0.02961301, 0.00884599, 0.00193931 );
+uniform float offset[] = float[]( 0.00000000, 1.47368421, 3.43859649, 5.40350877, 7.36842105, 9.33333333, 11.29824561 );
 
-ivec2 inputRes = textureSize(textureUnitPS0, 0);
-vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-vec2 scale = outputRes * blurFactor;
 void main()
 {
-    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-    for (int i = 1; i<4; i++) {
-        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-    }
-    passPixelColor0 = R1f;
-}
\ No newline at end of file
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<7; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 16 --reduce 16 25 --linear
+//game original py blurninja.py --expand 2 --reduce 2 5 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_2160p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_2160p/9fad3b3505a6d831_0000000000000079_ps.txt
new file mode 100644
index 00000000..5a73adc6
--- /dev/null
+++ b/Quality/Splatoon_2160p/9fad3b3505a6d831_0000000000000079_ps.txt
@@ -0,0 +1,41 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Horizontal Bloom 2160
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 );
+uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 );
+
+uniform float weight[] = float[]( 0.10807685, 0.19765286, 0.13814447, 0.07221188, 0.02803520, 0.00799803, 0.00165142, 0.00024167, 0.00002435, 0.00000162, 0.00000007 );
+uniform float offset[] = float[]( 0.00000000, 1.47272727, 3.43636364, 5.40000000, 7.36363636, 9.32727273, 11.29090909, 13.25454545, 15.21818182, 17.18181818, 19.14545455 );
+
+void main()
+{
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<11; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i];
+	}
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<4; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 7 --reduce 7 41 --linear
+// game original py blurninja.py --expand 0 --reduce 0 13 --linear
\ No newline at end of file
diff --git a/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt
index 328aa41b..f36f837e 100644
--- a/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt
+++ b/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt
@@ -1,33 +1,22 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader cb0e6e8cbec4502a
+// shader cb0e6e8cbec4502a // dof blur
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem3;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-
 
 void main()
 {
-vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point
-ivec2 ires = textureSize(textureUnitPS0,0);
-vec2 res = vec2( float(ires.x), float(ires.y) );
-int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5));
+vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point
+vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale;
+int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5));
 vec4 R1f = vec4(0.0);
 float count = 0.0;
 for( int x=-r; x<=r; x++ ) {
 	for( int y=-r; y<=r; y++ ) {
 		if( pow(x,2) + pow(y,2) <= pow(r,2) ) {
-			R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res );
+			R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res );
 			count += 1.0;
 			}
 		}