From b2fe3a636a28082014185643eb7db6fdc383d4b8 Mon Sep 17 00:00:00 2001
From: gabest <gabest@627e133f-a60d-0410-aeef-a778af760ea1>
Date: Wed, 24 Dec 2008 10:04:07 +0000
Subject: [PATCH]

---
 gsdx/GPUDrawScanline.cpp |  186 +--
 gsdx/GPUDrawScanline.h   |  120 +-
 gsdx/GPURendererSW.h     |   67 +-
 gsdx/GS.h                |   25 +-
 gsdx/GSDevice10.cpp      |   47 -
 gsdx/GSDevice9.cpp       |   37 -
 gsdx/GSDrawScanline.cpp  | 3361 +++++++++++++++++++-------------------
 gsdx/GSDrawScanline.h    |  164 +-
 gsdx/GSDrawingContext.h  |    8 +-
 gsdx/GSRasterizer.cpp    |  167 +-
 gsdx/GSRasterizer.h      |   80 +-
 gsdx/GSRendererHW.h      |    6 +-
 gsdx/GSRendererHW10.cpp  |   15 +
 gsdx/GSRendererSW.h      |  511 ++++--
 gsdx/GSTexture10.cpp     |   55 +-
 gsdx/GSTexture9.cpp      |   47 +-
 gsdx/GSUtil.cpp          |   20 +-
 gsdx/GSUtil.h            |    2 +-
 gsdx/GSVector.h          |   15 +
 gsdx/GSVertex.h          |    1 +
 20 files changed, 2693 insertions(+), 2241 deletions(-)

diff --git a/gsdx/GPUDrawScanline.cpp b/gsdx/GPUDrawScanline.cpp
index e813245..8ed5ff4 100644
--- a/gsdx/GPUDrawScanline.cpp
+++ b/gsdx/GPUDrawScanline.cpp
@@ -24,8 +24,6 @@
 
 GPUDrawScanline::GPUDrawScanline(GPUState* state)
 	: m_state(state)
-	, m_filter(0)
-	, m_dither(1)
 {
 	Init();
 }
@@ -34,83 +32,67 @@ GPUDrawScanline::~GPUDrawScanline()
 {
 }
 
-void GPUDrawScanline::SetOptions(int filter, int dither)
-{
-	m_filter = filter;
-	m_dither = dither;
-}
-
 // IDrawScanline
 
-void GPUDrawScanline::SetupDraw(Vertex* vertices, int count, const void* texture)
+bool GPUDrawScanline::SetupDraw(const GSRasterizerData* data)
 {
 	GPUDrawingEnvironment& env = m_state->m_env;
 
-	// m_sel
+	const GPUScanlineParam* p = (const GPUScanlineParam*)data->param;
 
-	m_sel.dw = 0;
-	m_sel.iip = env.PRIM.IIP;
-	m_sel.me = env.STATUS.ME;
-	m_sel.abe = env.PRIM.ABE;
-	m_sel.abr = env.STATUS.ABR;
-	m_sel.tge = env.PRIM.TGE;
-	m_sel.tme = env.PRIM.TME;
-	m_sel.tlu = env.STATUS.TP < 2;
-	m_sel.twin = (env.TWIN.ai32 & 0xfffff) != 0;
-	m_sel.dtd = m_dither ? env.STATUS.DTD : 0;
-	m_sel.ltf = m_filter == 1 && env.PRIM.TYPE == GPU_POLYGON || m_filter == 2 ? 1 : 0;
+	m_env.sel = p->sel;
 
-	m_dsf = m_ds[m_sel];
+	m_env.mem = &m_state->m_mem;
 
-	// m_slenv
-
-	m_slenv.mem = &m_state->m_mem;
-
-	if(m_sel.tme)
+	if(m_env.sel.tme)
 	{
-		m_slenv.tex = texture;
-		m_slenv.clut = m_state->m_mem.GetCLUT(env.STATUS.TP, env.CLUT.X, env.CLUT.Y);
+		m_env.tex = p->tex;
+		m_env.clut = p->clut;
 
-		if(m_sel.twin)
+		if(m_env.sel.twin)
 		{
 			DWORD u, v;
 
 			u = ~(env.TWIN.TWW << 3) & 0xff;
 			v = ~(env.TWIN.TWH << 3) & 0xff;
 
-			m_slenv.u[0] = GSVector4i((u << 16) | u);
-			m_slenv.v[0] = GSVector4i((v << 16) | v);
+			m_env.u[0] = GSVector4i((u << 16) | u);
+			m_env.v[0] = GSVector4i((v << 16) | v);
 
 			u = env.TWIN.TWX << 3;
 			v = env.TWIN.TWY << 3;
 			
-			m_slenv.u[1] = GSVector4i((u << 16) | u) & ~m_slenv.u[0];
-			m_slenv.v[1] = GSVector4i((v << 16) | v) & ~m_slenv.v[0];
+			m_env.u[1] = GSVector4i((u << 16) | u) & ~m_env.u[0];
+			m_env.v[1] = GSVector4i((v << 16) | v) & ~m_env.v[0];
 		}
 	}
 
-	m_slenv.a = GSVector4i(env.PRIM.ABE ? 0xffffffff : 0);
-	m_slenv.md = GSVector4i(env.STATUS.MD ? 0x80008000 : 0);
+	m_env.a = GSVector4i(env.PRIM.ABE ? 0xffffffff : 0);
+	m_env.md = GSVector4i(env.STATUS.MD ? 0x80008000 : 0);
+
+	m_dsf = m_ds[m_env.sel];
+
+	return false;
 }
 
-void GPUDrawScanline::SetupPrim(PrimitiveType type, const Vertex* vertices, const Vertex& dscan)
+void GPUDrawScanline::SetupPrim(GS_PRIM_CLASS primclass, const GSVertexSW* vertices, const GSVertexSW& dscan)
 {
-	if(m_sel.tme && !m_sel.twin)
+	if(m_env.sel.tme && !m_env.sel.twin)
 	{
 		GSVector4i t;
 
-		switch(type)
+		switch(primclass)
 		{
-		case Sprite:
+		case GS_SPRITE_CLASS:
 			t = (GSVector4i(vertices[1].t) >> 8) - GSVector4i::x00000001();
 			t = t.ps32(t);
 			t = t.upl16(t);
-			m_slenv.u[2] = t.xxxx();
-			m_slenv.v[2] = t.yyyy();
+			m_env.u[2] = t.xxxx();
+			m_env.v[2] = t.yyyy();
 			break;
 		default:
-			m_slenv.u[2] = GSVector4i::x00ff();
-			m_slenv.v[2] = GSVector4i::x00ff();
+			m_env.u[2] = GSVector4i::x00ff();
+			m_env.v[2] = GSVector4i::x00ff();
 			break;
 		}
 	}
@@ -125,22 +107,22 @@ void GPUDrawScanline::SetupPrim(PrimitiveType type, const Vertex* vertices, cons
 
 	GSVector4i dtc8 = GSVector4i(dt * 8.0f).ps32(GSVector4i(dc * 8.0f));
 
-	m_slenv.ds = GSVector4i(dt.xxxx() * ps0123).ps32(GSVector4i(dt.xxxx() * ps4567));
-	m_slenv.dt = GSVector4i(dt.yyyy() * ps0123).ps32(GSVector4i(dt.yyyy() * ps4567));
-	m_slenv.dst8 = dtc8.upl16(dtc8);
+	m_env.ds = GSVector4i(dt.xxxx() * ps0123).ps32(GSVector4i(dt.xxxx() * ps4567));
+	m_env.dt = GSVector4i(dt.yyyy() * ps0123).ps32(GSVector4i(dt.yyyy() * ps4567));
+	m_env.dst8 = dtc8.upl16(dtc8);
 
-	m_slenv.dr = GSVector4i(dc.xxxx() * ps0123).ps32(GSVector4i(dc.xxxx() * ps4567));
-	m_slenv.dg = GSVector4i(dc.yyyy() * ps0123).ps32(GSVector4i(dc.yyyy() * ps4567));
-	m_slenv.db = GSVector4i(dc.zzzz() * ps0123).ps32(GSVector4i(dc.zzzz() * ps4567));
-	m_slenv.dc8 = dtc8.uph16(dtc8);
+	m_env.dr = GSVector4i(dc.xxxx() * ps0123).ps32(GSVector4i(dc.xxxx() * ps4567));
+	m_env.dg = GSVector4i(dc.yyyy() * ps0123).ps32(GSVector4i(dc.yyyy() * ps4567));
+	m_env.db = GSVector4i(dc.zzzz() * ps0123).ps32(GSVector4i(dc.zzzz() * ps4567));
+	m_env.dc8 = dtc8.uph16(dtc8);
 }
 
-void GPUDrawScanline::DrawScanline(int top, int left, int right, const Vertex& v)	
+void GPUDrawScanline::DrawScanline(int top, int left, int right, const GSVertexSW& v)	
 {
 	(this->*m_dsf)(top, left, right, v);
 }
 
-void GPUDrawScanline::FillRect(const GSVector4i& r, const Vertex& v)
+void GPUDrawScanline::DrawSolidRect(const GSVector4i& r, const GSVertexSW& v)
 {
 	ASSERT(0);
 }
@@ -152,8 +134,8 @@ IDrawScanline::DrawScanlinePtr GPUDrawScanline::GetDrawScanlinePtr()
 
 void GPUDrawScanline::SampleTexture(int pixels, DWORD ltf, DWORD tlu, DWORD twin, GSVector4i& test, const GSVector4i& s, const GSVector4i& t, GSVector4i* c)
 {
-	const void* RESTRICT tex = m_slenv.tex;
-	const WORD* RESTRICT clut = m_slenv.clut;
+	const void* RESTRICT tex = m_env.tex;
+	const WORD* RESTRICT clut = m_env.clut;
 
 	if(ltf)
 	{
@@ -171,17 +153,17 @@ void GPUDrawScanline::SampleTexture(int pixels, DWORD ltf, DWORD tlu, DWORD twin
 
 		if(twin)
 		{
-			u0 = (u0 & m_slenv.u[0]).add16(m_slenv.u[1]);
-			v0 = (v0 & m_slenv.v[0]).add16(m_slenv.v[1]);
-			u1 = (u1 & m_slenv.u[0]).add16(m_slenv.u[1]);
-			v1 = (v1 & m_slenv.v[0]).add16(m_slenv.v[1]);
+			u0 = (u0 & m_env.u[0]).add16(m_env.u[1]);
+			v0 = (v0 & m_env.v[0]).add16(m_env.v[1]);
+			u1 = (u1 & m_env.u[0]).add16(m_env.u[1]);
+			v1 = (v1 & m_env.v[0]).add16(m_env.v[1]);
 		}
 		else
 		{
-			u0 = u0.min_i16(m_slenv.u[2]);
-			v0 = v0.min_i16(m_slenv.v[2]);
-			u1 = u1.min_i16(m_slenv.u[2]);
-			v1 = v1.min_i16(m_slenv.v[2]);
+			u0 = u0.min_i16(m_env.u[2]);
+			v0 = v0.min_i16(m_env.v[2]);
+			u1 = u1.min_i16(m_env.u[2]);
+			v1 = v1.min_i16(m_env.v[2]);
 		}
 
 		GSVector4i addr00 = v0.sll16(8) | u0;
@@ -298,13 +280,13 @@ void GPUDrawScanline::SampleTexture(int pixels, DWORD ltf, DWORD tlu, DWORD twin
 
 		if(twin)
 		{
-			u = (u & m_slenv.u[0]).add16(m_slenv.u[1]);
-			v = (v & m_slenv.v[0]).add16(m_slenv.v[1]);
+			u = (u & m_env.u[0]).add16(m_env.u[1]);
+			v = (v & m_env.v[0]).add16(m_env.v[1]);
 		}
 		else
 		{
-			u = u.min_i16(m_slenv.u[2]);
-			v = v.min_i16(m_slenv.v[2]);
+			u = u.min_i16(m_env.u[2]);
+			v = v.min_i16(m_env.v[2]);
 		}
 
 		GSVector4i addr = v.sll16(8) | u;
@@ -440,7 +422,7 @@ void GPUDrawScanline::WriteFrame(WORD* RESTRICT fb, const GSVector4i& test, cons
 	GSVector4i b = (c[2] & 0x00f800f8) << 7;
 	GSVector4i a = (c[3] & 0x00800080) << 8;
 
-	GSVector4i s = r | g | b | a | m_slenv.md;
+	GSVector4i s = r | g | b | a | m_env.md;
 
 	int i = 0;
 
@@ -733,17 +715,17 @@ __declspec(align(16)) static WORD s_dither[4][16] =
 	{4, 3, 5, 2, 4, 3, 5, 2, 4, 3, 5, 2, 4, 3, 5, 2}, 
 };
 
-void GPUDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v)	
+void GPUDrawScanline::DrawScanlineT(int top, int left, int right, const GSVertexSW& v)	
 {
 	GSVector4i s, t;
 	GSVector4i r, g, b;
 
-	if(m_sel.tme)
+	if(m_env.sel.tme)
 	{
 		GSVector4i vt = GSVector4i(v.t).xxzzl();
 
-		s = vt.xxxx().add16(m_slenv.ds);
-		t = vt.yyyy().add16(m_slenv.dt);
+		s = vt.xxxx().add16(m_env.ds);
+		t = vt.yyyy().add16(m_env.dt);
 	}
 
 	GSVector4i vc = GSVector4i(v.c).xxzzl().xxzzh();
@@ -752,23 +734,23 @@ void GPUDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex&
 	g = vc.yyyy();
 	b = vc.zzzz();
 
-	if(m_sel.iip)
+	if(m_env.sel.iip)
 	{
-		r = r.add16(m_slenv.dr);
-		g = g.add16(m_slenv.dg);
-		b = b.add16(m_slenv.db);
+		r = r.add16(m_env.dr);
+		g = g.add16(m_env.dg);
+		b = b.add16(m_env.db);
 	}
 
 	GSVector4i dither;
 
-	if(m_sel.dtd)
+	if(m_env.sel.dtd)
 	{
 		dither = GSVector4i::load<false>(&s_dither[top & 3][left & 3]);
 	}
 
 	int steps = right - left;
 
-	WORD* fb = m_slenv.mem->GetPixelAddress(left, top);
+	WORD* fb = m_env.mem->GetPixelAddress(left, top);
 
 	while(1)
 	{
@@ -780,11 +762,11 @@ void GPUDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex&
 
 			GSVector4i d = GSVector4i::zero();
 
-			if(m_sel.rfb) // me | abe
+			if(m_env.sel.rfb) // me | abe
 			{
 				d = GSVector4i::load<false>(fb);
 
-				if(m_sel.me)
+				if(m_env.sel.me)
 				{
 					test = d.sra16(15);
 
@@ -797,19 +779,19 @@ void GPUDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex&
 
 			GSVector4i c[4];
 
-			if(m_sel.tme)
+			if(m_env.sel.tme)
 			{
-				SampleTexture(pixels, m_sel.ltf, m_sel.tlu, m_sel.twin, test, s, t, c);
+				SampleTexture(pixels, m_env.sel.ltf, m_env.sel.tlu, m_env.sel.twin, test, s, t, c);
 			}
 
-			ColorTFX(m_sel.tfx, r, g, b, c);
+			ColorTFX(m_env.sel.tfx, r, g, b, c);
 
-			if(m_sel.abe)
+			if(m_env.sel.abe)
 			{
-				AlphaBlend(m_sel.abr, m_sel.tme, d, c);
+				AlphaBlend(m_env.sel.abr, m_env.sel.tme, d, c);
 			}
 
-			if(m_sel.dtd)
+			if(m_env.sel.dtd)
 			{
 				c[0] = c[0].addus8(dither);
 				c[1] = c[1].addus8(dither);
@@ -826,17 +808,17 @@ void GPUDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex&
 
 		fb += 8;
 
-		if(m_sel.tme)
+		if(m_env.sel.tme)
 		{
-			GSVector4i dst8 = m_slenv.dst8;
+			GSVector4i dst8 = m_env.dst8;
 
 			s = s.add16(dst8.xxxx());
 			t = t.add16(dst8.yyyy());
 		}
 
-		if(m_sel.iip)
+		if(m_env.sel.iip)
 		{
-			GSVector4i dc8 = m_slenv.dc8;
+			GSVector4i dc8 = m_env.dc8;
 
 			r = r.add16(dc8.xxxx());
 			g = g.add16(dc8.yyyy());
@@ -846,7 +828,7 @@ void GPUDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex&
 }
 
 template<DWORD sel>
-void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex& v)
+void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const GSVertexSW& v)
 {
 	DWORD iip = (sel >> 0) & 1;
 	DWORD me = (sel >> 1) & 1;
@@ -865,8 +847,8 @@ void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex
 	{
 		GSVector4i vt = GSVector4i(v.t).xxzzl();
 
-		s = vt.xxxx().add16(m_slenv.ds);
-		t = vt.yyyy().add16(m_slenv.dt);
+		s = vt.xxxx().add16(m_env.ds);
+		t = vt.yyyy().add16(m_env.dt);
 	}
 
 	GSVector4i vc = GSVector4i(v.c).xxzzl().xxzzh();
@@ -877,21 +859,21 @@ void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex
 
 	if(iip)
 	{
-		r = r.add16(m_slenv.dr);
-		g = g.add16(m_slenv.dg);
-		b = b.add16(m_slenv.db);
+		r = r.add16(m_env.dr);
+		g = g.add16(m_env.dg);
+		b = b.add16(m_env.db);
 	}
 
 	GSVector4i dither;
 
-	if(m_sel.dtd)
+	if(m_env.sel.dtd)
 	{
 		dither = GSVector4i::load<false>(&s_dither[top & 3][left & 3]);
 	}
 
 	int steps = right - left;
 
-	WORD* fb = m_slenv.mem->GetPixelAddress(left, top);
+	WORD* fb = m_env.mem->GetPixelAddress(left, top);
 
 	while(1)
 	{
@@ -922,7 +904,7 @@ void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex
 
 			if(tme)
 			{
-				SampleTexture(pixels, m_sel.ltf, m_sel.tlu, twin, test, s, t, c);
+				SampleTexture(pixels, m_env.sel.ltf, m_env.sel.tlu, twin, test, s, t, c);
 			}
 
 			ColorTFX(tfx, r, g, b, c);
@@ -932,7 +914,7 @@ void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex
 				AlphaBlend(abr, tme, d, c);
 			}
 
-			if(m_sel.dtd)
+			if(m_env.sel.dtd)
 			{
 				c[0] = c[0].addus8(dither);
 				c[1] = c[1].addus8(dither);
@@ -951,7 +933,7 @@ void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex
 
 		if(tme)
 		{
-			GSVector4i dst8 = m_slenv.dst8;
+			GSVector4i dst8 = m_env.dst8;
 
 			s = s.add16(dst8.xxxx());
 			t = t.add16(dst8.yyyy());
@@ -959,7 +941,7 @@ void GPUDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex
 
 		if(iip)
 		{
-			GSVector4i dc8 = m_slenv.dc8;
+			GSVector4i dc8 = m_env.dc8;
 
 			r = r.add16(dc8.xxxx());
 			g = g.add16(dc8.yyyy());
diff --git a/gsdx/GPUDrawScanline.h b/gsdx/GPUDrawScanline.h
index fb11b9e..509d26b 100644
--- a/gsdx/GPUDrawScanline.h
+++ b/gsdx/GPUDrawScanline.h
@@ -25,66 +25,74 @@
 #include "GSRasterizer.h"
 #include "GSAlignedClass.h"
 
+union GPUScanlineSelector
+{
+	struct
+	{
+		DWORD iip:1; // 0
+		DWORD me:1; // 1
+		DWORD abe:1; // 2
+		DWORD abr:2; // 3
+		DWORD tge:1; // 5
+		DWORD tme:1; // 6
+		DWORD twin:1; // 7
+		DWORD tlu:1; // 8
+		DWORD dtd:1; // 9
+		DWORD ltf:1; // 10
+		// DWORD dte:1: // 11
+	};
+
+	struct
+	{
+		DWORD _pad1:1; // 0
+		DWORD rfb:2; // 1
+		DWORD _pad2:2; // 3
+		DWORD tfx:2; // 5
+	};
+
+	DWORD dw;
+
+	operator DWORD() {return dw & 0xff;}
+};
+
+__declspec(align(16)) struct GPUScanlineEnvironment
+{
+	GPUScanlineSelector sel;
+
+	GPULocalMemory* mem;
+	const void* tex;
+	const WORD* clut;
+
+	GSVector4i u[3];
+	GSVector4i v[3];
+
+	GSVector4i a;
+	GSVector4i md; // similar to gs fba
+
+	GSVector4i ds, dt, dst8;
+	GSVector4i dr, dg, db, dc8;
+};
+
+__declspec(align(16)) struct GPUScanlineParam
+{
+	GPUScanlineSelector sel;
+
+	const void* tex;
+	const WORD* clut;
+};
+
 class GPUDrawScanline : public GSAlignedClass<16>, public IDrawScanline
 {
-	union ScanlineSelector
-	{
-		struct
-		{
-			DWORD iip:1; // 0
-			DWORD me:1; // 1
-			DWORD abe:1; // 2
-			DWORD abr:2; // 3
-			DWORD tge:1; // 5
-			DWORD tme:1; // 6
-			DWORD twin:1; // 7
-			DWORD tlu:1; // 8
-			DWORD dtd:1; // 9
-			DWORD ltf:1; // 10
-			// DWORD dte:1: // 11
-		};
-
-		struct
-		{
-			DWORD _pad1:1; // 0
-			DWORD rfb:2; // 1
-			DWORD _pad2:2; // 3
-			DWORD tfx:2; // 5
-		};
-
-		DWORD dw;
-
-		operator DWORD() {return dw & 0xff;}
-	};
-	
-	__declspec(align(16)) struct ScanlineEnvironment
-	{
-		GPULocalMemory* mem;
-
-		const void* tex;
-		const WORD* clut;
-
-		GSVector4i u[3];
-		GSVector4i v[3];
-
-		GSVector4i a;
-		GSVector4i md; // similar to gs fba
-
-		GSVector4i ds, dt, dst8;
-		GSVector4i dr, dg, db, dc8;
-	};
-
-	ScanlineSelector m_sel;
-	ScanlineEnvironment m_slenv;
+	GPUScanlineEnvironment m_env;
 
 	DrawScanlinePtr m_ds[2048], m_dsf;
 
 	void Init();
 
-	void DrawScanlineT(int top, int left, int right, const Vertex& v);
+	void DrawScanlineT(int top, int left, int right, const GSVertexSW& v);
 
 	template<DWORD sel>
-	void DrawScanlineExT(int top, int left, int right, const Vertex& v);
+	void DrawScanlineExT(int top, int left, int right, const GSVertexSW& v);
 
 	__forceinline void SampleTexture(int pixels, DWORD ltf, DWORD tlu, DWORD twin, GSVector4i& test, const GSVector4i& s, const GSVector4i& t, GSVector4i* c);
 	__forceinline void ColorTFX(DWORD tfx, const GSVector4i& r, const GSVector4i& g, const GSVector4i& b, GSVector4i* c);
@@ -100,13 +108,11 @@ public:
 	GPUDrawScanline(GPUState* state);
 	virtual ~GPUDrawScanline();
 
-	void SetOptions(int filter, int dither);
-
 	// IDrawScanline
 
-	void SetupDraw(Vertex* vertices, int count, const void* texture);
-	void SetupPrim(PrimitiveType type, const Vertex* vertices, const Vertex& dscan);
-	void DrawScanline(int top, int left, int right, const Vertex& v);
-	void FillRect(const GSVector4i& r, const Vertex& v);
+	bool SetupDraw(const GSRasterizerData* data);
+	void SetupPrim(GS_PRIM_CLASS primclass, const GSVertexSW* vertices, const GSVertexSW& dscan);
+	void DrawScanline(int top, int left, int right, const GSVertexSW& v);
+	void DrawSolidRect(const GSVector4i& r, const GSVertexSW& v);
 	DrawScanlinePtr GetDrawScanlinePtr();
 };
diff --git a/gsdx/GPURendererSW.h b/gsdx/GPURendererSW.h
index fa36b4d..089ad27 100644
--- a/gsdx/GPURendererSW.h
+++ b/gsdx/GPURendererSW.h
@@ -25,10 +25,8 @@
 #include "GPUDrawScanline.h"
 
 template <class Device>
-class GPURendererSW : public GPURenderer<Device, GSVertexSW>, public IDrawAsync
+class GPURendererSW : public GPURenderer<Device, GSVertexSW>
 {
-	typedef GSVertexSW Vertex;
-
 protected:
 	GSRasterizerList m_rl;
 	Texture m_texture;
@@ -73,7 +71,7 @@ protected:
 
 	void VertexKick()
 	{
-		Vertex& v = m_vl.AddTail();
+		GSVertexSW& v = m_vl.AddTail();
 
 		// TODO: x/y + off.x/y should wrap around at +/-1024
 
@@ -92,17 +90,17 @@ protected:
 		__super::VertexKick();
 	}
 
-	void DrawingKickTriangle(Vertex* v, int& count)
+	void DrawingKickTriangle(GSVertexSW* v, int& count)
 	{
 		// TODO
 	}
 
-	void DrawingKickLine(Vertex* v, int& count)
+	void DrawingKickLine(GSVertexSW* v, int& count)
 	{
 		// TODO
 	}
 
-	void DrawingKickSprite(Vertex* v, int& count)
+	void DrawingKickSprite(GSVertexSW* v, int& count)
 	{
 		// TODO
 	}
@@ -121,31 +119,52 @@ protected:
 
 	void Draw()
 	{
-		const void* texture = NULL;
+		const GPUDrawingEnvironment& env = m_env;
 
-		if(m_env.PRIM.TME)
+		//
+
+		GPUScanlineParam p;
+
+		p.sel.dw = 0;
+		p.sel.iip = env.PRIM.IIP;
+		p.sel.me = env.STATUS.ME;
+		p.sel.abe = env.PRIM.ABE;
+		p.sel.abr = env.STATUS.ABR;
+		p.sel.tge = env.PRIM.TGE;
+		p.sel.tme = env.PRIM.TME;
+		p.sel.tlu = env.STATUS.TP < 2;
+		p.sel.twin = (env.TWIN.ai32 & 0xfffff) != 0;
+		p.sel.dtd = m_dither ? env.STATUS.DTD : 0;
+		p.sel.ltf = m_filter == 1 && env.PRIM.TYPE == GPU_POLYGON || m_filter == 2 ? 1 : 0;
+
+		if(env.PRIM.TME)
 		{
-			texture = m_mem.GetTexture(m_env.STATUS.TP, m_env.STATUS.TX, m_env.STATUS.TY);
+			const void* t = m_mem.GetTexture(env.STATUS.TP, env.STATUS.TX, env.STATUS.TY);
 
-			if(!texture) {ASSERT(0); return;}
+			if(!t) {ASSERT(0); return;}
+
+			p.tex = t;
+			p.clut = m_mem.GetCLUT(env.STATUS.TP, env.CLUT.X, env.CLUT.Y);
 		}
 
 		//
 
+		GSRasterizerData data;
+
+		data.scissor = GetScissor();
+		data.vertices = m_vertices;
+		data.count = m_count;
+		data.param = &p;
+
+		switch(env.PRIM.TYPE)
 		{
-			POSITION pos = m_rl.GetHeadPosition();
-
-			while(pos)
-			{
-				GSRasterizerMT* r = m_rl.GetNext(pos);
-
-				GPUDrawScanline* ds = (GPUDrawScanline*)r->GetDrawScanline();
-
-				ds->SetOptions(m_filter, m_dither);
-			}
+		case GPU_POLYGON: data.primclass = GS_TRIANGLE_CLASS; break;
+		case GPU_LINE: data.primclass = GS_LINE_CLASS; break;
+		case GPU_SPRITE: data.primclass = GS_SPRITE_CLASS; break;
+		default: __assume(0);
 		}
 
-		int prims = m_rl.Draw(m_vertices, m_count, texture);
+		int prims = m_rl.Draw(&data);
 	
 		m_perfmon.Put(GSPerfMon::Prim, prims);
 		m_perfmon.Put(GSPerfMon::Draw, 1);
@@ -168,7 +187,7 @@ protected:
 				br = br.maxv(p);
 			}
 
-			GSVector4i scissor = GetScissor();
+			GSVector4i scissor = data.scissor;
 
 			CRect r;
 
@@ -217,7 +236,7 @@ public:
 	GPURendererSW(const GPURendererSettings& rs, int threads)
 		: GPURenderer(rs)
 	{
-		m_rl.Create<GPUDrawScanline>(this, this, threads);
+		m_rl.Create<GPUDrawScanline>(this, threads);
 
 		m_fpDrawingKickHandlers[GPU_POLYGON] = (DrawingKickHandler)&GPURendererSW::DrawingKickTriangle;
 		m_fpDrawingKickHandlers[GPU_LINE] = (DrawingKickHandler)&GPURendererSW::DrawingKickLine;
diff --git a/gsdx/GS.h b/gsdx/GS.h
index e92d578..a1d504b 100644
--- a/gsdx/GS.h
+++ b/gsdx/GS.h
@@ -26,7 +26,7 @@
 
 #pragma once
 
-#define PLUGIN_VERSION 12
+#define PLUGIN_VERSION 13
 
 #include "GSVector.h"
 
@@ -72,6 +72,15 @@ enum GS_PRIM
 	GS_INVALID			= 7,
 };
 
+enum GS_PRIM_CLASS
+{
+	GS_POINT_CLASS		= 0,
+	GS_LINE_CLASS		= 1,
+	GS_TRIANGLE_CLASS	= 2,
+	GS_SPRITE_CLASS		= 3,
+	GS_INVALID_CLASS	= 7,
+};
+
 enum GIF_REG
 {
 	GIF_REG_PRIM	= 0x00,
@@ -508,7 +517,9 @@ REG64_(GIFReg, ALPHA)
 	UINT32 _PAD1:24;
 	UINT32 FIX:8;
 	UINT32 _PAD2:24;
-REG_END
+REG_END2
+	bool IsOpaque() const {return (A == B || C == 2 && FIX == 0) && D == 0 || (A == 0 && B == 2 && C == 2 && D == 2 && FIX == 0x80);} // output will be Cs/As
+REG_END2
 
 REG64_(GIFReg, BITBLTBUF)
 	UINT32 SBP:14;
@@ -806,7 +817,15 @@ REG64_(GIFReg, TEX1)
 	UINT32 _PAD3:11;
 	UINT32 K:12;
 	UINT32 _PAD4:20;
-REG_END
+REG_END2
+	bool IsLinear() const 
+	{
+		bool mmag = (MMAG & 1);
+		bool mmin = (MMIN == 1) || (MMIN & 4);
+
+		return !LCM ? mmag || mmin : K <= 0 ? mmag : mmin;
+	}
+REG_END2
 
 REG64_(GIFReg, TEX2)
 	UINT32 _PAD1:20;
diff --git a/gsdx/GSDevice10.cpp b/gsdx/GSDevice10.cpp
index aceb9bf..1f3920c 100644
--- a/gsdx/GSDevice10.cpp
+++ b/gsdx/GSDevice10.cpp
@@ -831,50 +831,3 @@ HRESULT GSDevice10::CompileShader(UINT id, LPCSTR entry, D3D10_SHADER_MACRO* mac
 
 	return hr;
 }
-
-bool GSDevice10::SaveToFileD32S8X24(ID3D10Texture2D* ds, LPCTSTR fn)
-{
-	HRESULT hr;
-
-	D3D10_TEXTURE2D_DESC desc;
-
-	memset(&desc, 0, sizeof(desc));
-
-	ds->GetDesc(&desc);
-
-	desc.Usage = D3D10_USAGE_STAGING;
-	desc.BindFlags = 0;
-	desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
-
-	CComPtr<ID3D10Texture2D> src, dst;
-
-	hr = m_dev->CreateTexture2D(&desc, NULL, &src);
-
-	m_dev->CopyResource(src, ds);
-
-	desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
-	desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
-
-	hr = m_dev->CreateTexture2D(&desc, NULL, &dst);
-
-	D3D10_MAPPED_TEXTURE2D sm, dm;
-
-	hr = src->Map(0, D3D10_MAP_READ, 0, &sm);
-	hr = dst->Map(0, D3D10_MAP_WRITE, 0, &dm);
-
-	BYTE* s = (BYTE*)sm.pData;
-	BYTE* d = (BYTE*)dm.pData;
-
-	for(UINT y = 0; y < desc.Height; y++, s += sm.RowPitch, d += dm.RowPitch)
-	{
-		for(UINT x = 0; x < desc.Width; x++)
-		{
-			((UINT*)d)[x] = (UINT)(((float*)s)[x*2] * UINT_MAX);
-		}
-	}
-
-	src->Unmap(0);
-	dst->Unmap(0);
-
-	return SUCCEEDED(D3DX10SaveTextureToFile(dst, D3DX10_IFF_BMP, fn));
-}
diff --git a/gsdx/GSDevice9.cpp b/gsdx/GSDevice9.cpp
index 255c098..3213c05 100644
--- a/gsdx/GSDevice9.cpp
+++ b/gsdx/GSDevice9.cpp
@@ -848,43 +848,6 @@ void GSDevice9::DrawPrimitive()
 	m_dev->DrawPrimitiveUP(m_topology, prims, m_vb_vertices, m_vb_stride);
 }
 
-bool GSDevice9::SaveToFileD24S8(IDirect3DSurface9* ds, LPCTSTR fn)
-{
-	HRESULT hr;
-
-	D3DSURFACE_DESC desc;
-
-	ds->GetDesc(&desc);
-
-	if(desc.Format != D3DFMT_D32F_LOCKABLE)
-		return false;
-
-	CComPtr<IDirect3DSurface9> surface;
-	
-	hr = m_dev->CreateOffscreenPlainSurface(desc.Width, desc.Height, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL);
-
-	D3DLOCKED_RECT slr, dlr;
-
-	hr = ds->LockRect(&slr, NULL, 0);;
-	hr = surface->LockRect(&dlr, NULL, 0);
-
-	BYTE* s = (BYTE*)slr.pBits;
-	BYTE* d = (BYTE*)dlr.pBits;
-
-	for(UINT y = 0; y < desc.Height; y++, s += slr.Pitch, d += dlr.Pitch)
-	{
-		for(UINT x = 0; x < desc.Width; x++)
-		{
-			((float*)d)[x] = ((float*)s)[x];
-		}
-	}
-
-	ds->UnlockRect();
-	surface->UnlockRect();
-
-	return SUCCEEDED(D3DXSaveSurfaceToFile(fn, D3DXIFF_BMP, surface, NULL, NULL));
-}
-
 void GSDevice9::StretchRect(Texture& st, Texture& dt, const GSVector4& dr, bool linear)
 {
 	StretchRect(st, GSVector4(0, 0, 1, 1), dt, dr, linear);
diff --git a/gsdx/GSDrawScanline.cpp b/gsdx/GSDrawScanline.cpp
index 186a557..4f80908 100644
--- a/gsdx/GSDrawScanline.cpp
+++ b/gsdx/GSDrawScanline.cpp
@@ -38,79 +38,123 @@ GSDrawScanline::~GSDrawScanline()
 
 // IDrawScanline
 
-void GSDrawScanline::SetupDraw(Vertex* vertices, int count, const void* texture)
+bool GSDrawScanline::SetupDraw(const GSRasterizerData* data)
 {
 	GSDrawingEnvironment& env = m_state->m_env;
 	GSDrawingContext* context = m_state->m_context;
-	GIFRegPRIM* PRIM = m_state->PRIM;
 
-	// m_sel
+	const GSScanlineParam* p = (const GSScanlineParam*)data->param;
 
-	m_sel.dw = 0;
+	m_env.sel = p->sel;
 
-	if(PRIM->AA1)
+	SetupOffset(m_fbo, context->FRAME.Block(), context->FRAME.FBW, context->FRAME.PSM);
+	SetupOffset(m_zbo, context->ZBUF.Block(), context->FRAME.FBW, context->ZBUF.PSM);
+
+	m_env.vm = p->vm;
+	m_env.fbr = m_fbo->row;
+	m_env.zbr = m_zbo->row;
+	m_env.fbc = m_fbo->col;
+	m_env.zbc = m_zbo->col;
+	m_env.fm = GSVector4i(p->fm);
+	m_env.zm = GSVector4i(p->zm);
+	m_env.datm = GSVector4i(context->TEST.DATM ? 0x80000000 : 0);
+	m_env.colclamp = GSVector4i(env.COLCLAMP.CLAMP ? 0xffffffff : 0x00ff00ff);
+	m_env.fba = GSVector4i(context->FBA.FBA ? 0x80000000 : 0);
+	m_env.aref = GSVector4i((int)context->TEST.AREF);
+	m_env.afix = GSVector4i((int)context->ALPHA.FIX << 16);
+	m_env.afix2 = m_env.afix.yywwl().yywwh().sll16(7);
+	m_env.frb = GSVector4i((int)env.FOGCOL.ai32[0] & 0x00ff00ff);
+	m_env.fga = GSVector4i((int)(env.FOGCOL.ai32[0] >> 8) & 0x00ff00ff);
+
+	if(m_env.sel.fpsm == 1)
 	{
-		// TODO: automatic alpha blending (ABE=1, A=0 B=1 C=0 D=1)
+		m_env.fm |= GSVector4i::xff000000();
 	}
 
-	m_sel.fpsm = GSUtil::EncodePSM(context->FRAME.PSM);
-	m_sel.zpsm = GSUtil::EncodePSM(context->ZBUF.PSM);
-	m_sel.ztst = context->TEST.ZTE && context->TEST.ZTST > 1 ? context->TEST.ZTST : context->ZBUF.ZMSK ? 0 : 1;
-	m_sel.iip = PRIM->PRIM == GS_POINTLIST || PRIM->PRIM == GS_SPRITE ? 0 : PRIM->IIP;
-	m_sel.tfx = PRIM->TME ? context->TEX0.TFX : 4;
-
-	if(m_sel.tfx != 4)
+	if(m_env.sel.atst == ATST_LESS)
 	{
-		m_sel.tcc = context->TEX0.TCC;
-		m_sel.fst = PRIM->FST;
-		m_sel.ltf = context->TEX1.LCM 
-			? (context->TEX1.K <= 0 && (context->TEX1.MMAG & 1) || context->TEX1.K > 0 && (context->TEX1.MMIN & 1)) 
-			: ((context->TEX1.MMAG & 1) | (context->TEX1.MMIN & 1));
+		m_env.sel.atst = ATST_LEQUAL;
 
-		if(m_sel.fst == 0 && PRIM->PRIM == GS_SPRITE)
-		{
-			// skip per pixel division if q is constant
+		m_env.aref -= GSVector4i::x00000001();
+	}
+	else if(m_env.sel.atst == ATST_GREATER)
+	{
+		m_env.sel.atst = ATST_GEQUAL;
 
-			m_sel.fst = 1;
-
-			for(int i = 0; i < count; i += 2)
-			{
-				GSVector4 q = vertices[i + 1].t.zzzz();
-
-				vertices[i + 0].t /= q;
-				vertices[i + 1].t /= q;
-			}
-		}
-
-		if(m_sel.fst && m_sel.ltf)
-		{
-			// if q is constant we can do the half pel shift for bilinear sampling on the vertices
-
-			GSVector4 half((float)0x8000, (float)0x8000, 0.0f, 0.0f);
-
-			for(int i = 0; i < count; i++)
-			{
-				vertices[i].t -= half;
-			}
-		}
+		m_env.aref += GSVector4i::x00000001();
 	}
 
-	m_sel.atst = context->TEST.ATE ? context->TEST.ATST : ATST_ALWAYS;
-	m_sel.afail = context->TEST.ATE ? context->TEST.AFAIL : 0;
-	m_sel.fge = PRIM->FGE;
-	m_sel.date = context->FRAME.PSM != PSM_PSMCT24 ? context->TEST.DATE : 0;
-	m_sel.abea = PRIM->ABE ? context->ALPHA.A : 3;
-	m_sel.abeb = PRIM->ABE ? context->ALPHA.B : 3;
-	m_sel.abec = PRIM->ABE ? context->ALPHA.C : 3;
-	m_sel.abed = PRIM->ABE ? context->ALPHA.D : 3;
-	m_sel.pabe = PRIM->ABE ? env.PABE.PABE : 0;
-	m_sel.rfb = m_sel.date || m_sel.abe != 255 || m_sel.atst != 1 && m_sel.afail == 3 || context->FRAME.FBMSK != 0 && context->FRAME.FBMSK != 0xffffffff;
-	m_sel.wzb = context->DepthWrite();
-	m_sel.tlu = PRIM->TME && GSLocalMemory::m_psm[context->TEX0.PSM].pal > 0 ? 1 : 0;
+	if(m_env.sel.tfx != TFX_NONE)
+	{
+		m_env.tex = p->tex;
+		m_env.clut = p->clut;
+		m_env.tw = p->tw;
 
-	m_dsf = m_ds[m_sel.fpsm][m_sel.zpsm][m_sel.ztst][m_sel.iip];
+		short tw = (short)(1 << context->TEX0.TW);
+		short th = (short)(1 << context->TEX0.TH);
 
-	CRBMap<DWORD, DrawScanlinePtr>::CPair* pair = m_dsmap2.Lookup(m_sel);
+		switch(context->CLAMP.WMS)
+		{
+		case CLAMP_REPEAT: 
+			m_env.t.min.u16[0] = tw - 1;
+			m_env.t.max.u16[0] = 0;
+			m_env.t.mask.u32[0] = 0xffffffff; 
+			break;
+		case CLAMP_CLAMP: 
+			m_env.t.min.u16[0] = 0;
+			m_env.t.max.u16[0] = tw - 1;
+			m_env.t.mask.u32[0] = 0; 
+			break;
+		case CLAMP_REGION_REPEAT: 
+			m_env.t.min.u16[0] = context->CLAMP.MINU;
+			m_env.t.max.u16[0] = context->CLAMP.MAXU;
+			m_env.t.mask.u32[0] = 0; 
+			break;
+		case CLAMP_REGION_CLAMP: 
+			m_env.t.min.u16[0] = context->CLAMP.MINU;
+			m_env.t.max.u16[0] = context->CLAMP.MAXU;
+			m_env.t.mask.u32[0] = 0xffffffff; 
+			break;
+		default: 
+			__assume(0);
+		}
+
+		switch(context->CLAMP.WMT)
+		{
+		case CLAMP_REPEAT: 
+			m_env.t.min.u16[4] = th - 1;
+			m_env.t.max.u16[4] = 0;
+			m_env.t.mask.u32[2] = 0xffffffff; 
+			break;
+		case CLAMP_CLAMP: 
+			m_env.t.min.u16[4] = 0;
+			m_env.t.max.u16[4] = th - 1;
+			m_env.t.mask.u32[2] = 0; 
+			break;
+		case CLAMP_REGION_REPEAT: 
+			m_env.t.min.u16[4] = context->CLAMP.MINV;
+			m_env.t.max.u16[4] = context->CLAMP.MAXV;
+			m_env.t.mask.u32[2] = 0; 
+			break;
+		case CLAMP_REGION_CLAMP: 
+			m_env.t.min.u16[4] = context->CLAMP.MINV;
+			m_env.t.max.u16[4] = context->CLAMP.MAXV;
+			m_env.t.mask.u32[2] = 0xffffffff; 
+			break;
+		default: 
+			__assume(0);
+		}
+
+		m_env.t.min = m_env.t.min.xxxxl().xxxxh();
+		m_env.t.max = m_env.t.max.xxxxl().xxxxh();
+		m_env.t.mask = m_env.t.mask.xxzz();
+	}
+
+	//
+
+	m_dsf = m_ds[m_env.sel.fpsm][m_env.sel.zpsm][m_env.sel.ztst][m_env.sel.iip];
+
+	CRBMap<DWORD, DrawScanlinePtr>::CPair* pair = m_dsmap2.Lookup(m_env.sel);
 
 	if(pair)
 	{
@@ -118,23 +162,35 @@ void GSDrawScanline::SetupDraw(Vertex* vertices, int count, const void* texture)
 	}
 	else
 	{
-		pair = m_dsmap.Lookup(m_sel);
+		static int found = 0;
+
+		pair = m_dsmap.Lookup(m_env.sel);
 
 		if(pair && pair->m_value)
 		{
 			m_dsf = pair->m_value;
 
 			m_dsmap2.SetAt(pair->m_key, pair->m_value);
+
+			found++;
+
 		}
 		else if(!pair)
 		{
-			_tprintf(_T("*** [%d] fpsm %d zpsm %d ztst %d tfx %d tcc %d fst %d ltf %d atst %d afail %d fge %d rfb %d date %d abe %d\n"), 
-				m_dsmap.GetCount(), 
-				m_sel.fpsm, m_sel.zpsm, m_sel.ztst, 
-				m_sel.tfx, m_sel.tcc, m_sel.fst, m_sel.ltf, 
-				m_sel.atst, m_sel.afail, m_sel.fge, m_sel.rfb, m_sel.date, m_sel.abe);
+			_tprintf(
+				_T("*** [%d,%d] ")
+				_T("psm %d/%d ztst %d iip %d ")
+				_T("tfx %d tcc %d fst %d ltf %d tlu %d ")
+				_T("atst %d afail %d fge %d date %d ")
+				_T("abe %02x pabe %d rfb %d ")
+				_T("\n"), 
+				m_dsmap.GetCount(), found,
+				m_env.sel.fpsm, m_env.sel.zpsm, m_env.sel.ztst, m_env.sel.iip,
+				m_env.sel.tfx, m_env.sel.tcc, m_env.sel.fst, m_env.sel.ltf, m_env.sel.tlu,
+				m_env.sel.atst, m_env.sel.afail, m_env.sel.fge, m_env.sel.date,
+				m_env.sel.abe, m_env.sel.pabe, m_env.sel.rfb);
 
-			m_dsmap.SetAt(m_sel, NULL);
+			m_dsmap.SetAt(m_env.sel, NULL);
 
 			if(FILE* fp = _tfopen(_T("c:\\1.txt"), _T("w")))
 			{
@@ -155,102 +211,63 @@ void GSDrawScanline::SetupDraw(Vertex* vertices, int count, const void* texture)
 		}
 	}
 
-	// m_slenv
-
-	SetupOffset(m_fbo, context->FRAME.Block(), context->FRAME.FBW, context->FRAME.PSM);
-	SetupOffset(m_zbo, context->ZBUF.Block(), context->FRAME.FBW, context->ZBUF.PSM);
-
-	m_slenv.vm = m_state->m_mem.m_vm32;
-	m_slenv.fbr = m_fbo->row;
-	m_slenv.zbr = m_zbo->row;
-	m_slenv.fbc = m_fbo->col;
-	m_slenv.zbc = m_zbo->col;
-	m_slenv.fm = GSVector4i(context->FRAME.FBMSK);
-	m_slenv.zm = GSVector4i(context->ZBUF.ZMSK ? 0xffffffff : 0);
-	m_slenv.datm = GSVector4i(context->TEST.DATM ? 0x80000000 : 0);
-	m_slenv.colclamp = GSVector4i(env.COLCLAMP.CLAMP ? 0xffffffff : 0x00ff00ff);
-	m_slenv.fba = GSVector4i(context->FBA.FBA ? 0x80000000 : 0);
-	m_slenv.aref = GSVector4i((int)context->TEST.AREF + (m_sel.atst == ATST_LESS ? -1 : m_sel.atst == ATST_GREATER ? +1 : 0));
-	m_slenv.afix = GSVector4i((int)context->ALPHA.FIX << 16);
-	m_slenv.afix2 = m_slenv.afix.yywwl().yywwh().sll16(7);
-	m_slenv.frb = GSVector4i((int)env.FOGCOL.ai32[0] & 0x00ff00ff);
-	m_slenv.fga = GSVector4i((int)(env.FOGCOL.ai32[0] >> 8) & 0x00ff00ff);
-
-	if(m_sel.fpsm == 1)
+	if(data->primclass == GS_SPRITE_CLASS)
 	{
-		m_slenv.fm |= GSVector4i::xff000000();
-	}
+		GIFRegPRIM* PRIM = m_state->PRIM;
 
-	if(PRIM->TME)
-	{
-		const GSTextureCacheSW::GSTexture* t = (const GSTextureCacheSW::GSTexture*)texture;
+		bool solid = true;
 
-		m_slenv.tex = t->m_buff;
-		m_slenv.clut = m_state->m_mem.m_clut;
-		m_slenv.tw = t->m_tw;
-
-		short tw = (short)(1 << context->TEX0.TW);
-		short th = (short)(1 << context->TEX0.TH);
-
-		switch(context->CLAMP.WMS)
+		if(PRIM->IIP || PRIM->TME || PRIM->ABE || PRIM->FGE
+		|| context->TEST.ZTE && context->TEST.ZTST != ZTST_ALWAYS 
+		|| context->TEST.ATE && context->TEST.ATST != ATST_ALWAYS
+		|| context->TEST.DATE
+		|| env.DTHE.DTHE
+		|| context->FRAME.FBMSK)
 		{
-		case CLAMP_REPEAT: 
-			m_slenv.t.min.u16[0] = tw - 1;
-			m_slenv.t.max.u16[0] = 0;
-			m_slenv.t.mask.u32[0] = 0xffffffff; 
-			break;
-		case CLAMP_CLAMP: 
-			m_slenv.t.min.u16[0] = 0;
-			m_slenv.t.max.u16[0] = tw - 1;
-			m_slenv.t.mask.u32[0] = 0; 
-			break;
-		case CLAMP_REGION_REPEAT: 
-			m_slenv.t.min.u16[0] = context->CLAMP.MINU;
-			m_slenv.t.max.u16[0] = context->CLAMP.MAXU;
-			m_slenv.t.mask.u32[0] = 0; 
-			break;
-		case CLAMP_REGION_CLAMP: 
-			m_slenv.t.min.u16[0] = context->CLAMP.MINU;
-			m_slenv.t.max.u16[0] = context->CLAMP.MAXU;
-			m_slenv.t.mask.u32[0] = 0xffffffff; 
-			break;
-		default: 
-			__assume(0);
+			solid = false;
+		}
+/*
+		// TODO
+
+		bool solid2 = true;
+
+		if(m_env.sel.iip 
+		|| m_env.sel.tfx != TFX_NONE
+		|| m_env.sel.abe != 255 
+		|| m_env.sel.fge
+		|| m_env.sel.ztst > 1 
+		|| m_env.sel.atst > 1
+		|| m_env.sel.date
+		|| p->fm != 0 && p->fm != 0xffffffff // TODO: implement masked FillRect
+		)
+		{
+			solid2 = false;
 		}
 
-		switch(context->CLAMP.WMT)
+		if(solid != solid2)
 		{
-		case CLAMP_REPEAT: 
-			m_slenv.t.min.u16[4] = th - 1;
-			m_slenv.t.max.u16[4] = 0;
-			m_slenv.t.mask.u32[2] = 0xffffffff; 
-			break;
-		case CLAMP_CLAMP: 
-			m_slenv.t.min.u16[4] = 0;
-			m_slenv.t.max.u16[4] = th - 1;
-			m_slenv.t.mask.u32[2] = 0; 
-			break;
-		case CLAMP_REGION_REPEAT: 
-			m_slenv.t.min.u16[4] = context->CLAMP.MINV;
-			m_slenv.t.max.u16[4] = context->CLAMP.MAXV;
-			m_slenv.t.mask.u32[2] = 0; 
-			break;
-		case CLAMP_REGION_CLAMP: 
-			m_slenv.t.min.u16[4] = context->CLAMP.MINV;
-			m_slenv.t.max.u16[4] = context->CLAMP.MAXV;
-			m_slenv.t.mask.u32[2] = 0xffffffff; 
-			break;
-		default: 
-			__assume(0);
-		}
+			int pixels = 0;
 
-		m_slenv.t.min = m_slenv.t.min.xxxxl().xxxxh();
-		m_slenv.t.max = m_slenv.t.max.xxxxl().xxxxh();
-		m_slenv.t.mask = m_slenv.t.mask.xxzz();
+			for(int i = 0; i < data->count; i += 2)
+			{
+				const GSVector4& p0 = data->vertices[i + 0].p;
+				const GSVector4& p1 = data->vertices[i + 1].p;
+
+				GSVector4 v = (p1 - p0).abs();
+
+				pixels += (int)v.x * (int)v.y;
+			}
+
+			printf("[%I64d] %d != %d, %08x, %d\n", m_state->m_perfmon.GetFrame(), solid, solid2, p->fm, pixels);
+		}
+*/
+		return solid;
 	}
+
+	return false;
 }
 
-void GSDrawScanline::SetupPrim(PrimitiveType type, const Vertex* vertices, const Vertex& dscan)
+void GSDrawScanline::SetupPrim(GS_PRIM_CLASS primclass, const GSVertexSW* vertices, const GSVertexSW& dscan)
 {
 	GSVector4 ps0123 = GSVector4::ps0123();
 	
@@ -258,41 +275,47 @@ void GSDrawScanline::SetupPrim(PrimitiveType type, const Vertex* vertices, const
 	GSVector4 dt = dscan.t;
 	GSVector4 dc = dscan.c;
 
-	// p
+	if(m_env.sel.ztst)
+	{
+		GSVector4 dz = dp.zzzz();
 
-	GSVector4 dz = dp.zzzz();
+		m_env.dz = dz * ps0123;
+		m_env.dz4 = dz * 4.0;
+	}
 
-	m_slenv.dz = dz * ps0123;
-	m_slenv.dz4 = dz * 4.0;
+	if(m_env.sel.fge)
+	{
+		GSVector4 df = dp.wwww();
+		GSVector4i dfi = GSVector4i(df * ps0123).ps32(GSVector4i(df * 4.0f));
 
-	GSVector4 df = dp.wwww();
-	GSVector4i dfi = GSVector4i(df * ps0123).ps32(GSVector4i(df * 4.0f));
+		m_env.df = dfi.upl16(dfi);
+		m_env.df4 = dfi.uph16(dfi);
+	}
 
-	m_slenv.df = dfi.upl16(dfi);
-	m_slenv.df4 = dfi.uph16(dfi);
+	if(m_env.sel.tfx != TFX_NONE)
+	{
+		m_env.dt = dt;
+		m_env.dt4 = dt * 4.0;
+	}
 
-	// t
+	if(m_env.sel.iip)
+	{
+		GSVector4i drg = GSVector4i(dc.xxxx() * ps0123).ps32(GSVector4i(dc.yyyy() * ps0123));
+		GSVector4i dba = GSVector4i(dc.zzzz() * ps0123).ps32(GSVector4i(dc.wwww() * ps0123));
+		GSVector4i dc4 = GSVector4i(dc * 4.0f).ps32().xzywl();
 
-	m_slenv.dt = dt;
-	m_slenv.dt4 = dt * 4.0;
-
-	// c
-
-	GSVector4i drg = GSVector4i(dc.xxxx() * ps0123).ps32(GSVector4i(dc.yyyy() * ps0123));
-	GSVector4i dba = GSVector4i(dc.zzzz() * ps0123).ps32(GSVector4i(dc.wwww() * ps0123));
-	GSVector4i dc4 = GSVector4i(dc * 4.0f).ps32().xzywl();
-
-	m_slenv.drb = drg.upl16(dba);
-	m_slenv.dga = drg.uph16(dba);
-	m_slenv.dc4 = dc4;
+		m_env.drb = drg.upl16(dba);
+		m_env.dga = drg.uph16(dba);
+		m_env.dc4 = dc4;
+	}
 }
 
-void GSDrawScanline::DrawScanline(int top, int left, int right, const Vertex& v)
+void GSDrawScanline::DrawScanline(int top, int left, int right, const GSVertexSW& v)
 {
 	(this->*m_dsf)(top, left, right, v);
 }
 
-void GSDrawScanline::FillRect(const GSVector4i& r, const Vertex& v)
+void GSDrawScanline::DrawSolidRect(const GSVector4i& r, const GSVertexSW& v)
 {
 	ASSERT(r.y >= 0);
 	ASSERT(r.w >= 0);
@@ -305,26 +328,27 @@ void GSDrawScanline::FillRect(const GSVector4i& r, const Vertex& v)
 	DWORD zpsm = context->ZBUF.PSM;
 	DWORD bw = context->FRAME.FBW;
 
-	if(!context->ZBUF.ZMSK)
+	if(m_env.fm.u32[0] != 0xffffffff) // TODO
+	{
+		DWORD c = (GSVector4i(v.c) >> 7).rgba32();
+
+		if(context->FBA.FBA)
+		{
+			c |= 0x80000000;
+		}
+		
+		if(fpsm == PSM_PSMCT16 || fpsm == PSM_PSMCT16S)
+		{
+			c = ((c & 0xf8) >> 3) | ((c & 0xf800) >> 6) | ((c & 0xf80000) >> 9) | ((c & 0x80000000) >> 16);
+		}
+
+		m_state->m_mem.FillRect(r, c, fpsm, fbp, bw);
+	}
+
+	if(m_env.zm.u32[0] != 0xffffffff)
 	{
 		m_state->m_mem.FillRect(r, (DWORD)(float)v.p.z, zpsm, zbp, bw);
 	}
-
-	DWORD c = (GSVector4i(v.c) >> 7).rgba32();
-
-	if(context->FBA.FBA)
-	{
-		c |= 0x80000000;
-	}
-	
-	if(fpsm == PSM_PSMCT16 || fpsm == PSM_PSMCT16S)
-	{
-		c = ((c & 0xf8) >> 3) | ((c & 0xf800) >> 6) | ((c & 0xf80000) >> 9) | ((c & 0x80000000) >> 16);
-	}
-
-	m_state->m_mem.FillRect(r, c, fpsm, fbp, bw);
-
-	// m_slenv.steps += r.Width() * r.Height();
 }
 
 IDrawScanline::DrawScanlinePtr GSDrawScanline::GetDrawScanlinePtr()
@@ -394,17 +418,34 @@ void GSDrawScanline::FreeOffsets()
 
 GSVector4i GSDrawScanline::Wrap(const GSVector4i& t)
 {
-	GSVector4i clamp = t.sat_i16(m_slenv.t.min, m_slenv.t.max);
-	GSVector4i repeat = (t & m_slenv.t.min) | m_slenv.t.max;
+	GSVector4i clamp = t.sat_i16(m_env.t.min, m_env.t.max);
+	GSVector4i repeat = (t & m_env.t.min) | m_env.t.max;
 
-	return clamp.blend8(repeat, m_slenv.t.mask);
+	return clamp.blend8(repeat, m_env.t.mask);
 }
 
-void GSDrawScanline::SampleTexture(int pixels, DWORD ztst, DWORD ltf, DWORD tlu, const GSVector4i& test, const GSVector4& u, const GSVector4& v, GSVector4i* c)
+void GSDrawScanline::SampleTexture(int pixels, DWORD ztst, DWORD fst, DWORD ltf, DWORD tlu, const GSVector4i& test, const GSVector4& s, const GSVector4& t, const GSVector4& q, GSVector4i* c)
 {
-	const void* RESTRICT tex = m_slenv.tex;
-	const DWORD* RESTRICT clut = m_slenv.clut;
-	const DWORD tw = m_slenv.tw;
+	const void* RESTRICT tex = m_env.tex;
+	const DWORD* RESTRICT clut = m_env.clut;
+	const DWORD tw = m_env.tw;
+
+	GSVector4 u = s;
+	GSVector4 v = t;
+
+	if(!fst)
+	{
+		GSVector4 w = q.rcp();
+
+		u *= w;
+		v *= w;
+
+		if(ltf)
+		{
+			u -= 0x8000;
+			v -= 0x8000;
+		}
+	}
 
 	GSVector4i ui = GSVector4i(u); 
 	GSVector4i vi = GSVector4i(v);
@@ -603,11 +644,10 @@ void GSDrawScanline::AlphaTFX(DWORD tfx, DWORD tcc, const GSVector4i& gaf, GSVec
 	case TFX_DECAL: 
 		break;
 	case TFX_HIGHLIGHT: 
-		if(!tcc) gat = gaf.srl16(7);
-		else gat = gat.addus8(gaf.srl16(7));
+		gat = gat.mix16(!tcc ? gaf.srl16(7) : gat.addus8(gaf.srl16(7)));
 		break;
-	case TFX_HIGHLIGHT2: 
-		if(!tcc) gat = gaf.srl16(7);
+	case TFX_HIGHLIGHT2:
+		if(!tcc) gat = gat.mix16(gaf.srl16(7));
 		break;
 	case TFX_NONE: 
 		gat = gaf.srl16(7);
@@ -617,10 +657,13 @@ void GSDrawScanline::AlphaTFX(DWORD tfx, DWORD tcc, const GSVector4i& gaf, GSVec
 	}
 }
 
-void GSDrawScanline::Fog(const GSVector4i& f, GSVector4i& rb, GSVector4i& ga)
+void GSDrawScanline::Fog(DWORD fge, const GSVector4i& f, GSVector4i& rb, GSVector4i& ga)
 {
-	rb = m_slenv.frb.lerp16<0>(rb, f);
-	ga = m_slenv.fga.lerp16<0>(ga, f).mix16(ga);
+	if(fge)
+	{
+		rb = m_env.frb.lerp16<0>(rb, f);
+		ga = m_env.fga.lerp16<0>(ga, f).mix16(ga);
+	}
 }
 
 bool GSDrawScanline::TestZ(DWORD zpsm, DWORD ztst, const GSVector4i& zs, const GSVector4i& za, GSVector4i& test)
@@ -656,7 +699,7 @@ bool GSDrawScanline::TestZ(DWORD zpsm, DWORD ztst, const GSVector4i& zs, const G
 
 bool GSDrawScanline::TestAlpha(DWORD atst, DWORD afail, const GSVector4i& ga, GSVector4i& fm, GSVector4i& zm, GSVector4i& test)
 {
-	if(atst != 1)
+	if(atst != ATST_ALWAYS)
 	{
 		GSVector4i t;
 
@@ -665,11 +708,11 @@ bool GSDrawScanline::TestAlpha(DWORD atst, DWORD afail, const GSVector4i& ga, GS
 		case ATST_NEVER: t = GSVector4i::invzero(); break;
 		case ATST_ALWAYS: t = GSVector4i::zero(); break;
 		case ATST_LESS: 
-		case ATST_LEQUAL: t = (ga >> 16) > m_slenv.aref; break;
-		case ATST_EQUAL: t = (ga >> 16) != m_slenv.aref; break;
+		case ATST_LEQUAL: t = (ga >> 16) > m_env.aref; break;
+		case ATST_EQUAL: t = (ga >> 16) != m_env.aref; break;
 		case ATST_GEQUAL: 
-		case ATST_GREATER: t = (ga >> 16) < m_slenv.aref; break;
-		case ATST_NOTEQUAL: t = (ga >> 16) == m_slenv.aref; break;
+		case ATST_GREATER: t = (ga >> 16) < m_env.aref; break;
+		case ATST_NOTEQUAL: t = (ga >> 16) == m_env.aref; break;
 		default: __assume(0);
 		}
 
@@ -699,6 +742,21 @@ bool GSDrawScanline::TestAlpha(DWORD atst, DWORD afail, const GSVector4i& ga, GS
 	return true;
 }
 
+bool GSDrawScanline::TestDestAlpha(DWORD fpsm, DWORD date, const GSVector4i& d, GSVector4i& test)
+{
+	if(fpsm != 1 && date)
+	{
+		test |= (d ^ m_env.datm).sra32(31);
+
+		if(test.alltrue())
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
 DWORD GSDrawScanline::ReadPixel32(DWORD* RESTRICT vm, DWORD addr)
 {
 	return vm[addr];
@@ -731,8 +789,8 @@ void GSDrawScanline::WritePixel16(WORD* RESTRICT vm, DWORD addr, DWORD c)
 
 GSVector4i GSDrawScanline::ReadFrameX(int psm, const GSVector4i& addr) const
 {
-	DWORD* RESTRICT vm32 = (DWORD*)m_slenv.vm;
-	WORD* RESTRICT vm16 = (WORD*)m_slenv.vm;
+	DWORD* RESTRICT vm32 = (DWORD*)m_env.vm;
+	WORD* RESTRICT vm16 = (WORD*)m_env.vm;
 
 	GSVector4i c, r, g, b, a;
 
@@ -773,9 +831,9 @@ GSVector4i GSDrawScanline::ReadFrameX(int psm, const GSVector4i& addr) const
 		#endif
 		c = ((c & 0x8000) << 16) | ((c & 0x7c00) << 9) | ((c & 0x03e0) << 6) | ((c & 0x001f) << 3); 
 		break;
-	default: 
-		ASSERT(0); 
+	case 3:
 		c = GSVector4i::zero();
+		break;
 	}
 	
 	return c;
@@ -783,8 +841,8 @@ GSVector4i GSDrawScanline::ReadFrameX(int psm, const GSVector4i& addr) const
 
 GSVector4i GSDrawScanline::ReadZBufX(int psm, const GSVector4i& addr) const
 {
-	DWORD* RESTRICT vm32 = (DWORD*)m_slenv.vm;
-	WORD* RESTRICT vm16 = (WORD*)m_slenv.vm;
+	DWORD* RESTRICT vm32 = (DWORD*)m_env.vm;
+	WORD* RESTRICT vm16 = (WORD*)m_env.vm;
 
 	GSVector4i z;
 
@@ -824,9 +882,9 @@ GSVector4i GSDrawScanline::ReadZBufX(int psm, const GSVector4i& addr) const
 			ReadPixel16(vm16, addr.u32[3]));
 		#endif
 		break;
-	default: 
-		ASSERT(0); 
+	case 3:
 		z = GSVector4i::zero();
+		break;
 	}
 
 	return z;
@@ -839,8 +897,8 @@ void GSDrawScanline::WriteFrameAndZBufX(
 {
 	// FIXME: compiler problem or not enough xmm regs in x86 mode to store the address regs (fa, za)
 
-	DWORD* RESTRICT vm32 = (DWORD*)m_slenv.vm;
-	WORD* RESTRICT vm16 = (WORD*)m_slenv.vm;
+	DWORD* RESTRICT vm32 = (DWORD*)m_env.vm;
+	WORD* RESTRICT vm16 = (WORD*)m_env.vm;
 
 	GSVector4i c = f;
 
@@ -848,6 +906,7 @@ void GSDrawScanline::WriteFrameAndZBufX(
 	{
 		GSVector4i rb = c & 0x00f800f8;
 		GSVector4i ga = c & 0x8000f800;
+
 		c = (ga >> 16) | (rb >> 9) | (ga >> 6) | (rb >> 3);
 	}
 
@@ -983,1313 +1042,1393 @@ void GSDrawScanline::Init()
 		InitDS_IIP(iFPSM, iZPSM, iZTST, 0) \
 		InitDS_IIP(iFPSM, iZPSM, iZTST, 1) \
 
-	#define InitDS_ZPSM(iFPSM, iZPSM) \
+	#define InitDS(iFPSM, iZPSM) \
 		InitDS_ZTST(iFPSM, iZPSM, 0) \
 		InitDS_ZTST(iFPSM, iZPSM, 1) \
 		InitDS_ZTST(iFPSM, iZPSM, 2) \
 		InitDS_ZTST(iFPSM, iZPSM, 3) \
 
-	#define InitDS_FPSM(iFPSM) \
-		InitDS_ZPSM(iFPSM, 0) \
-		InitDS_ZPSM(iFPSM, 1) \
-		InitDS_ZPSM(iFPSM, 2) \
-
-	#define InitDS() \
-		InitDS_FPSM(0) \
-		InitDS_FPSM(1) \
-		InitDS_FPSM(2) \
-
-	InitDS();
+	InitDS(0, 0);
+	InitDS(0, 1);
+	InitDS(0, 2);
+	InitDS(0, 3);
+	InitDS(1, 0);
+	InitDS(1, 1);
+	InitDS(1, 2);
+	InitDS(1, 3);
+	InitDS(2, 0);
+	InitDS(2, 1);
+	InitDS(2, 2);
+	InitDS(2, 3);
+	InitDS(3, 0);
+	InitDS(3, 1);
+	InitDS(3, 2);
 
 	#ifdef FAST_DRAWSCANLINE
 
+	// bios
+
+	m_dsmap.SetAt(0x1fe00860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe00860>);
+	m_dsmap.SetAt(0x1fe04070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04070>);
+	m_dsmap.SetAt(0x1fe04850, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04850>);
+	m_dsmap.SetAt(0x1fe04860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04860>);
+	m_dsmap.SetAt(0x1fe20060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe20060>);
+	m_dsmap.SetAt(0x1fe20860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe20860>);
+	m_dsmap.SetAt(0x1fe28864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe28864>);
+	m_dsmap.SetAt(0x1fe28870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe28870>);
+	m_dsmap.SetAt(0x1fe38050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe38050>);
+	m_dsmap.SetAt(0x1fe38060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe38060>);
+	m_dsmap.SetAt(0x1fe38064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe38064>);
+	m_dsmap.SetAt(0x1fe38070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe38070>);
+	m_dsmap.SetAt(0x1fe39050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe39050>);
+	m_dsmap.SetAt(0x48428050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48428050>);
+	m_dsmap.SetAt(0x48428060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48428060>);
+	m_dsmap.SetAt(0x48804860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804860>);
+	m_dsmap.SetAt(0x48838050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838050>);
+	m_dsmap.SetAt(0x48838064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838064>);
+	m_dsmap.SetAt(0x48839050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48839050>);
+	m_dsmap.SetAt(0x49004050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004050>);
+	m_dsmap.SetAt(0x4902884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4902884c>);
+	m_dsmap.SetAt(0x4902904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4902904c>);
+	m_dsmap.SetAt(0x49038050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49038050>);
+	m_dsmap.SetAt(0x49039050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49039050>);
+	m_dsmap.SetAt(0x4b02804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b02804c>);
+	m_dsmap.SetAt(0x4c40404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c40404c>);
+	m_dsmap.SetAt(0x4c419050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c419050>);
+	m_dsmap.SetAt(0x4c804050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804050>);
+	m_dsmap.SetAt(0x4c804850, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804850>);
+	m_dsmap.SetAt(0x4d019050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d019050>);
+	m_dsmap.SetAt(0x4d028864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d028864>);
+	m_dsmap.SetAt(0x4d038864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d038864>);
+
 	// ffx
 
-	m_dsmap.SetAt(0x2420c265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2420c265>);
-	m_dsmap.SetAt(0x2420e245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2420e245>);
-	m_dsmap.SetAt(0x24402205, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402205>);
-	m_dsmap.SetAt(0x24402245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402245>);
-	m_dsmap.SetAt(0x24402275, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402275>);
-	m_dsmap.SetAt(0x2440c265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c265>);
-	m_dsmap.SetAt(0x2440fc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440fc05>);
-	m_dsmap.SetAt(0x2440fc45, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440fc45>);
-	m_dsmap.SetAt(0x24411045, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411045>);
-	m_dsmap.SetAt(0x24411075, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411075>);
-	m_dsmap.SetAt(0x2444d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2444d465>);
-	m_dsmap.SetAt(0x24610265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24610265>);
-	m_dsmap.SetAt(0x24802245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802245>);
-	m_dsmap.SetAt(0x24802275, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802275>);
-	m_dsmap.SetAt(0x2480c265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480c265>);
-	m_dsmap.SetAt(0x2480e245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480e245>);
-	m_dsmap.SetAt(0x26402275, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402275>);
-	m_dsmap.SetAt(0x2880c205, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2880c205>);
-	m_dsmap.SetAt(0x4ff02215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02215>);
-	m_dsmap.SetAt(0x4ff02896, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02896>);
-	m_dsmap.SetAt(0x4ff0d475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0d475>);
-	m_dsmap.SetAt(0x4ff4c275, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4c275>);
-	m_dsmap.SetAt(0x4ff4d475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4d475>);
-	m_dsmap.SetAt(0x64402215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402215>);
-	m_dsmap.SetAt(0x64402255, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402255>);
-	m_dsmap.SetAt(0x64402815, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402815>);
-	m_dsmap.SetAt(0x6440e215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e215>);
-	m_dsmap.SetAt(0x6440e255, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e255>);
-	m_dsmap.SetAt(0x6440fc15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440fc15>);
-	m_dsmap.SetAt(0x6444c265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444c265>);
-	m_dsmap.SetAt(0x6444d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444d465>);
-	m_dsmap.SetAt(0x66402275, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402275>);
-	m_dsmap.SetAt(0x664038a5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x664038a5>);
-	m_dsmap.SetAt(0x6a902215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a902215>);
-	m_dsmap.SetAt(0xa420dc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420dc05>);
-	m_dsmap.SetAt(0xa440d405, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d405>);
-	m_dsmap.SetAt(0xa440d425, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d425>);
-	m_dsmap.SetAt(0xa440d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d465>);
-	m_dsmap.SetAt(0xa440dc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440dc05>);
-	m_dsmap.SetAt(0xa440fc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440fc05>);
-	m_dsmap.SetAt(0xa444d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa444d465>);
-	m_dsmap.SetAt(0xa480d425, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d425>);
-	m_dsmap.SetAt(0xa480d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d465>);
-	m_dsmap.SetAt(0xa6803435, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6803435>);
-	m_dsmap.SetAt(0xa680e425, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa680e425>);
-	m_dsmap.SetAt(0xcff03435, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff03435>);
-	m_dsmap.SetAt(0xcff0d415, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0d415>);
-	m_dsmap.SetAt(0xcff0d475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0d475>);
-	m_dsmap.SetAt(0xcff4d475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4d475>);
-	m_dsmap.SetAt(0xe440d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d465>);
-	m_dsmap.SetAt(0xe440ec55, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440ec55>);
-	m_dsmap.SetAt(0xe440fc15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440fc15>);
-	m_dsmap.SetAt(0xe440fc25, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440fc25>);
-	m_dsmap.SetAt(0xe440fc55, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440fc55>);
-	m_dsmap.SetAt(0xe444d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444d465>);
-	m_dsmap.SetAt(0xe444fc75, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444fc75>);
-	m_dsmap.SetAt(0xe484fc75, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe484fc75>);
-	m_dsmap.SetAt(0xe680e425, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe680e425>);
-	m_dsmap.SetAt(0x66402895, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402895>);
-	m_dsmap.SetAt(0xa480d405, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d405>);
-	m_dsmap.SetAt(0xa480dc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480dc05>);
-	m_dsmap.SetAt(0x24202245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24202245>);
-	m_dsmap.SetAt(0xa440fc45, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440fc45>);
+	m_dsmap.SetAt(0x1fe04055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04055>);
+	m_dsmap.SetAt(0x1fe11056, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe11056>);
+	m_dsmap.SetAt(0x1fe68175, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68175>);
+	m_dsmap.SetAt(0x1fe68975, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68975>);
+	m_dsmap.SetAt(0x1fe69175, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe69175>);
+	m_dsmap.SetAt(0x1fe84175, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84175>);
+	m_dsmap.SetAt(0x1fe84975, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84975>);
+	m_dsmap.SetAt(0x1fee8175, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8175>);
+	m_dsmap.SetAt(0x1fee8975, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8975>);
+	m_dsmap.SetAt(0x1fee9175, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee9175>);
+	m_dsmap.SetAt(0x48404965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404965>);
+	m_dsmap.SetAt(0x4847814d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4847814d>);
+	m_dsmap.SetAt(0x48478165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478165>);
+	m_dsmap.SetAt(0x48479165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48479165>);
+	m_dsmap.SetAt(0x4880404d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4880404d>);
+	m_dsmap.SetAt(0x48804055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804055>);
+	m_dsmap.SetAt(0x48804155, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804155>);
+	m_dsmap.SetAt(0x488041cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488041cd>);
+	m_dsmap.SetAt(0x4880484d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4880484d>);
+	m_dsmap.SetAt(0x48804855, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804855>);
+	m_dsmap.SetAt(0x48804965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804965>);
+	m_dsmap.SetAt(0x488049cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488049cd>);
+	m_dsmap.SetAt(0x48810055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48810055>);
+	m_dsmap.SetAt(0x48820965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48820965>);
+	m_dsmap.SetAt(0x48830075, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830075>);
+	m_dsmap.SetAt(0x4883014d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883014d>);
+	m_dsmap.SetAt(0x48830875, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830875>);
+	m_dsmap.SetAt(0x48830965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830965>);
+	m_dsmap.SetAt(0x488589cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488589cd>);
+	m_dsmap.SetAt(0x48868165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868165>);
+	m_dsmap.SetAt(0x48868965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868965>);
+	m_dsmap.SetAt(0x4887814d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887814d>);
+	m_dsmap.SetAt(0x48878165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878165>);
+	m_dsmap.SetAt(0x488781cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488781cd>);
+	m_dsmap.SetAt(0x488781e5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488781e5>);
+	m_dsmap.SetAt(0x488789cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488789cd>);
+	m_dsmap.SetAt(0x4887914d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887914d>);
+	m_dsmap.SetAt(0x488791cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488791cd>);
+	m_dsmap.SetAt(0x488791d5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488791d5>);
+	m_dsmap.SetAt(0x488791e5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488791e5>);
+	m_dsmap.SetAt(0x48884965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884965>);
+	m_dsmap.SetAt(0x488e8165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8165>);
+	m_dsmap.SetAt(0x488e8965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8965>);
+	m_dsmap.SetAt(0x488e9165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9165>);
+	m_dsmap.SetAt(0x488f81f5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f81f5>);
+	m_dsmap.SetAt(0x488f89f5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f89f5>);
+	m_dsmap.SetAt(0x48c04865, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c04865>);
+	m_dsmap.SetAt(0x49004165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004165>);
+	m_dsmap.SetAt(0x490041cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490041cd>);
+	m_dsmap.SetAt(0x49004865, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004865>);
+	m_dsmap.SetAt(0x49004965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004965>);
+	m_dsmap.SetAt(0x490049cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490049cd>);
+	m_dsmap.SetAt(0x49068165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068165>);
+	m_dsmap.SetAt(0x49068965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068965>);
+	m_dsmap.SetAt(0x49069165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49069165>);
+	m_dsmap.SetAt(0x4907814d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907814d>);
+	m_dsmap.SetAt(0x49078165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078165>);
+	m_dsmap.SetAt(0x49078965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078965>);
+	m_dsmap.SetAt(0x49079165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079165>);
+	m_dsmap.SetAt(0x490f89f5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490f89f5>);
+	m_dsmap.SetAt(0x4c811055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c811055>);
+	m_dsmap.SetAt(0x4c831065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c831065>);
+	m_dsmap.SetAt(0x4d0481e5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d0481e5>);
+	m_dsmap.SetAt(0x51004155, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51004155>);
+	m_dsmap.SetAt(0x51004165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51004165>);
+	m_dsmap.SetAt(0x51004965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51004965>);
+	m_dsmap.SetAt(0x5101004e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5101004e>);
+	m_dsmap.SetAt(0x51020965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51020965>);
+	m_dsmap.SetAt(0x54204055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x54204055>);
+	m_dsmap.SetAt(0x55204055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x55204055>);
+	m_dsmap.SetAt(0x1fe78075, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78075>);
+	m_dsmap.SetAt(0x1fe78155, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78155>);
+	m_dsmap.SetAt(0x484049cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x484049cd>);
+	m_dsmap.SetAt(0x48804875, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804875>);
+	m_dsmap.SetAt(0x49004075, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004075>);
+	m_dsmap.SetAt(0x49004875, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004875>);
+	m_dsmap.SetAt(0x4907914d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907914d>);
+	m_dsmap.SetAt(0x4c804075, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804075>);
+	m_dsmap.SetAt(0x4c804875, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804875>);
+	m_dsmap.SetAt(0x4d078075, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d078075>);
+	m_dsmap.SetAt(0x5100414d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5100414d>);
 
 	// ffxii
 
-	m_dsmap.SetAt(0x0ff02204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02204>);
-	m_dsmap.SetAt(0x0ff11c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff11c04>);
-	m_dsmap.SetAt(0x0ff11c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff11c14>);
-	m_dsmap.SetAt(0x24210224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24210224>);
-	m_dsmap.SetAt(0x24410214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410214>);
-	m_dsmap.SetAt(0x24410254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410254>);
-	m_dsmap.SetAt(0x24411464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411464>);
-	m_dsmap.SetAt(0x24411c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411c04>);
-	m_dsmap.SetAt(0x24431054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24431054>);
-	m_dsmap.SetAt(0x244b0224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x244b0224>);
-	m_dsmap.SetAt(0x24810224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24810224>);
-	m_dsmap.SetAt(0x24810264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24810264>);
-	m_dsmap.SetAt(0x24811464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24811464>);
-	m_dsmap.SetAt(0x24830254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24830254>);
-	m_dsmap.SetAt(0x24831c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24831c04>);
-	m_dsmap.SetAt(0x25830214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25830214>);
-	m_dsmap.SetAt(0x2a882204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a882204>);
-	m_dsmap.SetAt(0x2ff02224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02224>);
-	m_dsmap.SetAt(0x2ff30204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff30204>);
-	m_dsmap.SetAt(0x2ff82204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff82204>);
-	m_dsmap.SetAt(0x4ff02214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02214>);
-	m_dsmap.SetAt(0x4ff20214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff20214>);
-	m_dsmap.SetAt(0x4ff4a264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4a264>);
-	m_dsmap.SetAt(0x64403054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64403054>);
-	m_dsmap.SetAt(0x8ff11454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff11454>);
-	m_dsmap.SetAt(0xa4411424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411424>);
-	m_dsmap.SetAt(0xa4411454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411454>);
-	m_dsmap.SetAt(0xa4411464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411464>);
-	m_dsmap.SetAt(0xa4411c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411c14>);
-	m_dsmap.SetAt(0xa4411c54, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411c54>);
-	m_dsmap.SetAt(0xa4430c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4430c14>);
-	m_dsmap.SetAt(0xa4431054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4431054>);
-	m_dsmap.SetAt(0xa4431464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4431464>);
-	m_dsmap.SetAt(0xa4431c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4431c14>);
-	m_dsmap.SetAt(0xa4431c54, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4431c54>);
-	m_dsmap.SetAt(0xa4811424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4811424>);
-	m_dsmap.SetAt(0xa4811464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4811464>);
-	m_dsmap.SetAt(0xa4830c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4830c14>);
-	m_dsmap.SetAt(0xa4831464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4831464>);
-	m_dsmap.SetAt(0xa4911424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4911424>);
-	m_dsmap.SetAt(0xa4911464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4911464>);
-	m_dsmap.SetAt(0xcff4a464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4a464>);
-	m_dsmap.SetAt(0xcff4b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4b464>);
-	m_dsmap.SetAt(0xe4203054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4203054>);
-	m_dsmap.SetAt(0xe445b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445b464>);
-	m_dsmap.SetAt(0xe445d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445d464>);
-	m_dsmap.SetAt(0xe485b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe485b464>);
-	m_dsmap.SetAt(0xa4611454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4611454>);
-	m_dsmap.SetAt(0xa4831c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4831c24>);
-	m_dsmap.SetAt(0xcff0b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0b464>);
-	m_dsmap.SetAt(0xcff42464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff42464>);
-
-	// kingdom hearts
-
-	m_dsmap.SetAt(0x0ff02205, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02205>);
-	m_dsmap.SetAt(0x0ff03c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c04>);
-	m_dsmap.SetAt(0x0ff03c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c05>);
-	m_dsmap.SetAt(0x24403c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403c04>);
-	m_dsmap.SetAt(0x2440d824, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440d824>);
-	m_dsmap.SetAt(0x28102204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x28102204>);
-	m_dsmap.SetAt(0x2ff03c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03c00>);
-	m_dsmap.SetAt(0x62a4d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x62a4d468>);
-	m_dsmap.SetAt(0x6420c254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6420c254>);
-	m_dsmap.SetAt(0x64402c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402c14>);
-	m_dsmap.SetAt(0x6440c214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440c214>);
-	m_dsmap.SetAt(0x6440c254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440c254>);
-	m_dsmap.SetAt(0x6440d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440d464>);
-	m_dsmap.SetAt(0x6480c254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6480c254>);
-	m_dsmap.SetAt(0x6ff02218, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff02218>);
-	m_dsmap.SetAt(0x6ff0c228, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff0c228>);
-	m_dsmap.SetAt(0xa440d434, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d434>);
-	m_dsmap.SetAt(0xa440d474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d474>);
-	m_dsmap.SetAt(0xa440dc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440dc04>);
-	m_dsmap.SetAt(0xa4445464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4445464>);
-	m_dsmap.SetAt(0xa444d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa444d464>);
-	m_dsmap.SetAt(0xa480d434, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d434>);
-	m_dsmap.SetAt(0xa480d474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d474>);
-	m_dsmap.SetAt(0xa480dc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480dc34>);
-	m_dsmap.SetAt(0xa484d474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa484d474>);
-	m_dsmap.SetAt(0xcff4d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4d464>);
-	m_dsmap.SetAt(0xe4402c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4402c14>);
-	m_dsmap.SetAt(0xe4402c54, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4402c54>);
-	m_dsmap.SetAt(0xe4403414, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403414>);
-	m_dsmap.SetAt(0xe4403c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403c14>);
-	m_dsmap.SetAt(0xe4403c54, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403c54>);
-	m_dsmap.SetAt(0xe440dc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc14>);
-	m_dsmap.SetAt(0xe440dc54, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc54>);
-	m_dsmap.SetAt(0xe444b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444b464>);
-	m_dsmap.SetAt(0xe444b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444b468>);
-	m_dsmap.SetAt(0xe444d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444d464>);
-	m_dsmap.SetAt(0xe4802c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4802c14>);
-	m_dsmap.SetAt(0xe480dc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480dc14>);
-	m_dsmap.SetAt(0xe480dc54, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480dc54>);
-	m_dsmap.SetAt(0x24402804, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402804>);
-	m_dsmap.SetAt(0x2440c274, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c274>);
-	m_dsmap.SetAt(0x2ff10224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff10224>);
-	m_dsmap.SetAt(0x4ff03814, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03814>);
-	m_dsmap.SetAt(0x64403814, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64403814>);
-	m_dsmap.SetAt(0xa420d404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420d404>);
-	m_dsmap.SetAt(0xa420d434, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420d434>);
-	m_dsmap.SetAt(0xa420d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420d444>);
-	m_dsmap.SetAt(0xa420d474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420d474>);
-	m_dsmap.SetAt(0xa420dc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420dc34>);
-	m_dsmap.SetAt(0xa440d404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d404>);
-	m_dsmap.SetAt(0xa440dc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440dc34>);
-	m_dsmap.SetAt(0xa460d474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa460d474>);
-	m_dsmap.SetAt(0xa480d404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d404>);
-	m_dsmap.SetAt(0xa480dc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480dc04>);
-	m_dsmap.SetAt(0xa484d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa484d444>);
-	m_dsmap.SetAt(0xe440d414, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d414>);
-
-	// dbzbt3
-
-	m_dsmap.SetAt(0x24402204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402204>);
-	m_dsmap.SetAt(0x24402884, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402884>);
-	m_dsmap.SetAt(0x24402c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402c84>);
-	m_dsmap.SetAt(0x24403804, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403804>);
-	m_dsmap.SetAt(0x24403884, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403884>);
-	m_dsmap.SetAt(0x2440fc84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440fc84>);
-	m_dsmap.SetAt(0x2448e464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2448e464>);
-	m_dsmap.SetAt(0x24802264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802264>);
-	m_dsmap.SetAt(0x24882204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24882204>);
-	m_dsmap.SetAt(0x25202204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25202204>);
-	m_dsmap.SetAt(0x25403804, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25403804>);
-	m_dsmap.SetAt(0x26402204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402204>);
-	m_dsmap.SetAt(0x26402206, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402206>);
-	m_dsmap.SetAt(0x26402244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402244>);
-	m_dsmap.SetAt(0x26403804, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403804>);
-	m_dsmap.SetAt(0x2640fc84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2640fc84>);
-	m_dsmap.SetAt(0x26802204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26802204>);
-	m_dsmap.SetAt(0x26803804, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803804>);
-	m_dsmap.SetAt(0x2ff02c86, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02c86>);
-	m_dsmap.SetAt(0x64402214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402214>);
-	m_dsmap.SetAt(0xa4402c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c84>);
-	m_dsmap.SetAt(0xa4402c86, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c86>);
-	m_dsmap.SetAt(0xa4402cb4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402cb4>);
-	m_dsmap.SetAt(0xa4403424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403424>);
-	m_dsmap.SetAt(0xa4403464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403464>);
-	m_dsmap.SetAt(0xa4403c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403c04>);
-	m_dsmap.SetAt(0xa440b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440b464>);
-	m_dsmap.SetAt(0xa440bc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440bc04>);
-	m_dsmap.SetAt(0xa440d424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d424>);
-	m_dsmap.SetAt(0xa440d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d464>);
-	m_dsmap.SetAt(0xa440fc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440fc04>);
-	m_dsmap.SetAt(0xa443bc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa443bc04>);
-	m_dsmap.SetAt(0xa4483464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4483464>);
-	m_dsmap.SetAt(0xa4483c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4483c04>);
-	m_dsmap.SetAt(0xa4802c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4802c84>);
-	m_dsmap.SetAt(0xa4803464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4803464>);
-	m_dsmap.SetAt(0xa4883c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4883c04>);
-	m_dsmap.SetAt(0xa5803c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa5803c04>);
-	m_dsmap.SetAt(0xa6202c86, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6202c86>);
-	m_dsmap.SetAt(0xe4403464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403464>);
-	m_dsmap.SetAt(0xe440b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440b464>);
-	m_dsmap.SetAt(0xe4419464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4419464>);
-	m_dsmap.SetAt(0xe58034e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe58034e4>);
-	m_dsmap.SetAt(0xe62034e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe62034e4>);
-	m_dsmap.SetAt(0xe6403464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe6403464>);
-
-	// xenosaga
-
-	m_dsmap.SetAt(0x0ff10234, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10234>);
-	m_dsmap.SetAt(0x24402234, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402234>);
-	m_dsmap.SetAt(0x24402264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402264>);
-	m_dsmap.SetAt(0x24402274, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402274>);
-	m_dsmap.SetAt(0x24403464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403464>);
-	m_dsmap.SetAt(0x24403834, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403834>);
-	m_dsmap.SetAt(0x24407464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24407464>);
-	m_dsmap.SetAt(0x24430264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24430264>);
-	m_dsmap.SetAt(0x2480c264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480c264>);
-	m_dsmap.SetAt(0x26408434, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26408434>);
-	m_dsmap.SetAt(0x26802264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26802264>);
-	m_dsmap.SetAt(0x26810214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26810214>);
-	m_dsmap.SetAt(0x2ff10234, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff10234>);
-	m_dsmap.SetAt(0x4ff02c34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02c34>);
-	m_dsmap.SetAt(0x4ff0dc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0dc34>);
-	m_dsmap.SetAt(0x60003c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x60003c14>);
-	m_dsmap.SetAt(0x6000c214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6000c214>);
-	m_dsmap.SetAt(0x64803c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64803c14>);
-	m_dsmap.SetAt(0x6600c274, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6600c274>);
-	m_dsmap.SetAt(0x66403c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66403c14>);
-	m_dsmap.SetAt(0x66803464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66803464>);
-	m_dsmap.SetAt(0x6680b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6680b464>);
-	m_dsmap.SetAt(0x6a902224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a902224>);
-	m_dsmap.SetAt(0x6ff02264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff02264>);
-	m_dsmap.SetAt(0x6ff0b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff0b464>);
-	m_dsmap.SetAt(0xa420d424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420d424>);
-	m_dsmap.SetAt(0xa4402c34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c34>);
-	m_dsmap.SetAt(0xa4407464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4407464>);
-	m_dsmap.SetAt(0xa4410c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4410c14>);
-	m_dsmap.SetAt(0xa480d424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d424>);
-	m_dsmap.SetAt(0xa6203464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6203464>);
-	m_dsmap.SetAt(0xa6803464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6803464>);
-	m_dsmap.SetAt(0xa8911434, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa8911434>);
-	m_dsmap.SetAt(0xe000cc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe000cc14>);
-	m_dsmap.SetAt(0xe000cc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe000cc24>);
-	m_dsmap.SetAt(0xe000cc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe000cc34>);
-	m_dsmap.SetAt(0xe110cc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe110cc34>);
-	m_dsmap.SetAt(0xe290cc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe290cc14>);
-	m_dsmap.SetAt(0xe440cc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440cc14>);
-	m_dsmap.SetAt(0xe440cc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440cc24>);
-	m_dsmap.SetAt(0xe440cc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440cc34>);
-	m_dsmap.SetAt(0xe440d424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d424>);
-	m_dsmap.SetAt(0xe6803464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe6803464>);
-	m_dsmap.SetAt(0xe680b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe680b464>);
-	m_dsmap.SetAt(0xe680cc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe680cc14>);
-	m_dsmap.SetAt(0xeff03464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xeff03464>);
-	m_dsmap.SetAt(0xeff0b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xeff0b464>);
-	m_dsmap.SetAt(0x0ff10c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10c04>);
-	m_dsmap.SetAt(0x26430c34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26430c34>);
-	m_dsmap.SetAt(0x4ff03c34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03c34>);
-	m_dsmap.SetAt(0x6440c264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440c264>);
-	m_dsmap.SetAt(0x64420214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64420214>);
-	m_dsmap.SetAt(0x6ff03c34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff03c34>);
-	m_dsmap.SetAt(0xe440cc64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440cc64>);
-
-	// xenosaga 2
-
-	m_dsmap.SetAt(0x0ff10204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10204>);
-	m_dsmap.SetAt(0x0ff42244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff42244>);
-	m_dsmap.SetAt(0x24445464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24445464>);
-	m_dsmap.SetAt(0x26803c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803c04>);
-	m_dsmap.SetAt(0x28903464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x28903464>);
-	m_dsmap.SetAt(0x2ff02204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02204>);
-	m_dsmap.SetAt(0x2ff03c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03c04>);
-	m_dsmap.SetAt(0x2ff90204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff90204>);
-	m_dsmap.SetAt(0x4ff02c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02c14>);
-	m_dsmap.SetAt(0x4ff42264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff42264>);
-	m_dsmap.SetAt(0x4ff43464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff43464>);
-	m_dsmap.SetAt(0x4ff4b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4b464>);
-	m_dsmap.SetAt(0x64403c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64403c14>);
-	m_dsmap.SetAt(0x66202214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66202214>);
-	m_dsmap.SetAt(0x66402214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402214>);
-	m_dsmap.SetAt(0x66802214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66802214>);
-	m_dsmap.SetAt(0x8ff43444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff43444>);
-	m_dsmap.SetAt(0xa4405464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4405464>);
-	m_dsmap.SetAt(0xa4443464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4443464>);
-	m_dsmap.SetAt(0xa4a13404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4a13404>);
-	m_dsmap.SetAt(0xa520d424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa520d424>);
-	m_dsmap.SetAt(0xa540d424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa540d424>);
-	m_dsmap.SetAt(0xa580d424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa580d424>);
-	m_dsmap.SetAt(0xcff03464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff03464>);
-	m_dsmap.SetAt(0xcff43464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff43464>);
-	m_dsmap.SetAt(0xe000dc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe000dc34>);
-	m_dsmap.SetAt(0xe440dc34, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc34>);
-	m_dsmap.SetAt(0xe4803464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4803464>);
-	m_dsmap.SetAt(0xe4803c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4803c14>);
-
-	// tales of abyss
-
-	m_dsmap.SetAt(0x0ff02208, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02208>);
-	m_dsmap.SetAt(0x0ff03c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c88>);
-	m_dsmap.SetAt(0x2091a048, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2091a048>);
-	m_dsmap.SetAt(0x20a02248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x20a02248>);
-	m_dsmap.SetAt(0x20a1b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x20a1b448>);
-	m_dsmap.SetAt(0x24402248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402248>);
-	m_dsmap.SetAt(0x24442268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24442268>);
-	m_dsmap.SetAt(0x25403c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25403c88>);
-	m_dsmap.SetAt(0x2680d448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2680d448>);
-	m_dsmap.SetAt(0x2a803448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a803448>);
-	m_dsmap.SetAt(0x2a803c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a803c08>);
-	m_dsmap.SetAt(0x2a805448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a805448>);
-	m_dsmap.SetAt(0x2a80d448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a80d448>);
-	m_dsmap.SetAt(0x2a81b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a81b448>);
-	m_dsmap.SetAt(0x2a81b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a81b468>);
-	m_dsmap.SetAt(0x2ff02208, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02208>);
-	m_dsmap.SetAt(0x2ff03c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03c88>);
-	m_dsmap.SetAt(0x4ff02218, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02218>);
-	m_dsmap.SetAt(0x60a02268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x60a02268>);
-	m_dsmap.SetAt(0x60a1b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x60a1b468>);
-	m_dsmap.SetAt(0x6445b458, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6445b458>);
-	m_dsmap.SetAt(0xa441b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441b448>);
-	m_dsmap.SetAt(0xa441b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441b468>);
-	m_dsmap.SetAt(0xa445b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa445b448>);
-	m_dsmap.SetAt(0xa445b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa445b468>);
-	m_dsmap.SetAt(0xa464f468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa464f468>);
-	m_dsmap.SetAt(0xa481b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa481b448>);
-	m_dsmap.SetAt(0xa481b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa481b468>);
-	m_dsmap.SetAt(0xa484f468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa484f468>);
-	m_dsmap.SetAt(0xa485b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa485b468>);
-	m_dsmap.SetAt(0xaff02cb8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff02cb8>);
-	m_dsmap.SetAt(0xe441b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441b468>);
-	m_dsmap.SetAt(0xe4443468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4443468>);
-	m_dsmap.SetAt(0xe445a468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445a468>);
-	m_dsmap.SetAt(0xe445b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445b468>);
-	m_dsmap.SetAt(0xe481b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe481b468>);
-	m_dsmap.SetAt(0xe485b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe485b468>);
-
-	// persona 4
-
-	m_dsmap.SetAt(0x0ff1a248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff1a248>);
-	m_dsmap.SetAt(0x24210248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24210248>);
-	m_dsmap.SetAt(0x2441a268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441a268>);
-	m_dsmap.SetAt(0x2441b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441b468>);
-	m_dsmap.SetAt(0x24810248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24810248>);
-	m_dsmap.SetAt(0x24811048, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24811048>);
-	m_dsmap.SetAt(0x24842268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24842268>);
-	m_dsmap.SetAt(0x25411048, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25411048>);
-	m_dsmap.SetAt(0x2541b048, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2541b048>);
-	m_dsmap.SetAt(0x26842068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26842068>);
-	m_dsmap.SetAt(0x2ff82248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff82248>);
-	m_dsmap.SetAt(0x4ff42268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff42268>);
-	m_dsmap.SetAt(0x64402268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402268>);
-	m_dsmap.SetAt(0x64442268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64442268>);
-	m_dsmap.SetAt(0x6445a268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6445a268>);
-	m_dsmap.SetAt(0x64802268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64802268>);
-	m_dsmap.SetAt(0x66842068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66842068>);
-	m_dsmap.SetAt(0xa4251468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4251468>);
-	m_dsmap.SetAt(0xa4411448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411448>);
-	m_dsmap.SetAt(0xa4411468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411468>);
-	m_dsmap.SetAt(0xa4811468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4811468>);
-	m_dsmap.SetAt(0xa4851468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4851468>);
-	m_dsmap.SetAt(0xa541b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa541b448>);
-	m_dsmap.SetAt(0xa541b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa541b468>);
-	m_dsmap.SetAt(0xa6843468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6843468>);
-	m_dsmap.SetAt(0xe441a468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441a468>);
-	m_dsmap.SetAt(0xe441d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441d468>);
-	m_dsmap.SetAt(0xe443b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe443b468>);
-	m_dsmap.SetAt(0xe447b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe447b468>);
-	m_dsmap.SetAt(0xe6843468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe6843468>);
+	m_dsmap.SetAt(0x1fe0404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0404c>);
+	m_dsmap.SetAt(0x1fe04054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04054>);
+	m_dsmap.SetAt(0x1fe04057, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04057>);
+	m_dsmap.SetAt(0x1fe3804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3804c>);
+	m_dsmap.SetAt(0x1fe3904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3904c>);
+	m_dsmap.SetAt(0x1fe6804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe6804c>);
+	m_dsmap.SetAt(0x1fe68164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68164>);
+	m_dsmap.SetAt(0x1fe6884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe6884c>);
+	m_dsmap.SetAt(0x1fe68964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68964>);
+	m_dsmap.SetAt(0x1fe84164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84164>);
+	m_dsmap.SetAt(0x1fe84964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84964>);
+	m_dsmap.SetAt(0x1fec8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fec8064>);
+	m_dsmap.SetAt(0x1fec8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fec8864>);
+	m_dsmap.SetAt(0x1fee8164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8164>);
+	m_dsmap.SetAt(0x1fee8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8864>);
+	m_dsmap.SetAt(0x1fee8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8964>);
+	m_dsmap.SetAt(0x48404064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404064>);
+	m_dsmap.SetAt(0x4847004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4847004c>);
+	m_dsmap.SetAt(0x4880404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4880404c>);
+	m_dsmap.SetAt(0x48804064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804064>);
+	m_dsmap.SetAt(0x4880484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4880484c>);
+	m_dsmap.SetAt(0x48828064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48828064>);
+	m_dsmap.SetAt(0x48828864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48828864>);
+	m_dsmap.SetAt(0x4883004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883004c>);
+	m_dsmap.SetAt(0x4883084c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883084c>);
+	m_dsmap.SetAt(0x4883804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883804c>);
+	m_dsmap.SetAt(0x4883884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883884c>);
+	m_dsmap.SetAt(0x4883904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883904c>);
+	m_dsmap.SetAt(0x4885804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885804c>);
+	m_dsmap.SetAt(0x4885904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885904c>);
+	m_dsmap.SetAt(0x4886804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886804c>);
+	m_dsmap.SetAt(0x48868064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868064>);
+	m_dsmap.SetAt(0x48868364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868364>);
+	m_dsmap.SetAt(0x4886884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886884c>);
+	m_dsmap.SetAt(0x48868864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868864>);
+	m_dsmap.SetAt(0x48868b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868b64>);
+	m_dsmap.SetAt(0x48869064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869064>);
+	m_dsmap.SetAt(0x4887004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887004c>);
+	m_dsmap.SetAt(0x4887084c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887084c>);
+	m_dsmap.SetAt(0x4887804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887804c>);
+	m_dsmap.SetAt(0x48878064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878064>);
+	m_dsmap.SetAt(0x48878364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878364>);
+	m_dsmap.SetAt(0x4887884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887884c>);
+	m_dsmap.SetAt(0x4887904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887904c>);
+	m_dsmap.SetAt(0x48879064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879064>);
+	m_dsmap.SetAt(0x48884064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884064>);
+	m_dsmap.SetAt(0x488c8364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488c8364>);
+	m_dsmap.SetAt(0x488c8b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488c8b64>);
+	m_dsmap.SetAt(0x488e8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8064>);
+	m_dsmap.SetAt(0x488e8364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8364>);
+	m_dsmap.SetAt(0x488e8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8864>);
+	m_dsmap.SetAt(0x488e8b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8b64>);
+	m_dsmap.SetAt(0x48904064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48904064>);
+	m_dsmap.SetAt(0x48c0404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c0404c>);
+	m_dsmap.SetAt(0x48c6804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c6804c>);
+	m_dsmap.SetAt(0x48c6904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c6904c>);
+	m_dsmap.SetAt(0x48c7804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c7804c>);
+	m_dsmap.SetAt(0x48c7884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c7884c>);
+	m_dsmap.SetAt(0x49004064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004064>);
+	m_dsmap.SetAt(0x4900484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4900484c>);
+	m_dsmap.SetAt(0x49004864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004864>);
+	m_dsmap.SetAt(0x4903804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4903804c>);
+	m_dsmap.SetAt(0x4905804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4905804c>);
+	m_dsmap.SetAt(0x49068064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068064>);
+	m_dsmap.SetAt(0x49068364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068364>);
+	m_dsmap.SetAt(0x4906884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4906884c>);
+	m_dsmap.SetAt(0x49068864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068864>);
+	m_dsmap.SetAt(0x49068b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068b64>);
+	m_dsmap.SetAt(0x4907804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907804c>);
+	m_dsmap.SetAt(0x49078064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078064>);
+	m_dsmap.SetAt(0x49078364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078364>);
+	m_dsmap.SetAt(0x4907884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907884c>);
+	m_dsmap.SetAt(0x490e8b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8b64>);
+	m_dsmap.SetAt(0x49268064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49268064>);
+	m_dsmap.SetAt(0x49278064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49278064>);
+	m_dsmap.SetAt(0x4b00404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b00404c>);
+	m_dsmap.SetAt(0x5fe0404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe0404c>);
+	m_dsmap.SetAt(0x5fe04064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe04064>);
+	m_dsmap.SetAt(0x5ff0404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5ff0404c>);
 
 	// ffx-2
 
-	m_dsmap.SetAt(0x20002806, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x20002806>);
-	m_dsmap.SetAt(0x24402805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402805>);
-	m_dsmap.SetAt(0x2440c245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c245>);
-	m_dsmap.SetAt(0x2440c445, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c445>);
-	m_dsmap.SetAt(0x2440d065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440d065>);
-	m_dsmap.SetAt(0x2440d805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440d805>);
-	m_dsmap.SetAt(0x24410215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410215>);
-	m_dsmap.SetAt(0x24411c19, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411c19>);
-	m_dsmap.SetAt(0x24490214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24490214>);
-	m_dsmap.SetAt(0x24491854, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24491854>);
-	m_dsmap.SetAt(0x244b1814, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x244b1814>);
-	m_dsmap.SetAt(0x2480c225, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480c225>);
-	m_dsmap.SetAt(0x2a902205, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a902205>);
-	m_dsmap.SetAt(0x2ff02805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02805>);
-	m_dsmap.SetAt(0x2ff0c245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff0c245>);
-	m_dsmap.SetAt(0x4ff03829, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03829>);
-	m_dsmap.SetAt(0x4ff0c215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0c215>);
-	m_dsmap.SetAt(0x6440d065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440d065>);
-	m_dsmap.SetAt(0x6440d815, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440d815>);
-	m_dsmap.SetAt(0x6440e225, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e225>);
-	m_dsmap.SetAt(0x6440e275, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e275>);
-	m_dsmap.SetAt(0x64420215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64420215>);
-	m_dsmap.SetAt(0x64802219, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64802219>);
-	m_dsmap.SetAt(0x64802259, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64802259>);
-	m_dsmap.SetAt(0x64802269, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64802269>);
-	m_dsmap.SetAt(0x6480c215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6480c215>);
-	m_dsmap.SetAt(0x66402215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402215>);
-	m_dsmap.SetAt(0x6880c265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6880c265>);
-	m_dsmap.SetAt(0x6880d065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6880d065>);
-	m_dsmap.SetAt(0xa420d425, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420d425>);
-	m_dsmap.SetAt(0xa420d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa420d465>);
-	m_dsmap.SetAt(0xa440cc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440cc05>);
-	m_dsmap.SetAt(0xa440dc25, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440dc25>);
-	m_dsmap.SetAt(0xa4410815, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4410815>);
-	m_dsmap.SetAt(0xa4490814, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4490814>);
-	m_dsmap.SetAt(0xa480dc25, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480dc25>);
-	m_dsmap.SetAt(0xa484d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa484d465>);
-	m_dsmap.SetAt(0xa880d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa880d465>);
-	m_dsmap.SetAt(0xaff02c45, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff02c45>);
-	m_dsmap.SetAt(0xaff0cc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff0cc05>);
-	m_dsmap.SetAt(0xaff0cc45, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff0cc45>);
-	m_dsmap.SetAt(0xe004d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe004d465>);
-	m_dsmap.SetAt(0xe440d425, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d425>);
-	m_dsmap.SetAt(0xe440ec15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440ec15>);
-	m_dsmap.SetAt(0xe440ec25, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440ec25>);
-	m_dsmap.SetAt(0xe440fc75, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440fc75>);
-	m_dsmap.SetAt(0xe480ac15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480ac15>);
-	m_dsmap.SetAt(0xe480ec15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480ec15>);
-	m_dsmap.SetAt(0xe480fc15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480fc15>);
-	m_dsmap.SetAt(0xe484d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe484d465>);
-	m_dsmap.SetAt(0xe6402815, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe6402815>);
-	m_dsmap.SetAt(0xe880d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe880d465>);
+	m_dsmap.SetAt(0x1fe0404d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0404d>);
+	m_dsmap.SetAt(0x1fe0414d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0414d>);
+	m_dsmap.SetAt(0x1fe1004e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1004e>);
+	m_dsmap.SetAt(0x1fe30069, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe30069>);
+	m_dsmap.SetAt(0x1fee8165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8165>);
+	m_dsmap.SetAt(0x1fee8965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8965>);
+	m_dsmap.SetAt(0x4840414d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4840414d>);
+	m_dsmap.SetAt(0x48404155, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404155>);
+	m_dsmap.SetAt(0x48468165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468165>);
+	m_dsmap.SetAt(0x48468965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468965>);
+	m_dsmap.SetAt(0x48478965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478965>);
+	m_dsmap.SetAt(0x488041e5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488041e5>);
+	m_dsmap.SetAt(0x4880494d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4880494d>);
+	m_dsmap.SetAt(0x488049f5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488049f5>);
+	m_dsmap.SetAt(0x4881004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881004d>);
+	m_dsmap.SetAt(0x4881894d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881894d>);
+	m_dsmap.SetAt(0x48820165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48820165>);
+	m_dsmap.SetAt(0x48820875, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48820875>);
+	m_dsmap.SetAt(0x48830155, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830155>);
+	m_dsmap.SetAt(0x4883904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883904d>);
+	m_dsmap.SetAt(0x4885004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885004d>);
+	m_dsmap.SetAt(0x4885814d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885814d>);
+	m_dsmap.SetAt(0x488581cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488581cd>);
+	m_dsmap.SetAt(0x488581e5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488581e5>);
+	m_dsmap.SetAt(0x488591cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488591cd>);
+	m_dsmap.SetAt(0x488591d5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488591d5>);
+	m_dsmap.SetAt(0x48869165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869165>);
+	m_dsmap.SetAt(0x48878074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878074>);
+	m_dsmap.SetAt(0x488781f5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488781f5>);
+	m_dsmap.SetAt(0x48878874, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878874>);
+	m_dsmap.SetAt(0x48878965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878965>);
+	m_dsmap.SetAt(0x488789f5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488789f5>);
+	m_dsmap.SetAt(0x48879165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879165>);
+	m_dsmap.SetAt(0x49004059, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004059>);
+	m_dsmap.SetAt(0x49004155, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004155>);
+	m_dsmap.SetAt(0x49004859, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004859>);
+	m_dsmap.SetAt(0x49004869, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004869>);
+	m_dsmap.SetAt(0x4900494d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4900494d>);
+	m_dsmap.SetAt(0x4901004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4901004d>);
+	m_dsmap.SetAt(0x490581cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490581cd>);
+	m_dsmap.SetAt(0x49059155, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49059155>);
+	m_dsmap.SetAt(0x490591cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490591cd>);
+	m_dsmap.SetAt(0x4906814d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4906814d>);
+	m_dsmap.SetAt(0x490781cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490781cd>);
+	m_dsmap.SetAt(0x490791cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490791cd>);
+	m_dsmap.SetAt(0x490e8165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8165>);
+	m_dsmap.SetAt(0x490e8965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8965>);
+	m_dsmap.SetAt(0x4c80404d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c80404d>);
+	m_dsmap.SetAt(0x4c804055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804055>);
+	m_dsmap.SetAt(0x4c81004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c81004d>);
+	m_dsmap.SetAt(0x4c850055, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c850055>);
+	m_dsmap.SetAt(0x4d020965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d020965>);
+	m_dsmap.SetAt(0x4d068965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068965>);
+	m_dsmap.SetAt(0x51068165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51068165>);
+	m_dsmap.SetAt(0x51068965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51068965>);
+	m_dsmap.SetAt(0x510a8165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x510a8165>);
+	m_dsmap.SetAt(0x510a8965, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x510a8965>);
+	m_dsmap.SetAt(0x5520404d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5520404d>);
+	m_dsmap.SetAt(0x5fe0414d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe0414d>);
+	m_dsmap.SetAt(0x5fe0494d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe0494d>);
+	m_dsmap.SetAt(0x5fe1004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe1004d>);
+	m_dsmap.SetAt(0x5fe5884d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe5884d>);
+	m_dsmap.SetAt(0x5fe5894d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe5894d>);
+	m_dsmap.SetAt(0x5fe5914d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe5914d>);
 
-	// 12riven
+	// kingdom hearts
 
-	m_dsmap.SetAt(0x24402208, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402208>);
-	m_dsmap.SetAt(0x24403c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403c08>);
-	m_dsmap.SetAt(0xa4402c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c08>);
-	m_dsmap.SetAt(0xa4402c48, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c48>);
+	m_dsmap.SetAt(0x1fe0484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0484c>);
+	m_dsmap.SetAt(0x1fe1804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1804c>);
+	m_dsmap.SetAt(0x1fe3004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3004d>);
+	m_dsmap.SetAt(0x1fe30054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe30054>);
+	m_dsmap.SetAt(0x1fe3804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3804d>);
+	m_dsmap.SetAt(0x1fe3904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3904d>);
+	m_dsmap.SetAt(0x1fe39054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe39054>);
+	m_dsmap.SetAt(0x1fee9164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee9164>);
+	m_dsmap.SetAt(0x4840414c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4840414c>);
+	m_dsmap.SetAt(0x4846814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4846814c>);
+	m_dsmap.SetAt(0x48468174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468174>);
+	m_dsmap.SetAt(0x48468974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468974>);
+	m_dsmap.SetAt(0x4847814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4847814c>);
+	m_dsmap.SetAt(0x48478174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478174>);
+	m_dsmap.SetAt(0x48478974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478974>);
+	m_dsmap.SetAt(0x48804054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804054>);
+	m_dsmap.SetAt(0x4880414c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4880414c>);
+	m_dsmap.SetAt(0x4880494c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4880494c>);
+	m_dsmap.SetAt(0x48804974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804974>);
+	m_dsmap.SetAt(0x4881004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881004c>);
+	m_dsmap.SetAt(0x48818054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48818054>);
+	m_dsmap.SetAt(0x48819054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48819054>);
+	m_dsmap.SetAt(0x48829164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48829164>);
+	m_dsmap.SetAt(0x48830054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830054>);
+	m_dsmap.SetAt(0x48830164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830164>);
+	m_dsmap.SetAt(0x48858054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858054>);
+	m_dsmap.SetAt(0x48858854, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858854>);
+	m_dsmap.SetAt(0x48859054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48859054>);
+	m_dsmap.SetAt(0x4886814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886814c>);
+	m_dsmap.SetAt(0x48868154, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868154>);
+	m_dsmap.SetAt(0x48868174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868174>);
+	m_dsmap.SetAt(0x48868974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868974>);
+	m_dsmap.SetAt(0x48878054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878054>);
+	m_dsmap.SetAt(0x4887814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887814c>);
+	m_dsmap.SetAt(0x48878154, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878154>);
+	m_dsmap.SetAt(0x48878174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878174>);
+	m_dsmap.SetAt(0x48878854, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878854>);
+	m_dsmap.SetAt(0x4887894c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887894c>);
+	m_dsmap.SetAt(0x48879054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879054>);
+	m_dsmap.SetAt(0x4887914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887914c>);
+	m_dsmap.SetAt(0x488a8168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8168>);
+	m_dsmap.SetAt(0x488e80e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e80e4>);
+	m_dsmap.SetAt(0x488e8164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8164>);
+	m_dsmap.SetAt(0x488e8168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8168>);
+	m_dsmap.SetAt(0x488e88e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e88e4>);
+	m_dsmap.SetAt(0x488e8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8964>);
+	m_dsmap.SetAt(0x488e90e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e90e4>);
+	m_dsmap.SetAt(0x488e9164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9164>);
+	m_dsmap.SetAt(0x488e9168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9168>);
+	m_dsmap.SetAt(0x48c68174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c68174>);
+	m_dsmap.SetAt(0x48c68974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c68974>);
+	m_dsmap.SetAt(0x49004054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004054>);
+	m_dsmap.SetAt(0x4900414c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4900414c>);
+	m_dsmap.SetAt(0x49058054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49058054>);
+	m_dsmap.SetAt(0x49059054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49059054>);
+	m_dsmap.SetAt(0x49068174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068174>);
+	m_dsmap.SetAt(0x4906894c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4906894c>);
+	m_dsmap.SetAt(0x49068974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068974>);
+	m_dsmap.SetAt(0x49078054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078054>);
+	m_dsmap.SetAt(0x4907814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907814c>);
+	m_dsmap.SetAt(0x49078174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078174>);
+	m_dsmap.SetAt(0x4907894c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907894c>);
+	m_dsmap.SetAt(0x49078974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078974>);
+	m_dsmap.SetAt(0x49079174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079174>);
+	m_dsmap.SetAt(0x490e814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e814c>);
+	m_dsmap.SetAt(0x490e894c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e894c>);
+	m_dsmap.SetAt(0x490e8974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8974>);
+	m_dsmap.SetAt(0x5020404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5020404c>);
+	m_dsmap.SetAt(0x5fe04058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe04058>);
+	m_dsmap.SetAt(0x5fe04168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe04168>);
+	m_dsmap.SetAt(0x5fe3804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe3804c>);
+	m_dsmap.SetAt(0x5fe3904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe3904c>);
+	m_dsmap.SetAt(0x5fea8168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fea8168>);
 
-	// onimusha 3
+	// kingdom hearts 2
 
-	m_dsmap.SetAt(0x0ff02c28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c28>);
-	m_dsmap.SetAt(0x0ff02c8a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c8a>);
-	m_dsmap.SetAt(0x0ff03808, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03808>);
-	m_dsmap.SetAt(0x0ff03c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c08>);
-	m_dsmap.SetAt(0x0ff03c0a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c0a>);
-	m_dsmap.SetAt(0x2440bc28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440bc28>);
-	m_dsmap.SetAt(0x24803c48, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24803c48>);
-	m_dsmap.SetAt(0x26402c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402c08>);
-	m_dsmap.SetAt(0x26802228, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26802228>);
-	m_dsmap.SetAt(0x26803c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803c08>);
-	m_dsmap.SetAt(0x26803c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803c88>);
-	m_dsmap.SetAt(0x2ff02238, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02238>);
-	m_dsmap.SetAt(0x2ff02c8a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02c8a>);
-	m_dsmap.SetAt(0x2ff82208, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff82208>);
-	m_dsmap.SetAt(0x2ff82c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff82c08>);
-	m_dsmap.SetAt(0x6461d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6461d468>);
-	m_dsmap.SetAt(0x6481c268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6481c268>);
-	m_dsmap.SetAt(0x6641c228, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6641c228>);
-	m_dsmap.SetAt(0x6ff1c228, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff1c228>);
-	m_dsmap.SetAt(0x8ff4d048, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff4d048>);
-	m_dsmap.SetAt(0x8ff4d448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff4d448>);
-	m_dsmap.SetAt(0xa4403468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403468>);
-	m_dsmap.SetAt(0xa4803c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4803c08>);
-	m_dsmap.SetAt(0xa8902c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa8902c88>);
-	m_dsmap.SetAt(0xaa102c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaa102c88>);
-	m_dsmap.SetAt(0xaff02c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff02c88>);
-	m_dsmap.SetAt(0xaff03c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff03c88>);
-	m_dsmap.SetAt(0xcff4b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4b468>);
-	m_dsmap.SetAt(0xcff5d068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff5d068>);
-	m_dsmap.SetAt(0xe411d428, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe411d428>);
-	m_dsmap.SetAt(0xe421d428, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe421d428>);
-	m_dsmap.SetAt(0xe4403c28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403c28>);
-	m_dsmap.SetAt(0xe441d428, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441d428>);
-	m_dsmap.SetAt(0xe441dc28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441dc28>);
-	m_dsmap.SetAt(0xe441dc68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441dc68>);
-	m_dsmap.SetAt(0xe445d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445d468>);
-	m_dsmap.SetAt(0xe461dc28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe461dc28>);
-	m_dsmap.SetAt(0xe4803c28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4803c28>);
-	m_dsmap.SetAt(0xe481d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe481d468>);
-	m_dsmap.SetAt(0xe481dc28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe481dc28>);
-	m_dsmap.SetAt(0xe640bc28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe640bc28>);
-	m_dsmap.SetAt(0xe640ec28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe640ec28>);
-	m_dsmap.SetAt(0xe641cc28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe641cc28>);
-	m_dsmap.SetAt(0xe644b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe644b468>);
-
-	// nba 2k8
-
-	m_dsmap.SetAt(0x24403446, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403446>);
-	m_dsmap.SetAt(0x2448d466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2448d466>);
-	m_dsmap.SetAt(0x60002256, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x60002256>);
-	m_dsmap.SetAt(0x6440b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440b466>);
-	m_dsmap.SetAt(0x6480b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6480b466>);
-	m_dsmap.SetAt(0x6a80b456, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a80b456>);
-	m_dsmap.SetAt(0x6a80b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a80b466>);
-	m_dsmap.SetAt(0xa440b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440b466>);
-	m_dsmap.SetAt(0xa480b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480b466>);
-	m_dsmap.SetAt(0xaa80b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaa80b466>);
-	m_dsmap.SetAt(0xe440a466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440a466>);
-	m_dsmap.SetAt(0xe440b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440b466>);
-	m_dsmap.SetAt(0xe440c466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440c466>);
-	m_dsmap.SetAt(0xe440d466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d466>);
-	m_dsmap.SetAt(0xea80a466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xea80a466>);
-	m_dsmap.SetAt(0xea80b066, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xea80b066>);
-	m_dsmap.SetAt(0xea80b466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xea80b466>);
-
-	// svr2k8
-
-	m_dsmap.SetAt(0x24412244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24412244>);
-	m_dsmap.SetAt(0x2441a244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441a244>);
-	m_dsmap.SetAt(0x2441c244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441c244>);
-	m_dsmap.SetAt(0x2441d044, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441d044>);
-	m_dsmap.SetAt(0x2441d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441d444>);
-	m_dsmap.SetAt(0x2481a244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2481a244>);
-	m_dsmap.SetAt(0x26242244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26242244>);
-	m_dsmap.SetAt(0x2a910214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a910214>);
-	m_dsmap.SetAt(0x2ff31815, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff31815>);
-	m_dsmap.SetAt(0x4ff02216, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02216>);
-	m_dsmap.SetAt(0x64403064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64403064>);
-	m_dsmap.SetAt(0x6440dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440dc24>);
-	m_dsmap.SetAt(0x6441a214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6441a214>);
-	m_dsmap.SetAt(0x6444d064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444d064>);
-	m_dsmap.SetAt(0x6a9c2274, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a9c2274>);
-	m_dsmap.SetAt(0xa441b444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441b444>);
-	m_dsmap.SetAt(0xa441bc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441bc04>);
-	m_dsmap.SetAt(0xa441d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441d444>);
-	m_dsmap.SetAt(0xa441dc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441dc04>);
-	m_dsmap.SetAt(0xa444b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa444b464>);
-	m_dsmap.SetAt(0xa44c3474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa44c3474>);
-	m_dsmap.SetAt(0xa481b444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa481b444>);
-	m_dsmap.SetAt(0xa481b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa481b464>);
-	m_dsmap.SetAt(0xa4843444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4843444>);
-	m_dsmap.SetAt(0xa484d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa484d464>);
-	m_dsmap.SetAt(0xa485d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa485d464>);
-	m_dsmap.SetAt(0xcff0dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0dc24>);
-	m_dsmap.SetAt(0xcff0dc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0dc26>);
-	m_dsmap.SetAt(0xe440d454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d454>);
-	m_dsmap.SetAt(0xe441b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441b464>);
-	m_dsmap.SetAt(0xe441b5e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441b5e4>);
-	m_dsmap.SetAt(0xe441bc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441bc14>);
-	m_dsmap.SetAt(0xe4443464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4443464>);
-	m_dsmap.SetAt(0xe481b454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe481b454>);
-	m_dsmap.SetAt(0xe484d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe484d464>);
-	m_dsmap.SetAt(0xe64c3474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe64c3474>);
-
-	// rumble roses
-
-	m_dsmap.SetAt(0x0ff03805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03805>);
-	m_dsmap.SetAt(0x24410244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410244>);
-	m_dsmap.SetAt(0x24430214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24430214>);
-	m_dsmap.SetAt(0x2ff10204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff10204>);
-	m_dsmap.SetAt(0x6440c224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440c224>);
-	m_dsmap.SetAt(0x6440d824, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440d824>);
-	m_dsmap.SetAt(0x64443064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64443064>);
-	m_dsmap.SetAt(0x6640d824, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6640d824>);
-	m_dsmap.SetAt(0x66443064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66443064>);
-	m_dsmap.SetAt(0xe440d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d464>);
-	m_dsmap.SetAt(0xe440d5e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d5e4>);
-	m_dsmap.SetAt(0xe440dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc24>);
-	m_dsmap.SetAt(0xe441d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441d464>);
-	m_dsmap.SetAt(0xe443d5e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe443d5e4>);
-	m_dsmap.SetAt(0xe445d064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445d064>);
-	m_dsmap.SetAt(0xe447d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe447d464>);
-	m_dsmap.SetAt(0xe5843464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe5843464>);
-	m_dsmap.SetAt(0xe6443464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe6443464>);
-	m_dsmap.SetAt(0xe644d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe644d464>);
-	m_dsmap.SetAt(0xe645d064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe645d064>);
-	m_dsmap.SetAt(0xe645d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe645d464>);
-
-	// disgaea 2
-
-	m_dsmap.SetAt(0x6441d064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6441d064>);
-	m_dsmap.SetAt(0x6a80c224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a80c224>);
-	m_dsmap.SetAt(0xe2a0d474, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe2a0d474>);
-	m_dsmap.SetAt(0xe440dc64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc64>);
-	m_dsmap.SetAt(0xe481d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe481d464>);
-	m_dsmap.SetAt(0xe620d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe620d464>);
-
-	// Gundam Seed Destiny OMNI VS ZAFT II PLUS 
-
-	m_dsmap.SetAt(0x0ff12205, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff12205>);
-	m_dsmap.SetAt(0x4ff12215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff12215>);
-	m_dsmap.SetAt(0xa4402c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c05>);
-	m_dsmap.SetAt(0xa4403445, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403445>);
-	m_dsmap.SetAt(0xa4403c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403c05>);
-	m_dsmap.SetAt(0xa441b475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441b475>);
-	m_dsmap.SetAt(0xa445b475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa445b475>);
-	m_dsmap.SetAt(0xa4803445, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4803445>);
-	m_dsmap.SetAt(0xa481b475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa481b475>);
-	m_dsmap.SetAt(0xa485b475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa485b475>);
-	m_dsmap.SetAt(0xcff1b475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff1b475>);
-	m_dsmap.SetAt(0xcff5b475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff5b475>);
-	m_dsmap.SetAt(0xe445b475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445b475>);
-
-	// grandia 3
-
-	m_dsmap.SetAt(0x20a0224a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x20a0224a>);
-	m_dsmap.SetAt(0x24202200, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24202200>);
-	m_dsmap.SetAt(0x24471460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24471460>);
-	m_dsmap.SetAt(0x24803c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24803c00>);
-	m_dsmap.SetAt(0x24830240, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24830240>);
-	m_dsmap.SetAt(0x24830260, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24830260>);
-	m_dsmap.SetAt(0x26402200, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402200>);
-	m_dsmap.SetAt(0x26402c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402c00>);
-	m_dsmap.SetAt(0x26403c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403c00>);
-	m_dsmap.SetAt(0x26403c20, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403c20>);
-	m_dsmap.SetAt(0x26433c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26433c00>);
-	m_dsmap.SetAt(0x26433c20, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26433c20>);
-	m_dsmap.SetAt(0x2ff02200, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02200>);
-	m_dsmap.SetAt(0x4ff02210, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02210>);
-	m_dsmap.SetAt(0x4ff0221a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0221a>);
-	m_dsmap.SetAt(0x6445a260, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6445a260>);
-	m_dsmap.SetAt(0x6447a260, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6447a260>);
-	m_dsmap.SetAt(0x66403c20, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66403c20>);
-	m_dsmap.SetAt(0x66433c20, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66433c20>);
-	m_dsmap.SetAt(0xa0903440, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa0903440>);
-	m_dsmap.SetAt(0xa0931460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa0931460>);
-	m_dsmap.SetAt(0xa4271460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4271460>);
-	m_dsmap.SetAt(0xa4403440, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403440>);
-	m_dsmap.SetAt(0xa4471470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4471470>);
-	m_dsmap.SetAt(0xa4831440, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4831440>);
-	m_dsmap.SetAt(0xa4831460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4831460>);
-	m_dsmap.SetAt(0xa4871460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4871460>);
-	m_dsmap.SetAt(0xa8191460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa8191460>);
-	m_dsmap.SetAt(0xe441b460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441b460>);
-	m_dsmap.SetAt(0xe443b460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe443b460>);
-	m_dsmap.SetAt(0xe445b460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445b460>);
-	m_dsmap.SetAt(0xe445d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445d460>);
-	m_dsmap.SetAt(0xe447b460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe447b460>);
-	m_dsmap.SetAt(0xe447d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe447d460>);
-
-	// shadow of the colossus
-
-	m_dsmap.SetAt(0x0ff02805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02805>);
-	m_dsmap.SetAt(0x0ff10214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10214>);
-	m_dsmap.SetAt(0x0ff10224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10224>);
-	m_dsmap.SetAt(0x0ff10254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10254>);
-	m_dsmap.SetAt(0x0ff10264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10264>);
-	m_dsmap.SetAt(0x0ff10c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10c14>);
-	m_dsmap.SetAt(0x0ff11c15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff11c15>);
-	m_dsmap.SetAt(0x24411814, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411814>);
-	m_dsmap.SetAt(0x24411c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411c14>);
-	m_dsmap.SetAt(0x24411c64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411c64>);
-	m_dsmap.SetAt(0x24451064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24451064>);
-	m_dsmap.SetAt(0x24491c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24491c24>);
-	m_dsmap.SetAt(0x24810214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24810214>);
-	m_dsmap.SetAt(0x24810254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24810254>);
-	m_dsmap.SetAt(0x24811c14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24811c14>);
-	m_dsmap.SetAt(0x25411814, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25411814>);
-	m_dsmap.SetAt(0x26410214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26410214>);
-	m_dsmap.SetAt(0x26810224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26810224>);
-	m_dsmap.SetAt(0x34451464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x34451464>);
-	m_dsmap.SetAt(0x4ff0c224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0c224>);
-	m_dsmap.SetAt(0x64453464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64453464>);
-	m_dsmap.SetAt(0x6445a264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6445a264>);
-	m_dsmap.SetAt(0x6445b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6445b464>);
-	m_dsmap.SetAt(0xa4251464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4251464>);
-	m_dsmap.SetAt(0xa4451464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4451464>);
-	m_dsmap.SetAt(0xa4851464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4851464>);
-	m_dsmap.SetAt(0xe441cc64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441cc64>);
-	m_dsmap.SetAt(0xe441dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441dc24>);
-	m_dsmap.SetAt(0xe441dc64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441dc64>);
-	m_dsmap.SetAt(0xe4453464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4453464>);
-	m_dsmap.SetAt(0xe445a464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445a464>);
-	m_dsmap.SetAt(0xe485a464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe485a464>);
-	m_dsmap.SetAt(0xa4843464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4843464>);
-	m_dsmap.SetAt(0xe441b454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441b454>);
-	m_dsmap.SetAt(0xe481b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe481b464>);
-
-	// dq8
-
-	m_dsmap.SetAt(0x0ff02244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02244>);
-	m_dsmap.SetAt(0x0ff02c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c04>);
-	m_dsmap.SetAt(0x0ff02c85, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c85>);
-	m_dsmap.SetAt(0x0ff0dc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff0dc04>);
-	m_dsmap.SetAt(0x22a02c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x22a02c04>);
-	m_dsmap.SetAt(0x24202204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24202204>);
-	m_dsmap.SetAt(0x2420a264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2420a264>);
-	m_dsmap.SetAt(0x24402244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402244>);
-	m_dsmap.SetAt(0x2440bc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440bc04>);
-	m_dsmap.SetAt(0x2440dc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440dc04>);
-	m_dsmap.SetAt(0x2444b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2444b464>);
-	m_dsmap.SetAt(0x24603c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24603c04>);
-	m_dsmap.SetAt(0x2480a264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480a264>);
-	m_dsmap.SetAt(0x2484b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2484b464>);
-	m_dsmap.SetAt(0x26203c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26203c04>);
-	m_dsmap.SetAt(0x2640bc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2640bc04>);
-	m_dsmap.SetAt(0x28803c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x28803c04>);
-	m_dsmap.SetAt(0x28803d84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x28803d84>);
-	m_dsmap.SetAt(0x2ff03c06, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03c06>);
-	m_dsmap.SetAt(0x6440a264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440a264>);
-	m_dsmap.SetAt(0x6444b064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444b064>);
-	m_dsmap.SetAt(0x6444b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444b464>);
-	m_dsmap.SetAt(0x6484b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6484b464>);
-	m_dsmap.SetAt(0x8ff03c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff03c04>);
-	m_dsmap.SetAt(0x8ff03c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff03c05>);
-	m_dsmap.SetAt(0xa4203c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4203c05>);
-	m_dsmap.SetAt(0xa4402c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c04>);
-	m_dsmap.SetAt(0xa4803c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4803c04>);
-	m_dsmap.SetAt(0xa480b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480b464>);
-	m_dsmap.SetAt(0xe444b454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444b454>);
-	m_dsmap.SetAt(0xe484b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe484b464>);
-	m_dsmap.SetAt(0xa4403c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403c24>);
-	m_dsmap.SetAt(0xa4803c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4803c24>);
-
-	// suikoden 5
-
-	m_dsmap.SetAt(0x2441b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441b448>);
-	m_dsmap.SetAt(0x60203468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x60203468>);
-	m_dsmap.SetAt(0x64402258, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402258>);
-	m_dsmap.SetAt(0x6441a468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6441a468>);
-	m_dsmap.SetAt(0x6441b468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6441b468>);
-	m_dsmap.SetAt(0x64803468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64803468>);
-	m_dsmap.SetAt(0xa421b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa421b448>);
-	m_dsmap.SetAt(0xe6803468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe6803468>);
-
-	// culdcept
-
-	m_dsmap.SetAt(0x0ff02200, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02200>);
-	m_dsmap.SetAt(0x0ff03880, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03880>);
-	m_dsmap.SetAt(0x2440e266, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440e266>);
-	m_dsmap.SetAt(0x2440e466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440e466>);
-	m_dsmap.SetAt(0x2440ec26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440ec26>);
-	m_dsmap.SetAt(0x2440f466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440f466>);
-	m_dsmap.SetAt(0x2480e266, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480e266>);
-	m_dsmap.SetAt(0x2680e266, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2680e266>);
-	m_dsmap.SetAt(0x2680f566, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2680f566>);
-	m_dsmap.SetAt(0x2680fc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2680fc26>);
-	m_dsmap.SetAt(0x2a10f566, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a10f566>);
-	m_dsmap.SetAt(0x4ff0e266, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0e266>);
-	m_dsmap.SetAt(0x4ff0e466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0e466>);
-	m_dsmap.SetAt(0x4ff0ec26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0ec26>);
-	m_dsmap.SetAt(0x4ff0f526, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0f526>);
-	m_dsmap.SetAt(0x4ff0f566, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0f566>);
-	m_dsmap.SetAt(0x4ff0fc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0fc26>);
-	m_dsmap.SetAt(0x4ff4ec26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4ec26>);
-	m_dsmap.SetAt(0x4ff4f526, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4f526>);
-	m_dsmap.SetAt(0x4ff4f566, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4f566>);
-	m_dsmap.SetAt(0x4ff4fc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4fc26>);
-	m_dsmap.SetAt(0x6440ec26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440ec26>);
-	m_dsmap.SetAt(0x6440f466, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440f466>);
-	m_dsmap.SetAt(0x6440fc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440fc26>);
-	m_dsmap.SetAt(0x6444fc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444fc26>);
-	m_dsmap.SetAt(0xa440ec26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440ec26>);
-	m_dsmap.SetAt(0xcff0ec26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0ec26>);
-	m_dsmap.SetAt(0xcff0fc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0fc26>);
-	m_dsmap.SetAt(0xcff4ec26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4ec26>);
-	m_dsmap.SetAt(0xcff4fc26, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4fc26>);
-
-	// resident evil 4
-
-	m_dsmap.SetAt(0x0ff02c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c24>);
-	m_dsmap.SetAt(0x0ff02c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c84>);
-	m_dsmap.SetAt(0x0ff03884, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03884>);
-	m_dsmap.SetAt(0x0ff03c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c00>);
-	m_dsmap.SetAt(0x22a03c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x22a03c84>);
-	m_dsmap.SetAt(0x2440c204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c204>);
-	m_dsmap.SetAt(0x2440d404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440d404>);
-	m_dsmap.SetAt(0x24802204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802204>);
-	m_dsmap.SetAt(0x24803c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24803c04>);
-	m_dsmap.SetAt(0x2480c224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480c224>);
-	m_dsmap.SetAt(0x2481c264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2481c264>);
-	m_dsmap.SetAt(0x26403c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403c84>);
-	m_dsmap.SetAt(0x2640c224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2640c224>);
-	m_dsmap.SetAt(0x26802224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26802224>);
-	m_dsmap.SetAt(0x26803c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803c84>);
-	m_dsmap.SetAt(0x28902204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x28902204>);
-	m_dsmap.SetAt(0x2a403c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a403c84>);
-	m_dsmap.SetAt(0x6640d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6640d464>);
-	m_dsmap.SetAt(0x66420214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66420214>);
-	m_dsmap.SetAt(0xa2a02c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa2a02c84>);
-	m_dsmap.SetAt(0xa440d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d444>);
-	m_dsmap.SetAt(0xa480d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d444>);
-	m_dsmap.SetAt(0xa480d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d464>);
-	m_dsmap.SetAt(0xa680d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa680d444>);
-	m_dsmap.SetAt(0xaff02c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff02c84>);
-	m_dsmap.SetAt(0xaff03484, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff03484>);
-	m_dsmap.SetAt(0xe580d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe580d464>);
+	m_dsmap.SetAt(0x1fe04050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04050>);
+	m_dsmap.SetAt(0x1fe31054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe31054>);
+	m_dsmap.SetAt(0x1fe3914d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3914d>);
+	m_dsmap.SetAt(0x40478174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x40478174>);
+	m_dsmap.SetAt(0x40c78174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x40c78174>);
+	m_dsmap.SetAt(0x48478054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478054>);
+	m_dsmap.SetAt(0x48478854, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478854>);
+	m_dsmap.SetAt(0x48804160, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804160>);
+	m_dsmap.SetAt(0x48810054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48810054>);
+	m_dsmap.SetAt(0x4883814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883814c>);
+	m_dsmap.SetAt(0x4883914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883914c>);
+	m_dsmap.SetAt(0x4885884d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885884d>);
+	m_dsmap.SetAt(0x4887804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887804d>);
+	m_dsmap.SetAt(0x4887884d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887884d>);
+	m_dsmap.SetAt(0x48879154, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879154>);
+	m_dsmap.SetAt(0x488a8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8964>);
+	m_dsmap.SetAt(0x49004974, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004974>);
+	m_dsmap.SetAt(0x4907804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907804d>);
+	m_dsmap.SetAt(0x4907884d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907884d>);
+	m_dsmap.SetAt(0x49078854, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078854>);
+	m_dsmap.SetAt(0x4907904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907904d>);
+	m_dsmap.SetAt(0x49079054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079054>);
+	m_dsmap.SetAt(0x490e8164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8164>);
+	m_dsmap.SetAt(0x490e8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8964>);
+	m_dsmap.SetAt(0x4ac78174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ac78174>);
+	m_dsmap.SetAt(0x4c83004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83004d>);
+	m_dsmap.SetAt(0x4d03004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d03004d>);
+	m_dsmap.SetAt(0x50c68174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x50c68174>);
+	m_dsmap.SetAt(0x54478174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x54478174>);
+	m_dsmap.SetAt(0x5fe68174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe68174>);
+	m_dsmap.SetAt(0x5fe78174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe78174>);
+	m_dsmap.SetAt(0x48830074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830074>);
+	m_dsmap.SetAt(0x48830874, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830874>);
+	m_dsmap.SetAt(0x4887904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887904d>);
+	m_dsmap.SetAt(0x48879074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879074>);
+	m_dsmap.SetAt(0x4888404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4888404c>);
+	m_dsmap.SetAt(0x488a8164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8164>);
+	m_dsmap.SetAt(0x49038174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49038174>);
+	m_dsmap.SetAt(0x49084174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49084174>);
+	m_dsmap.SetAt(0x4c084174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c084174>);
+	m_dsmap.SetAt(0x50884174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x50884174>);
+	m_dsmap.SetAt(0x5fe04174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe04174>);
+	m_dsmap.SetAt(0x5fe2b174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe2b174>);
+	m_dsmap.SetAt(0x5fe3b174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe3b174>);
 
 	// persona 3
 
-	m_dsmap.SetAt(0x0ff02248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02248>);
-	m_dsmap.SetAt(0x24402268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402268>);
-	m_dsmap.SetAt(0x24410448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410448>);
-	m_dsmap.SetAt(0x2441a448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2441a448>);
-	m_dsmap.SetAt(0x2445a468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2445a468>);
-	m_dsmap.SetAt(0x4ff02268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02268>);
-	m_dsmap.SetAt(0xa4811448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4811448>);
-	m_dsmap.SetAt(0xa581b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa581b448>);
-	m_dsmap.SetAt(0xa6a1b448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6a1b448>);
-	m_dsmap.SetAt(0xe4461468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4461468>);
+	m_dsmap.SetAt(0x1fe04058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04058>);
+	m_dsmap.SetAt(0x1fe0405b, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0405b>);
+	m_dsmap.SetAt(0x1fe04068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04068>);
+	m_dsmap.SetAt(0x1fe04368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04368>);
+	m_dsmap.SetAt(0x1fe82368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe82368>);
+	m_dsmap.SetAt(0x1fe84068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84068>);
+	m_dsmap.SetAt(0x1fe84368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84368>);
+	m_dsmap.SetAt(0x1fe84868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84868>);
+	m_dsmap.SetAt(0x4840404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4840404c>);
+	m_dsmap.SetAt(0x4840484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4840484c>);
+	m_dsmap.SetAt(0x484e8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x484e8068>);
+	m_dsmap.SetAt(0x48804068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804068>);
+	m_dsmap.SetAt(0x48804368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804368>);
+	m_dsmap.SetAt(0x48804868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804868>);
+	m_dsmap.SetAt(0x4881834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881834c>);
+	m_dsmap.SetAt(0x4881884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881884c>);
+	m_dsmap.SetAt(0x4881934c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881934c>);
+	m_dsmap.SetAt(0x48820368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48820368>);
+	m_dsmap.SetAt(0x48848b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48848b68>);
+	m_dsmap.SetAt(0x48858368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858368>);
+	m_dsmap.SetAt(0x48858b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858b68>);
+	m_dsmap.SetAt(0x48859368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48859368>);
+	m_dsmap.SetAt(0x48868068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868068>);
+	m_dsmap.SetAt(0x48868368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868368>);
+	m_dsmap.SetAt(0x48868b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868b68>);
+	m_dsmap.SetAt(0x48878068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878068>);
+	m_dsmap.SetAt(0x4887834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887834c>);
+	m_dsmap.SetAt(0x48878368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878368>);
+	m_dsmap.SetAt(0x48878b4c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878b4c>);
+	m_dsmap.SetAt(0x48878b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878b68>);
+	m_dsmap.SetAt(0x4887934c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887934c>);
+	m_dsmap.SetAt(0x48879368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879368>);
+	m_dsmap.SetAt(0x48884068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884068>);
+	m_dsmap.SetAt(0x48884368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884368>);
+	m_dsmap.SetAt(0x48884868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884868>);
+	m_dsmap.SetAt(0x48892368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48892368>);
+	m_dsmap.SetAt(0x488b2368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488b2368>);
+	m_dsmap.SetAt(0x488e8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8068>);
+	m_dsmap.SetAt(0x488e8368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8368>);
+	m_dsmap.SetAt(0x488e8868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8868>);
+	m_dsmap.SetAt(0x488e8b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8b68>);
+	m_dsmap.SetAt(0x488e8f68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8f68>);
+	m_dsmap.SetAt(0x488e9368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9368>);
+	m_dsmap.SetAt(0x488f8868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8868>);
+	m_dsmap.SetAt(0x488f8b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8b68>);
+	m_dsmap.SetAt(0x4900404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4900404c>);
+	m_dsmap.SetAt(0x49068068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068068>);
+	m_dsmap.SetAt(0x49068868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068868>);
+	m_dsmap.SetAt(0x49078068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078068>);
+	m_dsmap.SetAt(0x49078868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078868>);
+	m_dsmap.SetAt(0x4907904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907904c>);
+	m_dsmap.SetAt(0x49079068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079068>);
+	m_dsmap.SetAt(0x490e8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8068>);
+	m_dsmap.SetAt(0x490e8868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8868>);
+	m_dsmap.SetAt(0x490f8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490f8068>);
+	m_dsmap.SetAt(0x4a43004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a43004c>);
+	m_dsmap.SetAt(0x4a83004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a83004c>);
+	m_dsmap.SetAt(0x4a87934c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a87934c>);
+	m_dsmap.SetAt(0x4b03004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b03004c>);
+	m_dsmap.SetAt(0x4b07934c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b07934c>);
+	m_dsmap.SetAt(0x4c8689e8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8689e8>);
+	m_dsmap.SetAt(0x4d0e8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d0e8068>);
+	m_dsmap.SetAt(0x4d0e8868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d0e8868>);
+	m_dsmap.SetAt(0x4d47834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d47834c>);
+	m_dsmap.SetAt(0x4d478b4c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d478b4c>);
+	m_dsmap.SetAt(0x4d47934c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d47934c>);
 
-	// bully
+	// persona 4
 
-	m_dsmap.SetAt(0x24802804, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802804>);
-	m_dsmap.SetAt(0x25403c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25403c84>);
-	m_dsmap.SetAt(0x26102204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26102204>);
-	m_dsmap.SetAt(0x26803884, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803884>);
-	m_dsmap.SetAt(0x2a402205, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a402205>);
-	m_dsmap.SetAt(0x2a802c86, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a802c86>);
-	m_dsmap.SetAt(0x2ff03884, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03884>);
-	m_dsmap.SetAt(0x4ff02264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02264>);
-	m_dsmap.SetAt(0x64402264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402264>);
-	m_dsmap.SetAt(0x64a02214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64a02214>);
-	m_dsmap.SetAt(0x6ff20235, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff20235>);
-	m_dsmap.SetAt(0xa441b424, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441b424>);
-	m_dsmap.SetAt(0xa441b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441b464>);
-	m_dsmap.SetAt(0xa441bc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441bc24>);
-	m_dsmap.SetAt(0xa441bc44, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441bc44>);
-	m_dsmap.SetAt(0xa445b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa445b464>);
-	m_dsmap.SetAt(0xa681b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa681b464>);
-	m_dsmap.SetAt(0xa681bc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa681bc04>);
-	m_dsmap.SetAt(0xa681bc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa681bc24>);
-	m_dsmap.SetAt(0xa681bc44, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa681bc44>);
-	m_dsmap.SetAt(0xa681bc64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa681bc64>);
-	m_dsmap.SetAt(0xe4a53464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4a53464>);
-	m_dsmap.SetAt(0xe884d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe884d464>);
-
-	// tomoyo after 
-
-	m_dsmap.SetAt(0x0ff0220a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff0220a>);
-	m_dsmap.SetAt(0x4ff02c19, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02c19>);
-	m_dsmap.SetAt(0x4ff03c19, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03c19>);
-	m_dsmap.SetAt(0x64202268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64202268>);
-	m_dsmap.SetAt(0x64402c68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402c68>);
-	m_dsmap.SetAt(0xe4203c68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4203c68>);
-	m_dsmap.SetAt(0xe4402c68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4402c68>);
-	m_dsmap.SetAt(0xe4403c68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403c68>);
-	m_dsmap.SetAt(0xe4802c68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4802c68>);
-	m_dsmap.SetAt(0xe5402c68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe5402c68>);
-
-	// okami
-
-	m_dsmap.SetAt(0x0ff02c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c88>);
-	m_dsmap.SetAt(0x24402c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402c08>);
-	m_dsmap.SetAt(0x24403c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403c88>);
-	m_dsmap.SetAt(0x24411468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24411468>);
-	m_dsmap.SetAt(0x25403c08, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25403c08>);
-	m_dsmap.SetAt(0x26203c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26203c88>);
-	m_dsmap.SetAt(0x26403888, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403888>);
-	m_dsmap.SetAt(0x26403c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403c88>);
-	m_dsmap.SetAt(0x26803888, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803888>);
-	m_dsmap.SetAt(0x2ff02c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02c88>);
-	m_dsmap.SetAt(0x4ff02c18, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02c18>);
-	m_dsmap.SetAt(0x62902c18, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x62902c18>);
-	m_dsmap.SetAt(0x64402218, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402218>);
-	m_dsmap.SetAt(0x64402238, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402238>);
-	m_dsmap.SetAt(0x6440dc18, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440dc18>);
-	m_dsmap.SetAt(0x6444c268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444c268>);
-	m_dsmap.SetAt(0xa440d428, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d428>);
-	m_dsmap.SetAt(0xa480d428, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d428>);
-	m_dsmap.SetAt(0xa8903c88, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa8903c88>);
-	m_dsmap.SetAt(0xaff02ca8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff02ca8>);
-	m_dsmap.SetAt(0xaff03888, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff03888>);
-	m_dsmap.SetAt(0xe4403418, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403418>);
-	m_dsmap.SetAt(0xe440d418, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d418>);
-	m_dsmap.SetAt(0xe440d428, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d428>);
-	m_dsmap.SetAt(0xe440dc18, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc18>);
-	m_dsmap.SetAt(0xe440dc28, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc28>);
-	m_dsmap.SetAt(0xe444d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444d468>);
+	m_dsmap.SetAt(0x1fe04858, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04858>);
+	m_dsmap.SetAt(0x1fe04b4c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04b4c>);
+	m_dsmap.SetAt(0x48804058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804058>);
+	m_dsmap.SetAt(0x48804b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804b68>);
+	m_dsmap.SetAt(0x48828368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48828368>);
+	m_dsmap.SetAt(0x48828b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48828b68>);
+	m_dsmap.SetAt(0x48830168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830168>);
+	m_dsmap.SetAt(0x48868868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868868>);
+	m_dsmap.SetAt(0x48868f68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868f68>);
+	m_dsmap.SetAt(0x48869368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869368>);
+	m_dsmap.SetAt(0x48879168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879168>);
+	m_dsmap.SetAt(0x48884b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884b68>);
+	m_dsmap.SetAt(0x488f8368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8368>);
+	m_dsmap.SetAt(0x49004068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004068>);
+	m_dsmap.SetAt(0x49004868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004868>);
+	m_dsmap.SetAt(0x4903004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4903004c>);
+	m_dsmap.SetAt(0x49084068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49084068>);
+	m_dsmap.SetAt(0x49084868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49084868>);
+	m_dsmap.SetAt(0x4a47804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a47804c>);
+	m_dsmap.SetAt(0x4a47904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a47904c>);
+	m_dsmap.SetAt(0x4a80404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a80404c>);
+	m_dsmap.SetAt(0x4a87834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a87834c>);
+	m_dsmap.SetAt(0x4a878368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a878368>);
+	m_dsmap.SetAt(0x4a878b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a878b68>);
+	m_dsmap.SetAt(0x4a879068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a879068>);
+	m_dsmap.SetAt(0x4b004968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b004968>);
+	m_dsmap.SetAt(0x4b07804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b07804c>);
+	m_dsmap.SetAt(0x4b07884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b07884c>);
+	m_dsmap.SetAt(0x4d080068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d080068>);
+	m_dsmap.SetAt(0x5fe04068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe04068>);
+	m_dsmap.SetAt(0x5fe04858, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe04858>);
+	m_dsmap.SetAt(0x5ff0484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5ff0484c>);
 
 	// sfex3
 
-	m_dsmap.SetAt(0x0ff0280a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff0280a>);
-	m_dsmap.SetAt(0x0ff0380a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff0380a>);
-	m_dsmap.SetAt(0x0ff0c278, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff0c278>);
-	m_dsmap.SetAt(0x2428e248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2428e248>);
-	m_dsmap.SetAt(0x2440280a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440280a>);
-	m_dsmap.SetAt(0x24802278, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802278>);
-	m_dsmap.SetAt(0x2480e278, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480e278>);
-	m_dsmap.SetAt(0x4ff02258, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02258>);
-	m_dsmap.SetAt(0x66402258, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402258>);
-	m_dsmap.SetAt(0x66a02218, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66a02218>);
-	m_dsmap.SetAt(0x6a90c238, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a90c238>);
-	m_dsmap.SetAt(0xa428e5c8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa428e5c8>);
-	m_dsmap.SetAt(0xa4402cb8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402cb8>);
-	m_dsmap.SetAt(0xa4803438, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4803438>);
-	m_dsmap.SetAt(0xa480d478, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d478>);
-	m_dsmap.SetAt(0xa480dc38, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480dc38>);
-	m_dsmap.SetAt(0xa480fc38, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480fc38>);
-	m_dsmap.SetAt(0xcff0c5e8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0c5e8>);
-	m_dsmap.SetAt(0xe4402c18, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4402c18>);
-	m_dsmap.SetAt(0xe4403468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403468>);
-	m_dsmap.SetAt(0xe440c5e8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440c5e8>);
-	m_dsmap.SetAt(0xe440cc18, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440cc18>);
-	m_dsmap.SetAt(0xe440d5f8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d5f8>);
-	m_dsmap.SetAt(0x0ff0c238, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff0c238>);
-	m_dsmap.SetAt(0x6440c218, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440c218>);
-	m_dsmap.SetAt(0x6640c218, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6640c218>);
-	m_dsmap.SetAt(0x8ff0d438, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff0d438>);
-	m_dsmap.SetAt(0xe4403c18, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403c18>);
-
-	// tokyo bus guide
-
-	m_dsmap.SetAt(0x2444f470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2444f470>);
-	m_dsmap.SetAt(0x4ff0e230, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0e230>);
-	m_dsmap.SetAt(0x4ff0e270, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0e270>);
-	m_dsmap.SetAt(0x4ff4f470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff4f470>);
-	m_dsmap.SetAt(0x6440e230, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e230>);
-	m_dsmap.SetAt(0x6440e270, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e270>);
-	m_dsmap.SetAt(0x64420210, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64420210>);
-	m_dsmap.SetAt(0x64453450, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64453450>);
-	m_dsmap.SetAt(0x8ff4d470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff4d470>);
-	m_dsmap.SetAt(0x8ff4f470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff4f470>);
-	m_dsmap.SetAt(0xa4411450, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411450>);
-	m_dsmap.SetAt(0xcff4d470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4d470>);
-	m_dsmap.SetAt(0xcff4f470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4f470>);
-	m_dsmap.SetAt(0xe440d470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d470>);
-	m_dsmap.SetAt(0xe440f430, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440f430>);
-	m_dsmap.SetAt(0xe440fc30, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440fc30>);
-	m_dsmap.SetAt(0xe444f470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444f470>);
-
-	// katamary damacy
-
-	m_dsmap.SetAt(0x24402c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402c05>);
-	m_dsmap.SetAt(0x2440ec04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440ec04>);
-	m_dsmap.SetAt(0x2440f805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440f805>);
-	m_dsmap.SetAt(0x2440f824, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440f824>);
-	m_dsmap.SetAt(0x24410204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410204>);
-	m_dsmap.SetAt(0x24410802, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410802>);
-	m_dsmap.SetAt(0x24410816, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24410816>);
-	m_dsmap.SetAt(0x24442264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24442264>);
-	m_dsmap.SetAt(0x6440e214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e214>);
-	m_dsmap.SetAt(0x6440e224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e224>);
-	m_dsmap.SetAt(0x6440ec24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440ec24>);
-	m_dsmap.SetAt(0x6442e214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6442e214>);
-	m_dsmap.SetAt(0x644a0214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x644a0214>);
-	m_dsmap.SetAt(0x6484f064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6484f064>);
-	m_dsmap.SetAt(0x6ff02214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff02214>);
-	m_dsmap.SetAt(0xa440ec24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440ec24>);
-	m_dsmap.SetAt(0xa44cf444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa44cf444>);
-	m_dsmap.SetAt(0xa480f464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480f464>);
-	m_dsmap.SetAt(0xe440ec14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440ec14>);
-	m_dsmap.SetAt(0xe440ec24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440ec24>);
-	m_dsmap.SetAt(0xe440f464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440f464>);
-	m_dsmap.SetAt(0xe444f464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe444f464>);
-	m_dsmap.SetAt(0xe480ec24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480ec24>);
-	m_dsmap.SetAt(0xe480f464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480f464>);
-	m_dsmap.SetAt(0xe484f464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe484f464>);
-	m_dsmap.SetAt(0xe810cc14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe810cc14>);
-
-	// kh2
-
-	m_dsmap.SetAt(0x0ff0dc05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff0dc05>);
-	m_dsmap.SetAt(0x2440dc00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440dc00>);
-	m_dsmap.SetAt(0x2480c274, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480c274>);
-	m_dsmap.SetAt(0x26403805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403805>);
-	m_dsmap.SetAt(0x26803805, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803805>);
-	m_dsmap.SetAt(0x4ff03894, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03894>);
-	m_dsmap.SetAt(0x64402814, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402814>);
-	m_dsmap.SetAt(0x6440c220, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440c220>);
-	m_dsmap.SetAt(0x6444d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444d464>);
-	m_dsmap.SetAt(0x64802214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64802214>);
-	m_dsmap.SetAt(0xa4402c45, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c45>);
-	m_dsmap.SetAt(0xa4447464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4447464>);
-	m_dsmap.SetAt(0xe2a4d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe2a4d464>);
-	m_dsmap.SetAt(0xe4803c54, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4803c54>);
-
-	// the punisher
-
-	m_dsmap.SetAt(0x2423d064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2423d064>);
-	m_dsmap.SetAt(0x2423d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2423d464>);
-	m_dsmap.SetAt(0x2443c204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2443c204>);
-	m_dsmap.SetAt(0x2443c206, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2443c206>);
-	m_dsmap.SetAt(0x2443dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2443dc24>);
-	m_dsmap.SetAt(0x2483dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2483dc24>);
-	m_dsmap.SetAt(0x2683c204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2683c204>);
-	m_dsmap.SetAt(0x2a83c246, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a83c246>);
-	m_dsmap.SetAt(0x6443d5e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6443d5e4>);
-	m_dsmap.SetAt(0x6a83d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a83d464>);
-	m_dsmap.SetAt(0x6a83d564, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6a83d564>);
-	m_dsmap.SetAt(0xa423d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa423d464>);
-	m_dsmap.SetAt(0xa443cc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa443cc04>);
-	m_dsmap.SetAt(0xa443d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa443d464>);
-	m_dsmap.SetAt(0xa443dc04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa443dc04>);
-	m_dsmap.SetAt(0xa443dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa443dc24>);
-	m_dsmap.SetAt(0xa483d444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa483d444>);
-	m_dsmap.SetAt(0xa483d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa483d464>);
-	m_dsmap.SetAt(0xa483dc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa483dc24>);
-	m_dsmap.SetAt(0xa683d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa683d464>);
-	m_dsmap.SetAt(0xe443d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe443d464>);
-	m_dsmap.SetAt(0xe443d564, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe443d564>);
-	m_dsmap.SetAt(0xea83d464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xea83d464>);
-	m_dsmap.SetAt(0xea83d564, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xea83d564>);
+	m_dsmap.SetAt(0x1fe04868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04868>);
+	m_dsmap.SetAt(0x1fe04878, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04878>);
+	m_dsmap.SetAt(0x1fe3004e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3004e>);
+	m_dsmap.SetAt(0x1fe39178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe39178>);
+	m_dsmap.SetAt(0x1fe6b168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe6b168>);
+	m_dsmap.SetAt(0x1fe6b968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe6b968>);
+	m_dsmap.SetAt(0x41268068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x41268068>);
+	m_dsmap.SetAt(0x41268868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x41268868>);
+	m_dsmap.SetAt(0x41269068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x41269068>);
+	m_dsmap.SetAt(0x485041cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x485041cc>);
+	m_dsmap.SetAt(0x485049cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x485049cc>);
+	m_dsmap.SetAt(0x4856b1cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4856b1cc>);
+	m_dsmap.SetAt(0x4856b9cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4856b9cc>);
+	m_dsmap.SetAt(0x48804158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804158>);
+	m_dsmap.SetAt(0x48804178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804178>);
+	m_dsmap.SetAt(0x48804978, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804978>);
+	m_dsmap.SetAt(0x4885814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885814c>);
+	m_dsmap.SetAt(0x48858158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858158>);
+	m_dsmap.SetAt(0x48859078, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48859078>);
+	m_dsmap.SetAt(0x4885914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885914c>);
+	m_dsmap.SetAt(0x48859158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48859158>);
+	m_dsmap.SetAt(0x48868168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868168>);
+	m_dsmap.SetAt(0x48868178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868178>);
+	m_dsmap.SetAt(0x48868968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868968>);
+	m_dsmap.SetAt(0x48868978, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868978>);
+	m_dsmap.SetAt(0x4886b168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886b168>);
+	m_dsmap.SetAt(0x4886b178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886b178>);
+	m_dsmap.SetAt(0x4886b968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886b968>);
+	m_dsmap.SetAt(0x4886b978, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886b978>);
+	m_dsmap.SetAt(0x48878158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878158>);
+	m_dsmap.SetAt(0x48879158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879158>);
+	m_dsmap.SetAt(0x49004178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004178>);
+	m_dsmap.SetAt(0x490041f8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490041f8>);
+	m_dsmap.SetAt(0x49004878, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004878>);
+	m_dsmap.SetAt(0x49004978, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004978>);
+	m_dsmap.SetAt(0x490049f8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490049f8>);
+	m_dsmap.SetAt(0x49068078, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068078>);
+	m_dsmap.SetAt(0x49068178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068178>);
+	m_dsmap.SetAt(0x49068978, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068978>);
+	m_dsmap.SetAt(0x49078078, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078078>);
+	m_dsmap.SetAt(0x49078178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078178>);
+	m_dsmap.SetAt(0x490781f8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490781f8>);
+	m_dsmap.SetAt(0x490789f8, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490789f8>);
+	m_dsmap.SetAt(0x49079178, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079178>);
+	m_dsmap.SetAt(0x4c80404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c80404c>);
+	m_dsmap.SetAt(0x4c804158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804158>);
+	m_dsmap.SetAt(0x4c80484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c80484c>);
+	m_dsmap.SetAt(0x4c85814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c85814c>);
+	m_dsmap.SetAt(0x4c85914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c85914c>);
+	m_dsmap.SetAt(0x4c859158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c859158>);
+	m_dsmap.SetAt(0x4c868068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c868068>);
+	m_dsmap.SetAt(0x4c868868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c868868>);
+	m_dsmap.SetAt(0x4d068168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068168>);
+	m_dsmap.SetAt(0x4d06b168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d06b168>);
+	m_dsmap.SetAt(0x4d06b968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d06b968>);
+	m_dsmap.SetAt(0x4d404058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d404058>);
 
 	// gt4
 
-	m_dsmap.SetAt(0x0ff02201, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02201>);
-	m_dsmap.SetAt(0x0ff02c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c05>);
-	m_dsmap.SetAt(0x0ff03c44, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c44>);
-	m_dsmap.SetAt(0x24402241, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402241>);
-	m_dsmap.SetAt(0x24402441, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402441>);
-	m_dsmap.SetAt(0x25803c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25803c04>);
-	m_dsmap.SetAt(0x25843464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25843464>);
-	m_dsmap.SetAt(0x258c3464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x258c3464>);
-	m_dsmap.SetAt(0x26402205, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402205>);
-	m_dsmap.SetAt(0x26402245, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26402245>);
-	m_dsmap.SetAt(0x26403c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403c05>);
-	m_dsmap.SetAt(0x2a902204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a902204>);
-	m_dsmap.SetAt(0x2ff02201, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff02201>);
-	m_dsmap.SetAt(0x2ff03446, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03446>);
-	m_dsmap.SetAt(0x2ff42264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff42264>);
-	m_dsmap.SetAt(0x6440ec14, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440ec14>);
-	m_dsmap.SetAt(0x64443464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64443464>);
-	m_dsmap.SetAt(0x8ff03c01, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff03c01>);
-	m_dsmap.SetAt(0x8ff03c44, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x8ff03c44>);
-	m_dsmap.SetAt(0xa4402445, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402445>);
-	m_dsmap.SetAt(0xa4403441, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403441>);
-	m_dsmap.SetAt(0xa440d445, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d445>);
-	m_dsmap.SetAt(0xa44435e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa44435e4>);
-	m_dsmap.SetAt(0xa5843464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa5843464>);
-	m_dsmap.SetAt(0xa6802c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6802c00>);
-	m_dsmap.SetAt(0xaff02c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff02c00>);
-	m_dsmap.SetAt(0xaff02c81, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff02c81>);
-	m_dsmap.SetAt(0xaff43464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff43464>);
-	m_dsmap.SetAt(0xcff4c464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4c464>);
-	m_dsmap.SetAt(0x24802244, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802244>);
-	m_dsmap.SetAt(0xa4403465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403465>);
-	m_dsmap.SetAt(0xa4442464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4442464>);
+	m_dsmap.SetAt(0x1fe0404e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0404e>);
+	m_dsmap.SetAt(0x1fe04064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04064>);
+	m_dsmap.SetAt(0x1fe1904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1904c>);
+	m_dsmap.SetAt(0x1fe1904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1904d>);
+	m_dsmap.SetAt(0x1fe3904e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3904e>);
+	m_dsmap.SetAt(0x1fe7804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe7804d>);
+	m_dsmap.SetAt(0x1fe7904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe7904c>);
+	m_dsmap.SetAt(0x1fe7904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe7904d>);
+	m_dsmap.SetAt(0x1fec8164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fec8164>);
+	m_dsmap.SetAt(0x1fec8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fec8964>);
+	m_dsmap.SetAt(0x1fec9164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fec9164>);
+	m_dsmap.SetAt(0x1fecb964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fecb964>);
+	m_dsmap.SetAt(0x1fee8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8064>);
+	m_dsmap.SetAt(0x1feeb964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1feeb964>);
+	m_dsmap.SetAt(0x488181d4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488181d4>);
+	m_dsmap.SetAt(0x488191d4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488191d4>);
+	m_dsmap.SetAt(0x4883804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883804d>);
+	m_dsmap.SetAt(0x4885804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885804d>);
+	m_dsmap.SetAt(0x4885904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885904d>);
+	m_dsmap.SetAt(0x4886884d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886884d>);
+	m_dsmap.SetAt(0x48878065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878065>);
+	m_dsmap.SetAt(0x48878865, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878865>);
+	m_dsmap.SetAt(0x488a8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8064>);
+	m_dsmap.SetAt(0x488a8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8864>);
+	m_dsmap.SetAt(0x488c8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488c8064>);
+	m_dsmap.SetAt(0x488c8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488c8864>);
+	m_dsmap.SetAt(0x488e804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e804c>);
+	m_dsmap.SetAt(0x488e8065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8065>);
+	m_dsmap.SetAt(0x488e8764, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8764>);
+	m_dsmap.SetAt(0x488e8865, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8865>);
+	m_dsmap.SetAt(0x488e8f64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8f64>);
+	m_dsmap.SetAt(0x488e9764, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9764>);
+	m_dsmap.SetAt(0x488eb064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488eb064>);
+	m_dsmap.SetAt(0x488eb864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488eb864>);
+	m_dsmap.SetAt(0x490e8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8064>);
+	m_dsmap.SetAt(0x490e8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8864>);
+	m_dsmap.SetAt(0x4b03804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b03804c>);
+	m_dsmap.SetAt(0x4b0a8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b0a8864>);
+	m_dsmap.SetAt(0x4b0e8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b0e8064>);
+	m_dsmap.SetAt(0x4b0e8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b0e8864>);
+	m_dsmap.SetAt(0x4b1a8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b1a8064>);
+	m_dsmap.SetAt(0x4b1a8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b1a8864>);
+	m_dsmap.SetAt(0x4c80484d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c80484d>);
+	m_dsmap.SetAt(0x4c81804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c81804c>);
+	m_dsmap.SetAt(0x4c81904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c81904c>);
+	m_dsmap.SetAt(0x4c81904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c81904d>);
+	m_dsmap.SetAt(0x4c83804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83804d>);
+	m_dsmap.SetAt(0x4c83904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83904c>);
+	m_dsmap.SetAt(0x4c83904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83904d>);
+	m_dsmap.SetAt(0x4c87904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c87904d>);
+	m_dsmap.SetAt(0x4d05804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d05804c>);
+	m_dsmap.SetAt(0x5520404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5520404c>);
+	m_dsmap.SetAt(0x5520410c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5520410c>);
+	m_dsmap.SetAt(0x5fe0404d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe0404d>);
+	m_dsmap.SetAt(0x5fe1904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe1904c>);
+	m_dsmap.SetAt(0x5fe1914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe1914c>);
+	m_dsmap.SetAt(0x5fe2884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe2884c>);
+	m_dsmap.SetAt(0x5fe2884e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe2884e>);
+	m_dsmap.SetAt(0x5fe3904e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe3904e>);
+	m_dsmap.SetAt(0x5fe5804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe5804c>);
+	m_dsmap.SetAt(0x5fe5904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe5904c>);
+	m_dsmap.SetAt(0x5fe5904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe5904d>);
+	m_dsmap.SetAt(0x5fee8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fee8064>);
+	m_dsmap.SetAt(0x5fee8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fee8864>);
+	m_dsmap.SetAt(0x5fee9064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fee9064>);
 
-	// ico
+	// katamary damacy
 
-	m_dsmap.SetAt(0x0ff03d00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03d00>);
-	m_dsmap.SetAt(0x0ff05c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff05c00>);
-	m_dsmap.SetAt(0x24402200, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402200>);
-	m_dsmap.SetAt(0x24403c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403c00>);
-	m_dsmap.SetAt(0x2448dc00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2448dc00>);
-	m_dsmap.SetAt(0x24802200, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802200>);
-	m_dsmap.SetAt(0x24802220, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24802220>);
-	m_dsmap.SetAt(0x26802200, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26802200>);
-	m_dsmap.SetAt(0x26802220, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26802220>);
-	m_dsmap.SetAt(0x26803c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803c00>);
-	m_dsmap.SetAt(0x4ff02220, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02220>);
-	m_dsmap.SetAt(0x64402210, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402210>);
-	m_dsmap.SetAt(0x64802260, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64802260>);
-	m_dsmap.SetAt(0xa4402c20, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c20>);
-	m_dsmap.SetAt(0xa4403c00, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403c00>);
-	m_dsmap.SetAt(0xa441dc20, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa441dc20>);
-	m_dsmap.SetAt(0xa481d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa481d460>);
-	m_dsmap.SetAt(0xa621d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa621d460>);
-	m_dsmap.SetAt(0xa681d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa681d460>);
-	m_dsmap.SetAt(0xcff1d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff1d460>);
-	m_dsmap.SetAt(0xe441d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441d460>);
-	m_dsmap.SetAt(0xe481d460, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe481d460>);
+	m_dsmap.SetAt(0x1fe04056, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04056>);
+	m_dsmap.SetAt(0x488041d4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488041d4>);
+	m_dsmap.SetAt(0x488041e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488041e4>);
+	m_dsmap.SetAt(0x48804864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804864>);
+	m_dsmap.SetAt(0x4881004e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881004e>);
+	m_dsmap.SetAt(0x4881804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881804d>);
+	m_dsmap.SetAt(0x488181cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488181cc>);
+	m_dsmap.SetAt(0x488181e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488181e4>);
+	m_dsmap.SetAt(0x4881904d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881904d>);
+	m_dsmap.SetAt(0x488301cd, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488301cd>);
+	m_dsmap.SetAt(0x488301e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488301e4>);
+	m_dsmap.SetAt(0x488581d4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488581d4>);
+	m_dsmap.SetAt(0x488581e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488581e4>);
+	m_dsmap.SetAt(0x488591d4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488591d4>);
+	m_dsmap.SetAt(0x488591e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488591e4>);
+	m_dsmap.SetAt(0x488681e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488681e4>);
+	m_dsmap.SetAt(0x488691e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488691e4>);
+	m_dsmap.SetAt(0x48884864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884864>);
+	m_dsmap.SetAt(0x488e81e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e81e4>);
+	m_dsmap.SetAt(0x488e89e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e89e4>);
+	m_dsmap.SetAt(0x488e9064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9064>);
+	m_dsmap.SetAt(0x488e91d4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e91d4>);
+	m_dsmap.SetAt(0x488e91e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e91e4>);
+	m_dsmap.SetAt(0x488f8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8064>);
+	m_dsmap.SetAt(0x488f81e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f81e4>);
+	m_dsmap.SetAt(0x488f9064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f9064>);
+	m_dsmap.SetAt(0x48904054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48904054>);
+	m_dsmap.SetAt(0x489e91cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x489e91cc>);
+	m_dsmap.SetAt(0x489f91cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x489f91cc>);
+	m_dsmap.SetAt(0x490581e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490581e4>);
+	m_dsmap.SetAt(0x490591e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490591e4>);
+	m_dsmap.SetAt(0x490681cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490681cc>);
+	m_dsmap.SetAt(0x490681e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490681e4>);
+	m_dsmap.SetAt(0x490689cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490689cc>);
+	m_dsmap.SetAt(0x490689e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490689e4>);
+	m_dsmap.SetAt(0x490691cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490691cc>);
+	m_dsmap.SetAt(0x490691e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490691e4>);
+	m_dsmap.SetAt(0x490781cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490781cc>);
+	m_dsmap.SetAt(0x490781e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490781e4>);
+	m_dsmap.SetAt(0x490791cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490791cc>);
+	m_dsmap.SetAt(0x490791e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490791e4>);
+	m_dsmap.SetAt(0x490a09e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490a09e4>);
+	m_dsmap.SetAt(0x490e81cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e81cc>);
+	m_dsmap.SetAt(0x490e81e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e81e4>);
+	m_dsmap.SetAt(0x490e89e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e89e4>);
+	m_dsmap.SetAt(0x490e91e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e91e4>);
+	m_dsmap.SetAt(0x50258154, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x50258154>);
+	m_dsmap.SetAt(0x502691e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x502691e4>);
+	m_dsmap.SetAt(0x502791e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x502791e4>);
+	m_dsmap.SetAt(0x5fe04054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe04054>);
 
-	// kuon
+	// grandia 3
 
-	m_dsmap.SetAt(0x0ff02202, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02202>);
-	m_dsmap.SetAt(0x24402202, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402202>);
-	m_dsmap.SetAt(0x24430215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24430215>);
-	m_dsmap.SetAt(0x26203465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26203465>);
-	m_dsmap.SetAt(0x2a403801, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a403801>);
-	m_dsmap.SetAt(0x2ff03801, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03801>);
-	m_dsmap.SetAt(0x2ff03c02, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff03c02>);
-	m_dsmap.SetAt(0x2ff31c05, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff31c05>);
-	m_dsmap.SetAt(0x66403c15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66403c15>);
-	m_dsmap.SetAt(0x66803815, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66803815>);
-	m_dsmap.SetAt(0x6ff02215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff02215>);
-	m_dsmap.SetAt(0xa4411c15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4411c15>);
-	m_dsmap.SetAt(0xa4431815, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4431815>);
-	m_dsmap.SetAt(0xa4831065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4831065>);
-	m_dsmap.SetAt(0xa4831455, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4831455>);
-	m_dsmap.SetAt(0xe445d065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445d065>);
-	m_dsmap.SetAt(0xe445d465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445d465>);
-	m_dsmap.SetAt(0xeff5d065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xeff5d065>);
+	m_dsmap.SetAt(0x41268060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x41268060>);
+	m_dsmap.SetAt(0x484e8860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x484e8860>);
+	m_dsmap.SetAt(0x48868360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868360>);
+	m_dsmap.SetAt(0x48868760, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868760>);
+	m_dsmap.SetAt(0x48868870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868870>);
+	m_dsmap.SetAt(0x48868b60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868b60>);
+	m_dsmap.SetAt(0x48868f60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868f60>);
+	m_dsmap.SetAt(0x48869760, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869760>);
+	m_dsmap.SetAt(0x48878760, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878760>);
+	m_dsmap.SetAt(0x48879760, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879760>);
+	m_dsmap.SetAt(0x488e8360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8360>);
+	m_dsmap.SetAt(0x488e8870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8870>);
+	m_dsmap.SetAt(0x488e8b60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8b60>);
+	m_dsmap.SetAt(0x488e8f60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8f60>);
+	m_dsmap.SetAt(0x488f8f60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8f60>);
+	m_dsmap.SetAt(0x48984070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48984070>);
+	m_dsmap.SetAt(0x49004060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004060>);
+	m_dsmap.SetAt(0x49004860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004860>);
+	m_dsmap.SetAt(0x4906804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4906804c>);
+	m_dsmap.SetAt(0x49068860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068860>);
+	m_dsmap.SetAt(0x49078060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078060>);
+	m_dsmap.SetAt(0x49078070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078070>);
+	m_dsmap.SetAt(0x49078860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078860>);
+	m_dsmap.SetAt(0x49078870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078870>);
+	m_dsmap.SetAt(0x49079060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079060>);
+	m_dsmap.SetAt(0x490e8860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8860>);
+	m_dsmap.SetAt(0x4c839060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c839060>);
+	m_dsmap.SetAt(0x50368060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x50368060>);
+	m_dsmap.SetAt(0x1fe0405a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0405a>);
+	m_dsmap.SetAt(0x48868070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868070>);
+	m_dsmap.SetAt(0x48869070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869070>);
+	m_dsmap.SetAt(0x48869360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869360>);
+	m_dsmap.SetAt(0x48884060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884060>);
+	m_dsmap.SetAt(0x48884760, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884760>);
+	m_dsmap.SetAt(0x488a8060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8060>);
+	m_dsmap.SetAt(0x488e8760, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8760>);
+	m_dsmap.SetAt(0x488e9360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9360>);
+	m_dsmap.SetAt(0x490e8060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8060>);
+	m_dsmap.SetAt(0x4c83964c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83964c>);
+	m_dsmap.SetAt(0x4c839660, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c839660>);
 
-	// guitar hero
+	// rumble roses
 
-	m_dsmap.SetAt(0x0ff038aa, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff038aa>);
-	m_dsmap.SetAt(0x2442c24a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2442c24a>);
-	m_dsmap.SetAt(0x2442c26a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2442c26a>);
-	m_dsmap.SetAt(0x2442d44a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2442d44a>);
-	m_dsmap.SetAt(0x2480226a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480226a>);
-	m_dsmap.SetAt(0x2680224a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2680224a>);
-	m_dsmap.SetAt(0x2680226a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2680226a>);
-	m_dsmap.SetAt(0x2680390a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2680390a>);
-	m_dsmap.SetAt(0x2a80390a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2a80390a>);
-	m_dsmap.SetAt(0x4ff03c9a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03c9a>);
-	m_dsmap.SetAt(0x6442c27a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6442c27a>);
-	m_dsmap.SetAt(0x6444d47a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6444d47a>);
-	m_dsmap.SetAt(0x6446c27a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6446c27a>);
-	m_dsmap.SetAt(0xa440d46a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d46a>);
-	m_dsmap.SetAt(0xa442d44a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa442d44a>);
-	m_dsmap.SetAt(0xa442d46a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa442d46a>);
-	m_dsmap.SetAt(0xa446d46a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa446d46a>);
-	m_dsmap.SetAt(0xa480344a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480344a>);
-	m_dsmap.SetAt(0xa480346a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480346a>);
-	m_dsmap.SetAt(0xa48034ea, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa48034ea>);
-	m_dsmap.SetAt(0xa480d46a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d46a>);
-	m_dsmap.SetAt(0xa680344a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa680344a>);
-	m_dsmap.SetAt(0xa68034ea, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa68034ea>);
-	m_dsmap.SetAt(0xa680356a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa680356a>);
-	m_dsmap.SetAt(0xa6803c2a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa6803c2a>);
-	m_dsmap.SetAt(0xa680d44a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa680d44a>);
-	m_dsmap.SetAt(0xa684356a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa684356a>);
-	m_dsmap.SetAt(0xcff0347a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0347a>);
-	m_dsmap.SetAt(0xcff034ea, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff034ea>);
-	m_dsmap.SetAt(0xcff034fa, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff034fa>);
-	m_dsmap.SetAt(0xcff0d47a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0d47a>);
-	m_dsmap.SetAt(0xe440d45a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440d45a>);
-	m_dsmap.SetAt(0xe442d45a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe442d45a>);
-	m_dsmap.SetAt(0xe442d46a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe442d46a>);
-	m_dsmap.SetAt(0xe442d47a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe442d47a>);
-	m_dsmap.SetAt(0xe446d47a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe446d47a>);
-	m_dsmap.SetAt(0xe480345a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe480345a>);
+	m_dsmap.SetAt(0x1fe78164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78164>);
+	m_dsmap.SetAt(0x1fe79164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe79164>);
+	m_dsmap.SetAt(0x48804164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804164>);
+	m_dsmap.SetAt(0x48804964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804964>);
+	m_dsmap.SetAt(0x48838164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838164>);
+	m_dsmap.SetAt(0x48868964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868964>);
+	m_dsmap.SetAt(0x4886b964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886b964>);
+	m_dsmap.SetAt(0x48878164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878164>);
+	m_dsmap.SetAt(0x48878964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878964>);
+	m_dsmap.SetAt(0x4887b164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887b164>);
+	m_dsmap.SetAt(0x4887b964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887b964>);
+	m_dsmap.SetAt(0x4887bf64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887bf64>);
+	m_dsmap.SetAt(0x488a0064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a0064>);
+	m_dsmap.SetAt(0x488e0b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e0b64>);
+	m_dsmap.SetAt(0x490e804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e804c>);
+	m_dsmap.SetAt(0x4c48484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c48484c>);
+	m_dsmap.SetAt(0x4c830164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c830164>);
+	m_dsmap.SetAt(0x4c8a0064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8a0064>);
+	m_dsmap.SetAt(0x4c8e0b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8e0b64>);
+	m_dsmap.SetAt(0x4c8e8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8e8864>);
+	m_dsmap.SetAt(0x4c8e8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8e8964>);
+	m_dsmap.SetAt(0x4c8e8b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8e8b64>);
+	m_dsmap.SetAt(0x55384874, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x55384874>);
 
-	// virtual tennis 2
-
-	m_dsmap.SetAt(0x0ff10215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff10215>);
-	m_dsmap.SetAt(0x24231065, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24231065>);
-	m_dsmap.SetAt(0x28830215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x28830215>);
-	m_dsmap.SetAt(0x2aa30215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2aa30215>);
-	m_dsmap.SetAt(0x4ff0e265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff0e265>);
-	m_dsmap.SetAt(0x4ff20215, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff20215>);
-	m_dsmap.SetAt(0x6440e265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6440e265>);
-	m_dsmap.SetAt(0x6480e265, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6480e265>);
-	m_dsmap.SetAt(0x66402c15, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402c15>);
-	m_dsmap.SetAt(0xa680f445, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa680f445>);
-	m_dsmap.SetAt(0xcff0f475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0f475>);
-	m_dsmap.SetAt(0xe440ec65, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440ec65>);
-	m_dsmap.SetAt(0xe440ede5, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440ede5>);
-	m_dsmap.SetAt(0xe440f465, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440f465>);
-	m_dsmap.SetAt(0xe440f475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440f475>);
-	m_dsmap.SetAt(0xe640f475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe640f475>);
-	m_dsmap.SetAt(0xe680f475, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe680f475>);
-
-	// bios
-
-	m_dsmap.SetAt(0x0ff03404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03404>);
-	m_dsmap.SetAt(0x0ff03c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff03c24>);
-	m_dsmap.SetAt(0x24403c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403c24>);
-	m_dsmap.SetAt(0x24803404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24803404>);
-	m_dsmap.SetAt(0x24803444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24803444>);
-	m_dsmap.SetAt(0x25803404, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25803404>);
-	m_dsmap.SetAt(0x26202204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26202204>);
-	m_dsmap.SetAt(0x26403c04, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26403c04>);
-	m_dsmap.SetAt(0x26803464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26803464>);
-	m_dsmap.SetAt(0x4ff02230, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02230>);
-	m_dsmap.SetAt(0x4ff02250, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02250>);
-	m_dsmap.SetAt(0x4ff02260, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02260>);
-	m_dsmap.SetAt(0x4ff03020, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03020>);
-	m_dsmap.SetAt(0x4ff03060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03060>);
-	m_dsmap.SetAt(0x4ff03464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03464>);
-	m_dsmap.SetAt(0x4ff03470, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03470>);
-	m_dsmap.SetAt(0x4ff03c10, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03c10>);
-	m_dsmap.SetAt(0x4ff03c20, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03c20>);
-	m_dsmap.SetAt(0x4ff03c30, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff03c30>);
-	m_dsmap.SetAt(0x60002060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x60002060>);
-	m_dsmap.SetAt(0x64203410, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64203410>);
-	m_dsmap.SetAt(0x64203420, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64203420>);
-	m_dsmap.SetAt(0x64402260, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402260>);
-	m_dsmap.SetAt(0x64403c10, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64403c10>);
-	m_dsmap.SetAt(0x64803420, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64803420>);
-	m_dsmap.SetAt(0x64803c10, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64803c10>);
-	m_dsmap.SetAt(0x66202c10, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66202c10>);
-	m_dsmap.SetAt(0x66402210, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402210>);
-	m_dsmap.SetAt(0x66402250, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66402250>);
-	m_dsmap.SetAt(0x66802c10, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66802c10>);
-	m_dsmap.SetAt(0xe440dc10, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe440dc10>);
-
-	// one piece grand battle 3
-
-	m_dsmap.SetAt(0x0ff02c86, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff02c86>);
-	m_dsmap.SetAt(0x2440c264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c264>);
-	m_dsmap.SetAt(0x25602204, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25602204>);
-	m_dsmap.SetAt(0x26202c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26202c84>);
-	m_dsmap.SetAt(0x26204c84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26204c84>);
-	m_dsmap.SetAt(0x2990cc84, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2990cc84>);
-	m_dsmap.SetAt(0x64402254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402254>);
-	m_dsmap.SetAt(0x64403454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64403454>);
-	m_dsmap.SetAt(0x64482254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64482254>);
-	m_dsmap.SetAt(0x65402254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x65402254>);
-	m_dsmap.SetAt(0x66220214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x66220214>);
-	m_dsmap.SetAt(0x6ff02254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6ff02254>);
-	m_dsmap.SetAt(0xa4403444, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403444>);
-	m_dsmap.SetAt(0xe0a03464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe0a03464>);
-	m_dsmap.SetAt(0xe4403454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4403454>);
-	m_dsmap.SetAt(0xe4483454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4483454>);
-	m_dsmap.SetAt(0xe4803454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4803454>);
-	m_dsmap.SetAt(0xeff03454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xeff03454>);
-
-	// mana khemia
-
-	m_dsmap.SetAt(0x24402209, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402209>);
-	m_dsmap.SetAt(0x24402c09, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24402c09>);
-	m_dsmap.SetAt(0x24403c02, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403c02>);
-	m_dsmap.SetAt(0x4ff02219, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff02219>);
-	m_dsmap.SetAt(0x64402c19, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64402c19>);
-	m_dsmap.SetAt(0x64403c29, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64403c29>);
-	m_dsmap.SetAt(0xa4402c09, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4402c09>);
-	m_dsmap.SetAt(0xa4403c09, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4403c09>);
-	m_dsmap.SetAt(0xa4442c09, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4442c09>);
-	m_dsmap.SetAt(0xe445b469, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445b469>);
-	m_dsmap.SetAt(0xe445bc29, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe445bc29>);
-
-	// enthusai
-
-	m_dsmap.SetAt(0x0ff11894, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x0ff11894>);
-	m_dsmap.SetAt(0x24403801, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24403801>);
-	m_dsmap.SetAt(0x24430224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24430224>);
-	m_dsmap.SetAt(0x24831064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x24831064>);
-	m_dsmap.SetAt(0x25831064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x25831064>);
-	m_dsmap.SetAt(0x258b1064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x258b1064>);
-	m_dsmap.SetAt(0x26a10214, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x26a10214>);
-	m_dsmap.SetAt(0x2ff31098, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff31098>);
-	m_dsmap.SetAt(0x4ff42224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4ff42224>);
-	m_dsmap.SetAt(0x6441a224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6441a224>);
-	m_dsmap.SetAt(0x6441a264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x6441a264>);
-	m_dsmap.SetAt(0x64434224, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64434224>);
-	m_dsmap.SetAt(0x64434264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x64434264>);
-	m_dsmap.SetAt(0xa4430c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4430c24>);
-	m_dsmap.SetAt(0xa4471064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4471064>);
-	m_dsmap.SetAt(0xa4471464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4471464>);
-	m_dsmap.SetAt(0xa4831064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4831064>);
-	m_dsmap.SetAt(0xa5231454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa5231454>);
-	m_dsmap.SetAt(0xa5831064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa5831064>);
-	m_dsmap.SetAt(0xa5831454, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa5831454>);
-	m_dsmap.SetAt(0xcff02468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff02468>);
-	m_dsmap.SetAt(0xcff0a068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff0a068>);
-	m_dsmap.SetAt(0xcff1bc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff1bc24>);
-	m_dsmap.SetAt(0xcff42468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff42468>);
-	m_dsmap.SetAt(0xcff4a068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4a068>);
-	m_dsmap.SetAt(0xcff4b064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4b064>);
-	m_dsmap.SetAt(0xe441bc24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441bc24>);
-	m_dsmap.SetAt(0xe4434c24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe4434c24>);
-	m_dsmap.SetAt(0xe443a468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe443a468>);
-	m_dsmap.SetAt(0xe443b064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe443b064>);
-	m_dsmap.SetAt(0xe447b064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe447b064>);
-	m_dsmap.SetAt(0xe447b464, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe447b464>);
-
-	// ar tonelico
-
-	m_dsmap.SetAt(0xa4802c09, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa4802c09>);
-	m_dsmap.SetAt(0xa485bc29, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa485bc29>);
-	m_dsmap.SetAt(0xe441bc29, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xe441bc29>);
-
-	// gradius 5
-
-	m_dsmap.SetAt(0x2440c248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c248>);
-	m_dsmap.SetAt(0x2440c448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2440c448>);
-	m_dsmap.SetAt(0x2480c268, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2480c268>);
-	m_dsmap.SetAt(0x2ff0c248, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff0c248>);
-	m_dsmap.SetAt(0x2ff0d448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x2ff0d448>);
-	m_dsmap.SetAt(0xa440c448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440c448>);
-	m_dsmap.SetAt(0xa440d448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d448>);
-	m_dsmap.SetAt(0xa440d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa440d468>);
-	m_dsmap.SetAt(0xa480d448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d448>);
-	m_dsmap.SetAt(0xa480d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xa480d468>);
-	m_dsmap.SetAt(0xaff0c448, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff0c448>);
-	m_dsmap.SetAt(0xaff0d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xaff0d468>);
-	m_dsmap.SetAt(0xcff4d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xcff4d468>);
-	m_dsmap.SetAt(0xeff0d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xeff0d468>);
-	m_dsmap.SetAt(0xeff4d468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xeff4d468>);
-	m_dsmap.SetAt(0xeffcd468, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0xeffcd468>);
-
-	#endif
-/*
 	// dmc (fixme)
 
-	// mgs3s1
+	m_dsmap.SetAt(0x1fe0424c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe0424c>);
+	m_dsmap.SetAt(0x1fe39058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe39058>);
+	m_dsmap.SetAt(0x1fe59068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe59068>);
+	m_dsmap.SetAt(0x1fe68968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68968>);
+	m_dsmap.SetAt(0x1fe78068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78068>);
+	m_dsmap.SetAt(0x1fe7814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe7814c>);
+	m_dsmap.SetAt(0x1fe78158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78158>);
+	m_dsmap.SetAt(0x1fea8968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fea8968>);
+	m_dsmap.SetAt(0x1fee8168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8168>);
+	m_dsmap.SetAt(0x1fee8968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8968>);
+	m_dsmap.SetAt(0x1fee8978, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee8978>);
+	m_dsmap.SetAt(0x45204078, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x45204078>);
+	m_dsmap.SetAt(0x4520424c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4520424c>);
+	m_dsmap.SetAt(0x48804078, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804078>);
+	m_dsmap.SetAt(0x48810068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48810068>);
+	m_dsmap.SetAt(0x48830068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830068>);
+	m_dsmap.SetAt(0x48878058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878058>);
+	m_dsmap.SetAt(0x48878168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878168>);
+	m_dsmap.SetAt(0x488e8968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8968>);
+	m_dsmap.SetAt(0x49068168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068168>);
+	m_dsmap.SetAt(0x49078168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078168>);
+	m_dsmap.SetAt(0x490e8168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8168>);
+	m_dsmap.SetAt(0x490e8968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8968>);
+	m_dsmap.SetAt(0x4c43804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c43804c>);
+	m_dsmap.SetAt(0x4c839068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c839068>);
+	m_dsmap.SetAt(0x4d068968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068968>);
+	m_dsmap.SetAt(0x4d0e8968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d0e8968>);
+	m_dsmap.SetAt(0x54204078, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x54204078>);
+	m_dsmap.SetAt(0x5420424c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5420424c>);
+	m_dsmap.SetAt(0x5fe30868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe30868>);
+
+	// xenosaga 2
+
+	m_dsmap.SetAt(0x1fe04067, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04067>);
+	m_dsmap.SetAt(0x1fe18054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe18054>);
+	m_dsmap.SetAt(0x1fe58174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe58174>);
+	m_dsmap.SetAt(0x1fe68064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68064>);
+	m_dsmap.SetAt(0x1fe68864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68864>);
+	m_dsmap.SetAt(0x1fe78174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78174>);
+	m_dsmap.SetAt(0x1fe8404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe8404c>);
+	m_dsmap.SetAt(0x1fe84064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84064>);
+	m_dsmap.SetAt(0x1fe84864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe84864>);
+	m_dsmap.SetAt(0x1fea8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fea8864>);
+	m_dsmap.SetAt(0x1fea8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fea8964>);
+	m_dsmap.SetAt(0x1fee804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee804c>);
+	m_dsmap.SetAt(0x1fee884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee884c>);
+	m_dsmap.SetAt(0x1fee9064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fee9064>);
+	m_dsmap.SetAt(0x48468864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468864>);
+	m_dsmap.SetAt(0x48804074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804074>);
+	m_dsmap.SetAt(0x48839054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48839054>);
+	m_dsmap.SetAt(0x48868164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868164>);
+	m_dsmap.SetAt(0x488688e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488688e4>);
+	m_dsmap.SetAt(0x488a88e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a88e4>);
+	m_dsmap.SetAt(0x4901004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4901004c>);
+	m_dsmap.SetAt(0x4905904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4905904c>);
+	m_dsmap.SetAt(0x49068164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068164>);
+	m_dsmap.SetAt(0x49069064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49069064>);
+	m_dsmap.SetAt(0x49078164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078164>);
+	m_dsmap.SetAt(0x49079164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079164>);
+	m_dsmap.SetAt(0x4946824c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4946824c>);
+	m_dsmap.SetAt(0x4947824c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4947824c>);
+	m_dsmap.SetAt(0x4a478164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a478164>);
+	m_dsmap.SetAt(0x4a878164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a878164>);
+	m_dsmap.SetAt(0x4b078164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b078164>);
+	m_dsmap.SetAt(0x4c404054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c404054>);
+	m_dsmap.SetAt(0x4c804054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804054>);
+	m_dsmap.SetAt(0x4c839054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c839054>);
+	m_dsmap.SetAt(0x4d004054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d004054>);
+	m_dsmap.SetAt(0x4d004064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d004064>);
+	m_dsmap.SetAt(0x4d03804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d03804c>);
+	m_dsmap.SetAt(0x4d039054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d039054>);
+	m_dsmap.SetAt(0x4d068064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068064>);
+	m_dsmap.SetAt(0x4d068864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068864>);
+	m_dsmap.SetAt(0x4d069064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d069064>);
+	m_dsmap.SetAt(0x51229064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51229064>);
 
 	// nfs mw
 
+	m_dsmap.SetAt(0x1fe68168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68168>);
+	m_dsmap.SetAt(0x1fe6816a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe6816a>);
+	m_dsmap.SetAt(0x1fe6894e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe6894e>);
+	m_dsmap.SetAt(0x1fe6896a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe6896a>);
+	m_dsmap.SetAt(0x1fe78168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78168>);
+	m_dsmap.SetAt(0x4805904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4805904c>);
+	m_dsmap.SetAt(0x4882814e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4882814e>);
+	m_dsmap.SetAt(0x4883814e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883814e>);
+	m_dsmap.SetAt(0x48838168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838168>);
+	m_dsmap.SetAt(0x48838968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838968>);
+	m_dsmap.SetAt(0x4886816a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886816a>);
+	m_dsmap.SetAt(0x4886896a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886896a>);
+	m_dsmap.SetAt(0x48869164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869164>);
+	m_dsmap.SetAt(0x48878968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878968>);
+	m_dsmap.SetAt(0x4906816a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4906816a>);
+	m_dsmap.SetAt(0x49068964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068964>);
+	m_dsmap.SetAt(0x49068968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068968>);
+	m_dsmap.SetAt(0x4906896a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4906896a>);
+	m_dsmap.SetAt(0x4907816a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907816a>);
+	m_dsmap.SetAt(0x49078964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078964>);
+	m_dsmap.SetAt(0x49078968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078968>);
+	m_dsmap.SetAt(0x4927904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4927904c>);
+	m_dsmap.SetAt(0x4a838164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a838164>);
+	m_dsmap.SetAt(0x4a838964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a838964>);
+	m_dsmap.SetAt(0x4a83904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a83904c>);
+	m_dsmap.SetAt(0x4b004064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b004064>);
+	m_dsmap.SetAt(0x4b004068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b004068>);
+	m_dsmap.SetAt(0x4b004864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b004864>);
+	m_dsmap.SetAt(0x4b004868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b004868>);
+	m_dsmap.SetAt(0x4b028064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b028064>);
+	m_dsmap.SetAt(0x4b028068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b028068>);
+	m_dsmap.SetAt(0x4b028864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b028864>);
+	m_dsmap.SetAt(0x4b028868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b028868>);
+	m_dsmap.SetAt(0x4b038164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b038164>);
+	m_dsmap.SetAt(0x4b038964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b038964>);
+	m_dsmap.SetAt(0x4c83004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83004c>);
+	m_dsmap.SetAt(0x4c83804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83804c>);
+	m_dsmap.SetAt(0x4c83804e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83804e>);
+	m_dsmap.SetAt(0x4d03904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d03904c>);
+	m_dsmap.SetAt(0x4d03914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d03914c>);
+	m_dsmap.SetAt(0x5127904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5127904c>);
+	m_dsmap.SetAt(0x5420404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5420404c>);
+	m_dsmap.SetAt(0x5420404d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5420404d>);
+	m_dsmap.SetAt(0x5420404e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5420404e>);
+	m_dsmap.SetAt(0x5fe1904e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe1904e>);
+	m_dsmap.SetAt(0x5fe19064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe19064>);
+	m_dsmap.SetAt(0x5fe78064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe78064>);
+
+	// berserk
+
+	m_dsmap.SetAt(0x48804165, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804165>);
+	m_dsmap.SetAt(0x4883104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883104c>);
+	m_dsmap.SetAt(0x4887804f, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887804f>);
+	m_dsmap.SetAt(0x49004874, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004874>);
+	m_dsmap.SetAt(0x49078864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078864>);
+	m_dsmap.SetAt(0x4c8eb964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8eb964>);
+	m_dsmap.SetAt(0x4c8fb164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8fb164>);
+	m_dsmap.SetAt(0x4c8fb964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8fb964>);
+
+	// castlevania
+
+	m_dsmap.SetAt(0x1fe1004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1004c>);
+	m_dsmap.SetAt(0x1fe3104e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3104e>);
+	m_dsmap.SetAt(0x1fe5904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe5904c>);
+	m_dsmap.SetAt(0x1fe78868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe78868>);
+	m_dsmap.SetAt(0x48878868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878868>);
+	m_dsmap.SetAt(0x488c8968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488c8968>);
+	m_dsmap.SetAt(0x488eb168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488eb168>);
+	m_dsmap.SetAt(0x488eb968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488eb968>);
+	m_dsmap.SetAt(0x488f8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8068>);
+	m_dsmap.SetAt(0x490e9068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e9068>);
+	m_dsmap.SetAt(0x4d00407a, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d00407a>);
+
+	// okami
+
+	m_dsmap.SetAt(0x1fe18058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe18058>);
+	m_dsmap.SetAt(0x45218058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x45218058>);
+	m_dsmap.SetAt(0x4881804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881804c>);
+	m_dsmap.SetAt(0x48838868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838868>);
+	m_dsmap.SetAt(0x48839158, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48839158>);
+	m_dsmap.SetAt(0x48879058, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879058>);
+	m_dsmap.SetAt(0x48879068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879068>);
+	m_dsmap.SetAt(0x48884168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884168>);
+	m_dsmap.SetAt(0x48884968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884968>);
+	m_dsmap.SetAt(0x488f8168, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8168>);
+	m_dsmap.SetAt(0x488f8968, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8968>);
+	m_dsmap.SetAt(0x4a83804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a83804c>);
+	m_dsmap.SetAt(0x4c43904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c43904c>);
+	m_dsmap.SetAt(0x4c83104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83104c>);
+	m_dsmap.SetAt(0x4d03104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d03104c>);
+	m_dsmap.SetAt(0x5fe59068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe59068>);
+	m_dsmap.SetAt(0x5fe7104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe7104c>);
+	m_dsmap.SetAt(0x5fe7904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe7904c>);
+
+	// bully
+
+	m_dsmap.SetAt(0x1fe04077, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04077>);
+	m_dsmap.SetAt(0x1fe04864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04864>);
+	m_dsmap.SetAt(0x488e8a64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8a64>);
+	m_dsmap.SetAt(0x49404054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49404054>);
+	m_dsmap.SetAt(0x494e8a64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x494e8a64>);
+	m_dsmap.SetAt(0x4c20404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c20404c>);
+	m_dsmap.SetAt(0x4d068364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068364>);
+	m_dsmap.SetAt(0x4d068b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068b64>);
+	m_dsmap.SetAt(0x4d07834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d07834c>);
+	m_dsmap.SetAt(0x4d078364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d078364>);
+	m_dsmap.SetAt(0x4d078b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d078b64>);
+	m_dsmap.SetAt(0x510e8164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x510e8164>);
+	m_dsmap.SetAt(0x510e8964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x510e8964>);
+	m_dsmap.SetAt(0x5480404d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5480404d>);
+	m_dsmap.SetAt(0x5501904e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5501904e>);
+	m_dsmap.SetAt(0x5fe3104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe3104c>);
+
+	// culdcept
+
+	m_dsmap.SetAt(0x1fe041e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe041e6>);
+	m_dsmap.SetAt(0x1fe049e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe049e6>);
+	m_dsmap.SetAt(0x1fe181e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe181e6>);
+	m_dsmap.SetAt(0x1fe191e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe191e6>);
+	m_dsmap.SetAt(0x1fe2a1e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe2a1e6>);
+	m_dsmap.SetAt(0x1fe2a9e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe2a9e6>);
+	m_dsmap.SetAt(0x1fe3104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3104c>);
+	m_dsmap.SetAt(0x1fe31066, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe31066>);
+	m_dsmap.SetAt(0x1fe381e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe381e6>);
+	m_dsmap.SetAt(0x1fe391e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe391e6>);
+	m_dsmap.SetAt(0x1fe3a1e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3a1e6>);
+	m_dsmap.SetAt(0x1fe3a9e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3a9e6>);
+	m_dsmap.SetAt(0x1fe581e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe581e6>);
+	m_dsmap.SetAt(0x1fe591e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe591e6>);
+	m_dsmap.SetAt(0x1fe781e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe781e6>);
+	m_dsmap.SetAt(0x1fe791e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe791e6>);
+	m_dsmap.SetAt(0x1fe991e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe991e6>);
+	m_dsmap.SetAt(0x1feaa1e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1feaa1e6>);
+	m_dsmap.SetAt(0x1feaa9e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1feaa9e6>);
+	m_dsmap.SetAt(0x1feba1e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1feba1e6>);
+	m_dsmap.SetAt(0x1fef81e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fef81e6>);
+	m_dsmap.SetAt(0x488049e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488049e6>);
+	m_dsmap.SetAt(0x488089e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488089e6>);
+	m_dsmap.SetAt(0x488181e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488181e6>);
+	m_dsmap.SetAt(0x488191e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488191e6>);
+	m_dsmap.SetAt(0x488281e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488281e6>);
+	m_dsmap.SetAt(0x488291e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488291e6>);
+	m_dsmap.SetAt(0x488381e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488381e6>);
+	m_dsmap.SetAt(0x488391e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488391e6>);
+	m_dsmap.SetAt(0x488581e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488581e6>);
+	m_dsmap.SetAt(0x490049e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490049e6>);
+	m_dsmap.SetAt(0x4d0049e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d0049e6>);
+	m_dsmap.SetAt(0x4d02a1e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d02a1e6>);
+	m_dsmap.SetAt(0x4d02a9e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d02a9e6>);
+	m_dsmap.SetAt(0x4d0381e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d0381e6>);
+	m_dsmap.SetAt(0x4d0391e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d0391e6>);
+	m_dsmap.SetAt(0x5422a1e6, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5422a1e6>);
+
+	// suikoden 5
+
+	m_dsmap.SetAt(0x1fe3934c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3934c>);
+	m_dsmap.SetAt(0x40428068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x40428068>);
+	m_dsmap.SetAt(0x40428868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x40428868>);
+	m_dsmap.SetAt(0x404a8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x404a8068>);
+	m_dsmap.SetAt(0x404a8868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x404a8868>);
+	m_dsmap.SetAt(0x4846834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4846834c>);
+	m_dsmap.SetAt(0x4847834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4847834c>);
+	m_dsmap.SetAt(0x48829368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48829368>);
+	m_dsmap.SetAt(0x4883834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883834c>);
+	m_dsmap.SetAt(0x48838368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838368>);
+	m_dsmap.SetAt(0x4883934c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4883934c>);
+	m_dsmap.SetAt(0x488a8368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8368>);
+	m_dsmap.SetAt(0x488a8b68, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8b68>);
+	m_dsmap.SetAt(0x488a9368, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a9368>);
+	m_dsmap.SetAt(0x49028068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49028068>);
+	m_dsmap.SetAt(0x49028868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49028868>);
+	m_dsmap.SetAt(0x4906834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4906834c>);
+	m_dsmap.SetAt(0x4907834c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907834c>);
+	m_dsmap.SetAt(0x490a8068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490a8068>);
+	m_dsmap.SetAt(0x490a8868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490a8868>);
+	m_dsmap.SetAt(0x4d068068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068068>);
+	m_dsmap.SetAt(0x4d068868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d068868>);
+
+	// dq8
+
+	m_dsmap.SetAt(0x1fe3914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3914c>);
+	m_dsmap.SetAt(0x48404164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404164>);
+	m_dsmap.SetAt(0x488b0164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488b0164>);
+	m_dsmap.SetAt(0x488b0964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488b0964>);
+	m_dsmap.SetAt(0x48c3804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c3804c>);
+	m_dsmap.SetAt(0x49004164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004164>);
+	m_dsmap.SetAt(0x4c83914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c83914c>);
+	m_dsmap.SetAt(0x5103804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5103804c>);
+	m_dsmap.SetAt(0x5103b04c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5103b04c>);
+	m_dsmap.SetAt(0x1fe7804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe7804c>);
+	m_dsmap.SetAt(0x48884164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884164>);
+	m_dsmap.SetAt(0x48884964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884964>);
+	m_dsmap.SetAt(0x490e914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e914c>);
+	m_dsmap.SetAt(0x490f914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490f914c>);
+
+	// resident evil 4
+
+	m_dsmap.SetAt(0x1fe18064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe18064>);
+	m_dsmap.SetAt(0x4886894c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4886894c>);
+	m_dsmap.SetAt(0x49004b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004b64>);
+	m_dsmap.SetAt(0x4903904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4903904c>);
+	m_dsmap.SetAt(0x4b068164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b068164>);
+	m_dsmap.SetAt(0x4c804164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c804164>);
+	m_dsmap.SetAt(0x4c828964, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c828964>);
+	m_dsmap.SetAt(0x4c879164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c879164>);
+	m_dsmap.SetAt(0x4d07814c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d07814c>);
+	m_dsmap.SetAt(0x5120404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5120404c>);
+	m_dsmap.SetAt(0x5483904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5483904c>);
+
+	// tomoyo after 
+
+	m_dsmap.SetAt(0x1fe38059, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe38059>);
+	m_dsmap.SetAt(0x1fe39059, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe39059>);
+	m_dsmap.SetAt(0x48404868, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404868>);
+	m_dsmap.SetAt(0x48478068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478068>);
+	m_dsmap.SetAt(0x48818068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48818068>);
+	m_dsmap.SetAt(0x48858068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858068>);
+	m_dsmap.SetAt(0x49058068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49058068>);
+	m_dsmap.SetAt(0x4a858068, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a858068>);
+
+	// .hack redemption
+
+	m_dsmap.SetAt(0x1fe04b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04b64>);
+	m_dsmap.SetAt(0x1fe1804d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1804d>);
+	m_dsmap.SetAt(0x1fe1914c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1914c>);
+	m_dsmap.SetAt(0x4123004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4123004c>);
+	m_dsmap.SetAt(0x48404074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404074>);
+	m_dsmap.SetAt(0x48468064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468064>);
+	m_dsmap.SetAt(0x48469064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48469064>);
+	m_dsmap.SetAt(0x48478064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478064>);
+	m_dsmap.SetAt(0x48478864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478864>);
+	m_dsmap.SetAt(0x48830064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48830064>);
+	m_dsmap.SetAt(0x48848064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48848064>);
+	m_dsmap.SetAt(0x48858064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858064>);
+	m_dsmap.SetAt(0x48859064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48859064>);
+	m_dsmap.SetAt(0x48869364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48869364>);
+	m_dsmap.SetAt(0x48878b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878b64>);
+	m_dsmap.SetAt(0x48879364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879364>);
+	m_dsmap.SetAt(0x488a8b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8b64>);
+	m_dsmap.SetAt(0x488e9364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e9364>);
+	m_dsmap.SetAt(0x488f8364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8364>);
+	m_dsmap.SetAt(0x488f9364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f9364>);
+	m_dsmap.SetAt(0x49004074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004074>);
+	m_dsmap.SetAt(0x49079064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079064>);
+	m_dsmap.SetAt(0x4c41804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c41804c>);
+	m_dsmap.SetAt(0x4c41904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c41904c>);
+	m_dsmap.SetAt(0x4d00404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d00404c>);
+	m_dsmap.SetAt(0x5fe1004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe1004c>);
+
 	// wild arms 5
 
+	m_dsmap.SetAt(0x1fe19050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe19050>);
+	m_dsmap.SetAt(0x1fef8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fef8064>);
+	m_dsmap.SetAt(0x4845804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4845804c>);
+	m_dsmap.SetAt(0x4845904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4845904c>);
+	m_dsmap.SetAt(0x48804854, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804854>);
+	m_dsmap.SetAt(0x4885884c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885884c>);
+	m_dsmap.SetAt(0x48c68864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48c68864>);
+	m_dsmap.SetAt(0x4b068864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b068864>);
+	m_dsmap.SetAt(0x4d078064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d078064>);
+	m_dsmap.SetAt(0x4d078164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d078164>);
+	m_dsmap.SetAt(0x5fe19054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe19054>);
+	m_dsmap.SetAt(0x5fe39054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x5fe39054>);
+
+	// shadow of the colossus
+
+	m_dsmap.SetAt(0x1fe04164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04164>);
+	m_dsmap.SetAt(0x1fe1004d, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe1004d>);
+	m_dsmap.SetAt(0x484e8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x484e8864>);
+	m_dsmap.SetAt(0x48838864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48838864>);
+	m_dsmap.SetAt(0x48859364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48859364>);
+	m_dsmap.SetAt(0x48868b24, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868b24>);
+	m_dsmap.SetAt(0x488b0864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488b0864>);
+	m_dsmap.SetAt(0x488e8264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8264>);
+	m_dsmap.SetAt(0x488f8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8864>);
+	m_dsmap.SetAt(0x48938064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48938064>);
+	m_dsmap.SetAt(0x48939064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48939064>);
+	m_dsmap.SetAt(0x490c8364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490c8364>);
+	m_dsmap.SetAt(0x490e8364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8364>);
+	m_dsmap.SetAt(0x490f8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490f8064>);
+	m_dsmap.SetAt(0x490f8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490f8864>);
+	m_dsmap.SetAt(0x688b8064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x688b8064>);
+	m_dsmap.SetAt(0x688b8864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x688b8864>);
+	m_dsmap.SetAt(0x688b9064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x688b9064>);
+
+	// tales of redemption
+
+	m_dsmap.SetAt(0x4827824c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4827824c>);
+	m_dsmap.SetAt(0x48804254, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804254>);
+	m_dsmap.SetAt(0x48804b4c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804b4c>);
+	m_dsmap.SetAt(0x48804b74, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804b74>);
+	m_dsmap.SetAt(0x48868074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868074>);
+	m_dsmap.SetAt(0x48878374, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878374>);
+	m_dsmap.SetAt(0x48878864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878864>);
+	m_dsmap.SetAt(0x48879164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879164>);
+	m_dsmap.SetAt(0x48879374, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879374>);
+	m_dsmap.SetAt(0x488b9054, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488b9054>);
+	m_dsmap.SetAt(0x4907824c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4907824c>);
+	m_dsmap.SetAt(0x49078264, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078264>);
+	m_dsmap.SetAt(0x4c838064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c838064>);
+	m_dsmap.SetAt(0x4c838364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c838364>);
+	m_dsmap.SetAt(0x4c838854, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c838854>);
+	m_dsmap.SetAt(0x4c838b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c838b64>);
+
+	// digital devil saga
+
+	m_dsmap.SetAt(0x1fe04053, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04053>);
+	m_dsmap.SetAt(0x1fe39070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe39070>);
+	m_dsmap.SetAt(0x40204250, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x40204250>);
+	m_dsmap.SetAt(0x48404050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404050>);
+	m_dsmap.SetAt(0x48404870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48404870>);
+	m_dsmap.SetAt(0x48468070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468070>);
+	m_dsmap.SetAt(0x484e8070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x484e8070>);
+	m_dsmap.SetAt(0x484e8870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x484e8870>);
+	m_dsmap.SetAt(0x484e9070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x484e9070>);
+	m_dsmap.SetAt(0x48804050, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804050>);
+	m_dsmap.SetAt(0x48804060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804060>);
+	m_dsmap.SetAt(0x48804150, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804150>);
+	m_dsmap.SetAt(0x48804360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804360>);
+	m_dsmap.SetAt(0x48804b60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804b60>);
+	m_dsmap.SetAt(0x48804b70, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804b70>);
+	m_dsmap.SetAt(0x48804f50, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48804f50>);
+	m_dsmap.SetAt(0x48858360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48858360>);
+	m_dsmap.SetAt(0x48868b70, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48868b70>);
+	m_dsmap.SetAt(0x48878060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878060>);
+	m_dsmap.SetAt(0x48878150, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878150>);
+	m_dsmap.SetAt(0x48878360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878360>);
+	m_dsmap.SetAt(0x48878750, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878750>);
+	m_dsmap.SetAt(0x48879360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879360>);
+	m_dsmap.SetAt(0x48879750, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48879750>);
+	m_dsmap.SetAt(0x48884360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884360>);
+	m_dsmap.SetAt(0x48884870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884870>);
+	m_dsmap.SetAt(0x48884b60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884b60>);
+	m_dsmap.SetAt(0x48884b70, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48884b70>);
+	m_dsmap.SetAt(0x488a8b70, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488a8b70>);
+	m_dsmap.SetAt(0x488e8060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8060>);
+	m_dsmap.SetAt(0x488e8370, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8370>);
+	m_dsmap.SetAt(0x488e8860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8860>);
+	m_dsmap.SetAt(0x488e8b70, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488e8b70>);
+	m_dsmap.SetAt(0x488f8360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488f8360>);
+	m_dsmap.SetAt(0x4890404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4890404c>);
+	m_dsmap.SetAt(0x48904270, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48904270>);
+	m_dsmap.SetAt(0x4890484c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4890484c>);
+	m_dsmap.SetAt(0x48904a70, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48904a70>);
+	m_dsmap.SetAt(0x4897904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4897904c>);
+	m_dsmap.SetAt(0x4898404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4898404c>);
+	m_dsmap.SetAt(0x49004070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004070>);
+	m_dsmap.SetAt(0x49004870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004870>);
+	m_dsmap.SetAt(0x49004b60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004b60>);
+	m_dsmap.SetAt(0x49004f50, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49004f50>);
+	m_dsmap.SetAt(0x49028060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49028060>);
+	m_dsmap.SetAt(0x49028860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49028860>);
+	m_dsmap.SetAt(0x49048060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49048060>);
+	m_dsmap.SetAt(0x49048860, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49048860>);
+	m_dsmap.SetAt(0x49068060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068060>);
+	m_dsmap.SetAt(0x49068070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068070>);
+	m_dsmap.SetAt(0x49068870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49068870>);
+	m_dsmap.SetAt(0x49078360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078360>);
+	m_dsmap.SetAt(0x49078750, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078750>);
+	m_dsmap.SetAt(0x49079360, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49079360>);
+	m_dsmap.SetAt(0x4908404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4908404c>);
+	m_dsmap.SetAt(0x49084070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49084070>);
+	m_dsmap.SetAt(0x49084870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49084870>);
+	m_dsmap.SetAt(0x490e8070, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8070>);
+	m_dsmap.SetAt(0x490e8870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x490e8870>);
+	m_dsmap.SetAt(0x4910404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4910404c>);
+	m_dsmap.SetAt(0x4a878060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a878060>);
+	m_dsmap.SetAt(0x4a879060, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a879060>);
+	m_dsmap.SetAt(0x51284870, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51284870>);
+	m_dsmap.SetAt(0x51284b60, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x51284b60>);
+
+	// dbzbt2
+
+	m_dsmap.SetAt(0x1fe3004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe3004c>);
+	m_dsmap.SetAt(0x4881904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881904c>);
+	m_dsmap.SetAt(0x488391cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488391cc>);
+	m_dsmap.SetAt(0x4885904e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4885904e>);
+	m_dsmap.SetAt(0x48859074, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48859074>);
+	m_dsmap.SetAt(0x488781cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488781cc>);
+	m_dsmap.SetAt(0x48878674, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48878674>);
+	m_dsmap.SetAt(0x4887874c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887874c>);
+	m_dsmap.SetAt(0x488791cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x488791cc>);
+	m_dsmap.SetAt(0x4887970c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887970c>);
+	m_dsmap.SetAt(0x4887974c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4887974c>);
+	m_dsmap.SetAt(0x48968064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48968064>);
+	m_dsmap.SetAt(0x48968864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48968864>);
+	m_dsmap.SetAt(0x4897804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4897804c>);
+	m_dsmap.SetAt(0x4a40404c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a40404c>);
+	m_dsmap.SetAt(0x4a83104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a83104c>);
+	m_dsmap.SetAt(0x4b069064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b069064>);
+	m_dsmap.SetAt(0x4b07904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4b07904c>);
+	m_dsmap.SetAt(0x4c45904e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c45904e>);
+	m_dsmap.SetAt(0x4c469064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c469064>);
+	m_dsmap.SetAt(0x4c80404e, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c80404e>);
+	m_dsmap.SetAt(0x4c81004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c81004c>);
+	m_dsmap.SetAt(0x4c8391cc, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c8391cc>);
+	m_dsmap.SetAt(0x4c869064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c869064>);
+	m_dsmap.SetAt(0x4c904064, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c904064>);
+	m_dsmap.SetAt(0x4d03004c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4d03004c>);
+	m_dsmap.SetAt(0x543081e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x543081e4>);
+	m_dsmap.SetAt(0x4a87804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a87804c>);
+	m_dsmap.SetAt(0x4a87904c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a87904c>);
+	m_dsmap.SetAt(0x543089e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x543089e4>);
+
+	// dbzbt3
+
+	m_dsmap.SetAt(0x4881104c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4881104c>);
+	m_dsmap.SetAt(0x489081e4, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x489081e4>);
+	m_dsmap.SetAt(0x4917804c, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4917804c>);
+	m_dsmap.SetAt(0x49268864, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49268864>);
+	m_dsmap.SetAt(0x4a879164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4a879164>);
+
+	// dbz sagas
+
+	// disgaea 2
+
+	m_dsmap.SetAt(0x1fe04364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe04364>);
+	m_dsmap.SetAt(0x1fe68174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe68174>);
+	m_dsmap.SetAt(0x1fe69174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe69174>);
+	m_dsmap.SetAt(0x1fe79174, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x1fe79174>);
+	m_dsmap.SetAt(0x48468364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468364>);
+	m_dsmap.SetAt(0x48468b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48468b64>);
+	m_dsmap.SetAt(0x48478364, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478364>);
+	m_dsmap.SetAt(0x48478b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48478b64>);
+	m_dsmap.SetAt(0x48820b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x48820b64>);
+	m_dsmap.SetAt(0x49078b64, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x49078b64>);
+	m_dsmap.SetAt(0x4c469164, (DrawScanlinePtr)&GSDrawScanline::DrawScanlineExT<0x4c469164>);
+
+	// resident evil code veronica
+
+	// Gundam Seed Destiny OMNI VS ZAFT II PLUS 
+
+	// grandia extreme
+
+	// the punisher
+
+	// ico
+
+	// kuon
+
+	// virtual tennis 2
+
+	// one piece grand battle 3
+
+	// one piece grand adventure
+
+	// enthusai
+
+	// prince of tennis
+
+	// crash wrath of cortex
+
+	// hxh
+
+	// ys 1/2 eternal story
+
+	// sbam 2
+
+	// armored core 3
+
+	// bloody roar
+
+	// guitar hero
+
+	// aerial planet
+
+	// gradius 5
+
+	// ferrari f355 challenge
+
+	// onimusha 3
+
+	// king of fighters xi
+
+	// nba 2k8
+
+	// mana khemia
+
+	// shadow hearts
+
+	// tourist trophy
+
+	// ar tonelico
+
+	// ar tonelico 2
+
+	// svr2k8
+
+	// remember 11
+
+	// tales of abyss
+
+	// tokyo bus guide
+
+	// 12riven
+
+	// xenosaga
+
+	// mgs3s1
+
 	// rouge galaxy
 
-	// God of War
+	// god of war
 
-	// dbzbt2
-*/
+	#endif
+
+	POSITION pos = m_dsmap.GetHeadPosition();
+	
+	while(pos)
+	{
+		CRBMap<DWORD, DrawScanlinePtr>::CPair* pair = m_dsmap.GetNext(pos);
+
+		GSScanlineSelector sel;
+
+		sel.dw = pair->m_key;
+
+		if(sel.atst == ATST_LESS)
+		{
+			sel.atst = ATST_LEQUAL;
+			
+			if(m_dsmap.Lookup(sel))
+			{
+				printf("*** %08x\n", sel.dw);
+			}
+		}
+		else if(sel.atst == ATST_GREATER)
+		{
+			sel.atst = ATST_GEQUAL;
+			
+			if(m_dsmap.Lookup(sel))
+			{
+				printf("*** %08x\n", sel.dw);
+			}
+		}
+	}
 }
 
 template<DWORD fpsm, DWORD zpsm, DWORD ztst, DWORD iip>
-void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v)	
+void GSDrawScanline::DrawScanlineT(int top, int left, int right, const GSVertexSW& v)	
 {
 	const GSVector4 ps0123 = GSVector4::ps0123();
 
@@ -2304,25 +2443,25 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 
 	// fa
 
-	fa_base = m_slenv.fbr[top];
-	fa_offset = (GSVector4i*)&m_slenv.fbc[left & 3][left];
+	fa_base = m_env.fbr[top];
+	fa_offset = (GSVector4i*)&m_env.fbc[left & 3][left];
 
 	// za
 
-	za_base = m_slenv.zbr[top];
-	za_offset = (GSVector4i*)&m_slenv.zbc[left & 3][left];
+	za_base = m_env.zbr[top];
+	za_offset = (GSVector4i*)&m_env.zbc[left & 3][left];
 
 	// v.p
 
 	GSVector4 vp = v.p;
 
-	z = vp.zzzz() + m_slenv.dz;
-	f = GSVector4i(vp).zzzzh().zzzz().add16(m_slenv.df);
+	z = vp.zzzz() + m_env.dz;
+	f = GSVector4i(vp).zzzzh().zzzz().add16(m_env.df);
 
 	// v.t
 
 	GSVector4 vt = v.t;
-	GSVector4 dt = m_slenv.dt;
+	GSVector4 dt = m_env.dt;
 	
 	s = vt.xxxx() + dt.xxxx() * ps0123; 
 	t = vt.yyyy() + dt.yyyy() * ps0123; 
@@ -2339,8 +2478,8 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 
 	if(iip)
 	{
-		rb = rb.add16(m_slenv.drb);
-		ga = ga.add16(m_slenv.dga);
+		rb = rb.add16(m_env.drb);
+		ga = ga.add16(m_env.dga);
 	}
 
 	//
@@ -2351,12 +2490,12 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 	{
 		do
 		{
+			GSVector4i test = GSVector4i::zero();
+
 			GSVector4i za = za_base + *za_offset;
 			
 			GSVector4i zs = (GSVector4i(z * 0.5f) << 1) | (GSVector4i(z) & GSVector4i::x00000001(za));
 
-			GSVector4i test;
-
 			if(!TestZ(zpsm, ztst, zs, za, test))
 			{
 				continue;
@@ -2366,73 +2505,48 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 
 			GSVector4i c[6];
 
-			if(m_sel.tfx != TFX_NONE)
+			if(m_env.sel.tfx != TFX_NONE)
 			{
-				GSVector4 u = s;
-				GSVector4 v = t;
-
-				if(!m_sel.fst)
-				{
-					GSVector4 w = q.rcp();
-
-					u *= w;
-					v *= w;
-
-					if(m_sel.ltf)
-					{
-						u -= 0x8000;
-						v -= 0x8000;
-					}
-				}
-
-				SampleTexture(pixels, ztst, m_sel.ltf, m_sel.tlu, test, u, v, c);
+				SampleTexture(pixels, ztst, m_env.sel.fst, m_env.sel.ltf, m_env.sel.tlu, test, s, t, q, c);
 			}
 
-			AlphaTFX(m_sel.tfx, m_sel.tcc, ga, c[1]);
+			AlphaTFX(m_env.sel.tfx, m_env.sel.tcc, ga, c[1]);
 
-			GSVector4i fm = m_slenv.fm;
-			GSVector4i zm = m_slenv.zm;
+			GSVector4i fm = m_env.fm;
+			GSVector4i zm = m_env.zm;
 
-			if(!TestAlpha(m_sel.atst, m_sel.afail, c[1], fm, zm, test))
+			if(!TestAlpha(m_env.sel.atst, m_env.sel.afail, c[1], fm, zm, test))
 			{
 				continue;
 			}
 
-			ColorTFX(m_sel.tfx, rb, ga, c[0], c[1]);
+			ColorTFX(m_env.sel.tfx, rb, ga, c[0], c[1]);
 
-			if(m_sel.fge)
-			{
-				Fog(f, c[0], c[1]);
-			}
+			Fog(m_env.sel.fge, f, c[0], c[1]);
 
 			GSVector4i fa = fa_base + *fa_offset;
 
-			GSVector4i d = GSVector4i::zero();
+			GSVector4i fd = GSVector4i::zero();
 
-			if(m_sel.rfb)
+			if(m_env.sel.rfb)
 			{
-				d = ReadFrameX(fpsm == 1 ? 0 : fpsm, fa);
+				fd = ReadFrameX(fpsm == 1 ? 0 : fpsm, fa);
 
-				if(fpsm != 1 && m_sel.date)
+				if(!TestDestAlpha(fpsm, m_env.sel.date, fd, test))
 				{
-					test |= (d ^ m_slenv.datm).sra32(31);
-
-					if(test.alltrue())
-					{
-						continue;
-					}
+					continue;
 				}
 			}
 
 			fm |= test;
 			zm |= test;
 
-			if(m_sel.abe != 255)
+			if(m_env.sel.abe != 255)
 			{
 				GSVector4i mask = GSVector4i::x00ff();
 
-				c[2] = d & mask;
-				c[3] = (d >> 8) & mask;
+				c[2] = fd & mask;
+				c[3] = (fd >> 8) & mask;
 
 				if(fpsm == 1)
 				{
@@ -2440,19 +2554,19 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 				}
 
 				c[4] = GSVector4::zero();
-				c[5] = m_slenv.afix;
+				c[5] = m_env.afix;
 
-				DWORD abea = m_sel.abea;
-				DWORD abeb = m_sel.abeb;
-				DWORD abec = m_sel.abec;
-				DWORD abed = m_sel.abed;
+				DWORD abea = m_env.sel.abea;
+				DWORD abeb = m_env.sel.abeb;
+				DWORD abec = m_env.sel.abec;
+				DWORD abed = m_env.sel.abed;
 
 				GSVector4i a = c[abec * 2 + 1].yywwl().yywwh().sll16(7);
 
 				GSVector4i rb = GSVector4i::lerp16<1>(c[abea * 2 + 0], c[abeb * 2 + 0], a, c[abed * 2 + 0]);
 				GSVector4i ga = GSVector4i::lerp16<1>(c[abea * 2 + 1], c[abeb * 2 + 1], a, c[abed * 2 + 1]);
 
-				if(m_sel.pabe)
+				if(m_env.sel.pabe)
 				{
 					GSVector4i mask = (c[1] << 8).sra32(31);
 
@@ -2464,22 +2578,22 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 				c[1] = ga.mix16(c[1]);
 			}
 
-			c[0] &= m_slenv.colclamp;
-			c[1] &= m_slenv.colclamp;
+			c[0] &= m_env.colclamp;
+			c[1] &= m_env.colclamp;
 
-			GSVector4i s = c[0].upl16(c[1]).pu16(c[0].uph16(c[1]));
+			GSVector4i fs = c[0].upl16(c[1]).pu16(c[0].uph16(c[1]));
 
 			if(fpsm != 1)
 			{
-				s |= m_slenv.fba;
+				fs |= m_env.fba;
 			}
 
-			if(m_sel.rfb)
+			if(m_env.sel.rfb)
 			{
-				s = s.blend(d, fm);
+				fs = fs.blend(fd, fm);
 			}
 
-			WriteFrameAndZBufX(fpsm, fa, fm, s, ztst > 0 ? zpsm : 3, za, zm, zs, pixels);
+			WriteFrameAndZBufX(fpsm, fa, fm, fs, ztst > 0 ? zpsm : 3, za, zm, zs, pixels);
 		}
 		while(0);
 
@@ -2490,10 +2604,10 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 		fa_offset++;
 		za_offset++;
 
-		z += m_slenv.dz4;
-		f = f.add16(m_slenv.df4);
+		z += m_env.dz4;
+		f = f.add16(m_env.df4);
 
-		GSVector4 dt4 = m_slenv.dt4;
+		GSVector4 dt4 = m_env.dt4;
 
 		s += dt4.xxxx();
 		t += dt4.yyyy();
@@ -2501,7 +2615,7 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 
 		if(iip)
 		{
-			GSVector4i dc4 = m_slenv.dc4;
+			GSVector4i dc4 = m_env.dc4;
 
 			rb = rb.add16(dc4.xxxx());
 			ga = ga.add16(dc4.yyyy());
@@ -2510,29 +2624,28 @@ void GSDrawScanline::DrawScanlineT(int top, int left, int right, const Vertex& v
 }
 
 template<DWORD sel>
-void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex& v)
+void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const GSVertexSW& v)
 {
 	const DWORD fpsm = (sel >> 0) & 3;
 	const DWORD zpsm = (sel >> 2) & 3;
 	const DWORD ztst = (sel >> 4) & 3;
-	const DWORD iip = (sel >> 6) & 1;
-	const DWORD tfx = (sel >> 7) & 7;
-	const DWORD tcc = (sel >> 10) & 1;
-	const DWORD fst = (sel >> 11) & 1;
-	const DWORD ltf = (sel >> 12) & 1;
-	const DWORD atst = (sel >> 13) & 7;
-	const DWORD afail = (sel >> 16) & 3;
-	const DWORD fge = (sel >> 18) & 1;
-	const DWORD date = (sel >> 19) & 1;
-	const DWORD abe = (sel >> 20) & 255;
-	const DWORD abea = (sel >> 20) & 3;
-	const DWORD abeb = (sel >> 22) & 3;
-	const DWORD abec = (sel >> 24) & 3;
-	const DWORD abed = (sel >> 26) & 3;
-	const DWORD pabe = (sel >> 28) & 1;
-	const DWORD rfb = (sel >> 29) & 1;
-	const DWORD wzb = (sel >> 30) & 1;
-	const DWORD tlu = (sel >> 31) & 1;
+	const DWORD atst = (sel >> 6) & 7;
+	const DWORD afail = (sel >> 9) & 3;
+	const DWORD iip = (sel >> 11) & 1;
+	const DWORD tfx = (sel >> 12) & 7;
+	const DWORD tcc = (sel >> 15) & 1;
+	const DWORD fst = (sel >> 16) & 1;
+	const DWORD ltf = (sel >> 17) & 1;
+	const DWORD tlu = (sel >> 18) & 1;
+	const DWORD fge = (sel >> 19) & 1;
+	const DWORD date = (sel >> 20) & 1;
+	const DWORD abe = (sel >> 21) & 255;
+	const DWORD abea = (sel >> 21) & 3;
+	const DWORD abeb = (sel >> 23) & 3;
+	const DWORD abec = (sel >> 25) & 3;
+	const DWORD abed = (sel >> 27) & 3;
+	const DWORD pabe = (sel >> 29) & 1;
+	const DWORD rfb = (sel >> 30) & 1;
 
 	const GSVector4 ps0123 = GSVector4::ps0123();
 
@@ -2547,36 +2660,29 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 
 	// fa
 
-	fa_base = m_slenv.fbr[top];
-	fa_offset = (GSVector4i*)&m_slenv.fbc[left & 3][left];
+	fa_base = m_env.fbr[top];
+	fa_offset = (GSVector4i*)&m_env.fbc[left & 3][left];
 
 	// za
 
-	za_base = m_slenv.zbr[top];
-	za_offset = (GSVector4i*)&m_slenv.zbc[left & 3][left];
+	za_base = m_env.zbr[top];
+	za_offset = (GSVector4i*)&m_env.zbc[left & 3][left];
 
 	// v.p
 
 	GSVector4 vp = v.p;
 
-	z = vp.zzzz() + m_slenv.dz;
-
-	if(fge)
-	{
-		f = GSVector4i(vp).zzzzh().zzzz().add16(m_slenv.df);
-	}
+	z = vp.zzzz() + m_env.dz;
+	f = GSVector4i(vp).zzzzh().zzzz().add16(m_env.df);
 
 	// v.t
 
 	GSVector4 vt = v.t;
-	GSVector4 dt = m_slenv.dt;
+	GSVector4 dt = m_env.dt;
 
-	if(tfx != TFX_NONE)
-	{
-		s = vt.xxxx() + dt.xxxx() * ps0123; 
-		t = vt.yyyy() + dt.yyyy() * ps0123; 
-		q = vt.zzzz() + dt.zzzz() * ps0123; 
-	}
+	s = vt.xxxx() + dt.xxxx() * ps0123; 
+	t = vt.yyyy() + dt.yyyy() * ps0123; 
+	q = vt.zzzz() + dt.zzzz() * ps0123; 
 
 	// v.c
 
@@ -2589,8 +2695,8 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 
 	if(iip)
 	{
-		rb = rb.add16(m_slenv.drb);
-		ga = ga.add16(m_slenv.dga);
+		rb = rb.add16(m_env.drb);
+		ga = ga.add16(m_env.dga);
 	}
 
 	//
@@ -2601,12 +2707,12 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 	{
 		do
 		{
+			GSVector4i test = GSVector4i::zero();
+
 			GSVector4i za = za_base + *za_offset;
 			
 			GSVector4i zs = (GSVector4i(z * 0.5f) << 1) | (GSVector4i(z) & GSVector4i::x00000001(za));
 
-			GSVector4i test;
-
 			if(!TestZ(zpsm, ztst, zs, za, test))
 			{
 				continue;
@@ -2618,30 +2724,13 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 
 			if(tfx != TFX_NONE)
 			{
-				GSVector4 u = s;
-				GSVector4 v = t;
-
-				if(!fst)
-				{
-					GSVector4 w = q.rcp();
-
-					u *= w;
-					v *= w;
-
-					if(ltf)
-					{
-						u -= 0x8000;
-						v -= 0x8000;
-					}
-				}
-
-				SampleTexture(pixels, ztst, ltf, tlu, test, u, v, c);
+				SampleTexture(pixels, ztst, fst, ltf, tlu, test, s, t, q, c);
 			}
-
+			
 			AlphaTFX(tfx, tcc, ga, c[1]);
 
-			GSVector4i fm = m_slenv.fm;
-			GSVector4i zm = m_slenv.zm;
+			GSVector4i fm = m_env.fm;
+			GSVector4i zm = m_env.zm;
 
 			if(!TestAlpha(atst, afail, c[1], fm, zm, test))
 			{
@@ -2650,39 +2739,34 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 
 			ColorTFX(tfx, rb, ga, c[0], c[1]);
 
-			if(fge)
-			{
-				Fog(f, c[0], c[1]);
-			}
+			Fog(fge, f, c[0], c[1]);
 
 			GSVector4i fa = fa_base + *fa_offset;
 
-			GSVector4i d = GSVector4i::zero();
+			GSVector4i fd = GSVector4i::zero();
 
 			if(rfb)
 			{
-				d = ReadFrameX(fpsm == 1 ? 0 : fpsm, fa);
+				fd = ReadFrameX(fpsm == 1 ? 0 : fpsm, fa);
 
-				if(fpsm != 1 && date)
+				if(!TestDestAlpha(fpsm, date, fd, test))
 				{
-					test |= (d ^ m_slenv.datm).sra32(31);
-
-					if(test.alltrue())
-					{
-						continue;
-					}
+					continue;
 				}
 			}
 
-			fm |= test;
-			zm |= test;
+			if(ztst > 1 || atst != ATST_ALWAYS || date)
+			{
+				fm |= test;
+				zm |= test;
+			}
 
 			if(abe != 255)
 			{
 				GSVector4i mask = GSVector4i::x00ff();
 
-				c[2] = d & mask;
-				c[3] = (d >> 8) & mask;
+				c[2] = fd & mask;
+				c[3] = (fd >> 8) & mask;
 
 				c[4] = GSVector4::zero();
 				c[5] = GSVector4::zero();
@@ -2702,7 +2786,7 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 
 					if(!(fpsm == 1 && abec == 1))
 					{
-						GSVector4i a = abec < 2 ? c[abec * 2 + 1].yywwl().yywwh().sll16(7) : m_slenv.afix2;
+						GSVector4i a = abec < 2 ? c[abec * 2 + 1].yywwl().yywwh().sll16(7) : m_env.afix2;
 
 						rb = rb.modulate16<1>(a);
 						ga = ga.modulate16<1>(a);
@@ -2732,22 +2816,22 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 				c[1] = ga.mix16(c[1]);
 			}
 
-			c[0] &= m_slenv.colclamp;
-			c[1] &= m_slenv.colclamp;
+			c[0] &= m_env.colclamp;
+			c[1] &= m_env.colclamp;
 
-			GSVector4i s = c[0].upl16(c[1]).pu16(c[0].uph16(c[1]));
+			GSVector4i fs = c[0].upl16(c[1]).pu16(c[0].uph16(c[1]));
 
 			if(fpsm != 1)
 			{
-				s |= m_slenv.fba;
+				fs |= m_env.fba;
 			}
 
 			if(rfb)
 			{
-				s = s.blend(d, fm);
+				fs = fs.blend(fd, fm);
 			}
 
-			WriteFrameAndZBufX(fpsm, fa, fm, s, ztst > 0 ? zpsm : 3, za, zm, zs, pixels);
+			WriteFrameAndZBufX(fpsm, fa, fm, fs, ztst > 0 ? zpsm : 3, za, zm, zs, pixels);
 		}
 		while(0);
 
@@ -2758,25 +2842,18 @@ void GSDrawScanline::DrawScanlineExT(int top, int left, int right, const Vertex&
 		fa_offset++;
 		za_offset++;
 
-		z += m_slenv.dz4;
+		z += m_env.dz4;
+		f = f.add16(m_env.df4);
 
-		if(fge)
-		{
-			f = f.add16(m_slenv.df4);
-		}
+		GSVector4 dt4 = m_env.dt4;
 
-		if(tfx != TFX_NONE)
-		{
-			GSVector4 dt4 = m_slenv.dt4;
-
-			s += dt4.xxxx();
-			t += dt4.yyyy();
-			q += dt4.zzzz();
-		}
+		s += dt4.xxxx();
+		t += dt4.yyyy();
+		q += dt4.zzzz();
 
 		if(iip)
 		{
-			GSVector4i dc4 = m_slenv.dc4;
+			GSVector4i dc4 = m_env.dc4;
 
 			rb = rb.add16(dc4.xxxx());
 			ga = ga.add16(dc4.yyyy());
diff --git a/gsdx/GSDrawScanline.h b/gsdx/GSDrawScanline.h
index d6a3e69..4668843 100644
--- a/gsdx/GSDrawScanline.h
+++ b/gsdx/GSDrawScanline.h
@@ -25,73 +25,87 @@
 #include "GSRasterizer.h"
 #include "GSAlignedClass.h"
 
+union GSScanlineSelector
+{
+	struct
+	{
+		DWORD fpsm:2; // 0
+		DWORD zpsm:2; // 2
+		DWORD ztst:2; // 4 (0: off, 1: write, 2: test (ge), 3: test (g))
+		DWORD atst:3; // 6
+		DWORD afail:2; // 9
+		DWORD iip:1; // 11
+		DWORD tfx:3; // 12
+		DWORD tcc:1; // 15
+		DWORD fst:1; // 16
+		DWORD ltf:1; // 17
+		DWORD tlu:1; // 18
+		DWORD fge:1; // 19
+		DWORD date:1; // 20
+		DWORD abea:2; // 21
+		DWORD abeb:2; // 23
+		DWORD abec:2; // 25
+		DWORD abed:2; // 27
+		DWORD pabe:1; // 29
+		DWORD rfb:1; // 30
+	};
+
+	struct
+	{
+		DWORD _pad1:21;
+		DWORD abe:8;
+		DWORD _pad2:3;
+	};
+
+	DWORD dw;
+
+	operator DWORD() {return dw & 0x7fffffff;}
+};
+
+__declspec(align(16)) struct GSScanlineEnvironment
+{
+	GSScanlineSelector sel;
+
+	void* vm;
+	const void* tex;
+	const DWORD* clut;
+	DWORD tw;
+
+	GSVector4i* fbr;
+	GSVector4i* zbr;
+	int** fbc;
+	int** zbc;
+
+	GSVector4i fm, zm;
+	struct {GSVector4i min, max, mask;} t; // [u] x 4 [v] x 4
+	GSVector4i datm;
+	GSVector4i colclamp;
+	GSVector4i fba;
+	GSVector4i aref;
+	GSVector4i afix, afix2;
+	GSVector4i frb, fga;
+
+	GSVector4 dz, dz4;
+	GSVector4i df, df4;
+	GSVector4 dt, dt4;
+	GSVector4i drb, dga, dc4;
+};
+
+__declspec(align(16)) struct GSScanlineParam
+{
+	GSScanlineSelector sel;
+
+	void* vm;
+	const void* tex;
+	const DWORD* clut;
+	DWORD tw;
+
+	DWORD fm, zm;
+};
+
 class GSDrawScanline : public GSAlignedClass<16>, public IDrawScanline
 {
-	union ScanlineSelector
-	{
-		struct
-		{
-			DWORD fpsm:2; // 0
-			DWORD zpsm:2; // 2
-			DWORD ztst:2; // 4 (0: off, 1: write, 2: test (ge), 3: test (g))
-			DWORD iip:1; // 6
-			DWORD tfx:3; // 7
-			DWORD tcc:1; // 10
-			DWORD fst:1; // 11
-			DWORD ltf:1; // 12
-			DWORD atst:3; // 13
-			DWORD afail:2; // 16
-			DWORD fge:1; // 18
-			DWORD date:1; // 19
-			DWORD abea:2; // 20
-			DWORD abeb:2; // 22
-			DWORD abec:2; // 24
-			DWORD abed:2; // 26
-			DWORD pabe:1; // 28
-			DWORD rfb:1; // 29
-			DWORD wzb:1; // 30
-			DWORD tlu:1; // 31
-		};
-
-		struct
-		{
-			DWORD _pad1:20;
-			DWORD abe:8;
-			DWORD _pad2:4;
-		};
-
-		DWORD dw;
-
-		operator DWORD() {return dw;}// & 0x7fffffff;}
-	};
-
-	__declspec(align(16)) struct ScanlineEnvironment
-	{
-		void* vm;
-
-		const void* tex;
-		const DWORD* clut;
-		DWORD tw;
-
-		GSVector4i* fbr;
-		GSVector4i* zbr;
-		int** fbc;
-		int** zbc;
-
-		GSVector4i fm, zm;
-		struct {GSVector4i min, max, mask;} t; // [u] x 4 [v] x 4
-		GSVector4i datm;
-		GSVector4i colclamp;
-		GSVector4i fba;
-		GSVector4i aref;
-		GSVector4i afix, afix2;
-		GSVector4i frb, fga;
-
-		GSVector4 dz, dz4;
-		GSVector4i df, df4;
-		GSVector4 dt, dt4;
-		GSVector4i drb, dga, dc4;
-	};
+	GSScanlineEnvironment m_env;
 
 	struct Offset
 	{
@@ -100,9 +114,6 @@ class GSDrawScanline : public GSAlignedClass<16>, public IDrawScanline
 		DWORD hash;
 	};
 
-	ScanlineSelector m_sel;
-	ScanlineEnvironment m_slenv;
-
 	CRBMapC<DWORD, Offset*> m_omap;
 	Offset* m_fbo;
 	Offset* m_zbo;
@@ -116,19 +127,20 @@ class GSDrawScanline : public GSAlignedClass<16>, public IDrawScanline
 	void Init();
 
 	template<DWORD fpsm, DWORD zpsm, DWORD ztst, DWORD iip>
-	void DrawScanlineT(int top, int left, int right, const Vertex& v);
+	void DrawScanlineT(int top, int left, int right, const GSVertexSW& v);
 
 	template<DWORD sel> 
-	void DrawScanlineExT(int top, int left, int right, const Vertex& v);
+	void DrawScanlineExT(int top, int left, int right, const GSVertexSW& v);
 
 	__forceinline GSVector4i Wrap(const GSVector4i& t);
 
-	__forceinline void SampleTexture(int pixels, DWORD ztst, DWORD ltf, DWORD pal, const GSVector4i& test, const GSVector4& u, const GSVector4& v, GSVector4i* c);
+	__forceinline void SampleTexture(int pixels, DWORD ztst, DWORD fst, DWORD ltf, DWORD tlu, const GSVector4i& test, const GSVector4& s, const GSVector4& t, const GSVector4& q, GSVector4i* c);
 	__forceinline void ColorTFX(DWORD tfx, const GSVector4i& rbf, const GSVector4i& gaf, GSVector4i& rbt, GSVector4i& gat);
 	__forceinline void AlphaTFX(DWORD tfx, DWORD tcc, const GSVector4i& gaf, GSVector4i& gat);
-	__forceinline void Fog(const GSVector4i& f, GSVector4i& rb, GSVector4i& ga);
+	__forceinline void Fog(DWORD fge, const GSVector4i& f, GSVector4i& rb, GSVector4i& ga);
 	__forceinline bool TestZ(DWORD zpsm, DWORD ztst, const GSVector4i& zs, const GSVector4i& za, GSVector4i& test);
 	__forceinline bool TestAlpha(DWORD atst, DWORD afail, const GSVector4i& ga, GSVector4i& fm, GSVector4i& zm, GSVector4i& test);
+	__forceinline bool TestDestAlpha(DWORD fpsm, DWORD date, const GSVector4i& d, GSVector4i& test);
 
 	__forceinline static DWORD ReadPixel32(DWORD* RESTRICT vm, DWORD addr);
 	__forceinline static DWORD ReadPixel24(DWORD* RESTRICT vm, DWORD addr);
@@ -150,9 +162,9 @@ public:
 
 	// IDrawScanline
 
-	void SetupDraw(Vertex* vertices, int count, const void* texture);
-	void SetupPrim(PrimitiveType type, const Vertex* vertices, const Vertex& dscan);
-	void DrawScanline(int top, int left, int right, const Vertex& v);
-	void FillRect(const GSVector4i& r, const Vertex& v);
+	bool SetupDraw(const GSRasterizerData* data);
+	void SetupPrim(GS_PRIM_CLASS primclass, const GSVertexSW* vertices, const GSVertexSW& dscan);
+	void DrawScanline(int top, int left, int right, const GSVertexSW& v);
+	void DrawSolidRect(const GSVector4i& r, const GSVertexSW& v);
 	DrawScanlinePtr GetDrawScanlinePtr();
 };
diff --git a/gsdx/GSDrawingContext.h b/gsdx/GSDrawingContext.h
index 09f45dc..86cfae4 100644
--- a/gsdx/GSDrawingContext.h
+++ b/gsdx/GSDrawingContext.h
@@ -96,19 +96,19 @@ public:
 			(int)SCISSOR.SCAY1);
 	}
 
-	bool DepthRead()
+	bool DepthRead() const
 	{
 		return TEST.ZTE && TEST.ZTST >= 2;
 	}
 
-	bool DepthWrite()
+	bool DepthWrite() const
 	{
-		if(TEST.ATE && TEST.ATST == 0 && TEST.AFAIL != 2) // alpha test, all pixels fail, z buffer is not updated
+		if(TEST.ATE && TEST.ATST == ATST_NEVER && TEST.AFAIL != AFAIL_ZB_ONLY) // alpha test, all pixels fail, z buffer is not updated
 		{
 			return false;
 		}
 
-		return ZBUF.ZMSK == 0;
+		return ZBUF.ZMSK == 0 && TEST.ZTE != 0; // ZTE == 0 is bug on the real hardware, write is blocked then
 	}
 };
 
diff --git a/gsdx/GSRasterizer.cpp b/gsdx/GSRasterizer.cpp
index b45c2f7..a42a6ce 100644
--- a/gsdx/GSRasterizer.cpp
+++ b/gsdx/GSRasterizer.cpp
@@ -35,7 +35,45 @@ GSRasterizer::~GSRasterizer()
 	delete m_ds;
 }
 
-void GSRasterizer::DrawPoint(Vertex* v, const GSVector4i& scissor)
+int GSRasterizer::Draw(const GSRasterizerData* data)
+{
+	bool solid = m_ds->SetupDraw(data);
+
+	const GSVector4i scissor = data->scissor;
+	const GSVertexSW* vertices = data->vertices;
+	const int count = data->count;
+
+	int prims = 0;
+
+	switch(data->primclass)
+	{
+	case GS_POINT_CLASS:
+		prims = count;
+		for(int i = 0; i < count; i++) DrawPoint(&vertices[i], scissor);
+		break;
+	case GS_LINE_CLASS:
+		ASSERT(!(count & 1));
+		prims = count / 2;
+		for(int i = 0; i < count; i += 2) DrawLine(&vertices[i], scissor);
+		break;
+	case GS_TRIANGLE_CLASS:
+		ASSERT(!(count % 3));
+		prims = count / 3;
+		for(int i = 0; i < count; i += 3) DrawTriangle(&vertices[i], scissor);
+		break;
+	case GS_SPRITE_CLASS:
+		ASSERT(!(count & 1));
+		prims = count / 2;
+		for(int i = 0; i < count; i += 2) DrawSprite(&vertices[i], scissor, solid);
+		break;
+	default:
+		__assume(0);
+	}
+
+	return prims;
+}
+
+void GSRasterizer::DrawPoint(const GSVertexSW* v, const GSVector4i& scissor)
 {
 	// TODO: round to closest for point, prestep for line
 
@@ -52,19 +90,50 @@ void GSRasterizer::DrawPoint(Vertex* v, const GSVector4i& scissor)
 	}
 }
 
-void GSRasterizer::DrawLine(Vertex* v, const GSVector4i& scissor)
+void GSRasterizer::DrawLine(const GSVertexSW* v, const GSVector4i& scissor)
 {
-	Vertex dv = v[1] - v[0];
+	GSVertexSW dv = v[1] - v[0];
 
 	GSVector4 dp = dv.p.abs();
 	GSVector4i dpi(dp);
 
-	if(dpi.x == 0 && dpi.y == 0) return;
+	if(dpi.y == 0)
+	{
+		if(dpi.x > 0)
+		{
+			// shortcut for horizontal lines
+
+			GSVector4 mask = (v[0].p > v[1].p).xxxx();
+
+			GSVertexSW l, dl;
+
+			l.p = v[0].p.blend8(v[1].p, mask);
+			l.t = v[0].t.blend8(v[1].t, mask);
+			l.c = v[0].c.blend8(v[1].c, mask);
+
+			GSVector4 r, dr;
+
+			r = v[1].p.blend8(v[0].p, mask);
+
+			GSVertexSW dscan = dv / dv.p.xxxx();
+
+			GSVector4i p(l.p);
+
+			if(scissor.y <= p.y && p.y < scissor.w)
+			{
+				m_ds->SetupPrim(GS_LINE_CLASS, v, dscan);
+
+				DrawTriangleSection(p.y, p.y + 1, l, dl, r, dr, dscan, scissor);
+			}
+		}
+
+		return;
+	}
 
 	int i = dpi.x > dpi.y ? 0 : 1;
 
-	Vertex edge = v[0];
-	Vertex dedge = dv / dp.v[i];
+	GSVertexSW edge = v[0];
+	GSVertexSW dedge = dv / dp.v[i];
 
 	// TODO: prestep + clip with the scissor
 
@@ -90,9 +159,9 @@ static const int s_abc[8][4] =
 	{2, 1, 0, 0},
 };
 
-void GSRasterizer::DrawTriangle(Vertex* vertices, const GSVector4i& scissor)
+void GSRasterizer::DrawTriangle(const GSVertexSW* vertices, const GSVector4i& scissor)
 {
-	Vertex v[3];
+	GSVertexSW v[3];
 
 	GSVector4 aabb = vertices[0].p.yyyy(vertices[1].p);
 	GSVector4 bccb = vertices[1].p.yyyy(vertices[2].p).xzzx();
@@ -126,26 +195,26 @@ void GSRasterizer::DrawTriangle(Vertex* vertices, const GSVector4i& scissor)
 	}
 }
 
-void GSRasterizer::DrawTriangleTop(Vertex* v, const GSVector4i& scissor)
+void GSRasterizer::DrawTriangleTop(GSVertexSW* v, const GSVector4i& scissor)
 {
-	Vertex longest = v[2] - v[1];
+	GSVertexSW longest = v[2] - v[1];
 	
 	if((longest.p == GSVector4::zero()).mask() & 1)
 	{
 		return;
 	}
 
-	Vertex dscan = longest * longest.p.xxxx().rcp();
+	GSVertexSW dscan = longest * longest.p.xxxx().rcp();
 
 	int i = (longest.p > GSVector4::zero()).mask() & 1;
 
-	Vertex& l = v[0];
+	GSVertexSW& l = v[0];
 	GSVector4 r = v[0].p;
 
-	Vertex vl = v[2 - i] - l;
+	GSVertexSW vl = v[2 - i] - l;
 	GSVector4 vr = v[1 + i].p - r;
 
-	Vertex dl = vl / vl.p.yyyy();
+	GSVertexSW dl = vl / vl.p.yyyy();
 	GSVector4 dr = vr / vr.yyyy();
 
 	GSVector4i tb(l.p.xyxy(v[2].p).ceil());
@@ -168,32 +237,32 @@ void GSRasterizer::DrawTriangleTop(Vertex* v, const GSVector4i& scissor)
 			r += dr * dy;
 		}
 
-		m_ds->SetupPrim(IDrawScanline::Triangle, v, dscan);
+		m_ds->SetupPrim(GS_TRIANGLE_CLASS, v, dscan);
 
 		DrawTriangleSection(top, bottom, l, dl, r, dr, dscan, scissor);
 	}
 }
 
-void GSRasterizer::DrawTriangleBottom(Vertex* v, const GSVector4i& scissor)
+void GSRasterizer::DrawTriangleBottom(GSVertexSW* v, const GSVector4i& scissor)
 {
-	Vertex longest = v[1] - v[0];
+	GSVertexSW longest = v[1] - v[0];
 	
 	if((longest.p == GSVector4::zero()).mask() & 1)
 	{
 		return;
 	}
 	
-	Vertex dscan = longest * longest.p.xxxx().rcp();
+	GSVertexSW dscan = longest * longest.p.xxxx().rcp();
 
 	int i = (longest.p > GSVector4::zero()).mask() & 1;
 
-	Vertex& l = v[1 - i];
+	GSVertexSW& l = v[1 - i];
 	GSVector4& r = v[i].p;
 
-	Vertex vl = v[2] - l;
+	GSVertexSW vl = v[2] - l;
 	GSVector4 vr = v[2].p - r;
 
-	Vertex dl = vl / vl.p.yyyy();
+	GSVertexSW dl = vl / vl.p.yyyy();
 	GSVector4 dr = vr / vr.yyyy();
 
 	GSVector4i tb(l.p.xyxy(v[2].p).ceil());
@@ -216,34 +285,34 @@ void GSRasterizer::DrawTriangleBottom(Vertex* v, const GSVector4i& scissor)
 			r += dr * dy;
 		}
 		
-		m_ds->SetupPrim(IDrawScanline::Triangle, v, dscan);
+		m_ds->SetupPrim(GS_TRIANGLE_CLASS, v, dscan);
 
 		DrawTriangleSection(top, bottom, l, dl, r, dr, dscan, scissor);
 	}
 }
 
-void GSRasterizer::DrawTriangleTopBottom(Vertex* v, const GSVector4i& scissor)
+void GSRasterizer::DrawTriangleTopBottom(GSVertexSW* v, const GSVector4i& scissor)
 {
-	Vertex v01, v02, v12;
+	GSVertexSW v01, v02, v12;
 
 	v01 = v[1] - v[0];
 	v02 = v[2] - v[0];
 
-	Vertex longest = v[0] + v02 * (v01.p / v02.p).yyyy() - v[1];
+	GSVertexSW longest = v[0] + v02 * (v01.p / v02.p).yyyy() - v[1];
 
 	if((longest.p == GSVector4::zero()).mask() & 1)
 	{
 		return;
 	}
 
-	Vertex dscan = longest * longest.p.xxxx().rcp();
+	GSVertexSW dscan = longest * longest.p.xxxx().rcp();
 
-	m_ds->SetupPrim(IDrawScanline::Triangle, v, dscan);
+	m_ds->SetupPrim(GS_TRIANGLE_CLASS, v, dscan);
 
-	Vertex& l = v[0];
+	GSVertexSW& l = v[0];
 	GSVector4 r = v[0].p;
 
-	Vertex dl;
+	GSVertexSW dl;
 	GSVector4 dr;
 
 	bool b = (longest.p > GSVector4::zero()).mask() & 1;
@@ -319,7 +388,7 @@ void GSRasterizer::DrawTriangleTopBottom(Vertex* v, const GSVector4i& scissor)
 	}
 }
 
-void GSRasterizer::DrawTriangleSection(int top, int bottom, Vertex& l, const Vertex& dl, GSVector4& r, const GSVector4& dr, const Vertex& dscan, const GSVector4i& scissor)
+void GSRasterizer::DrawTriangleSection(int top, int bottom, GSVertexSW& l, const GSVertexSW& dl, GSVector4& r, const GSVector4& dr, const GSVertexSW& dscan, const GSVector4i& scissor)
 {
 	ASSERT(top < bottom);
 
@@ -361,7 +430,7 @@ void GSRasterizer::DrawTriangleSection(int top, int bottom, Vertex& l, const Ver
 				{
 					m_pixels += pixels;
 
-					Vertex scan = l;
+					GSVertexSW scan = l;
 
 					float px = (float)left - l.p.x;
 
@@ -380,9 +449,9 @@ void GSRasterizer::DrawTriangleSection(int top, int bottom, Vertex& l, const Ver
 	}
 }
 
-void GSRasterizer::DrawSprite(Vertex* vertices, const GSVector4i& scissor, bool solid)
+void GSRasterizer::DrawSprite(const GSVertexSW* vertices, const GSVector4i& scissor, bool solid)
 {
-	Vertex v[2];
+	GSVertexSW v[2];
 
 	GSVector4 mask = vertices[0].p > vertices[1].p;
 
@@ -419,13 +488,15 @@ void GSRasterizer::DrawSprite(Vertex* vertices, const GSVector4i& scissor, bool
 
 	#endif
 
-	Vertex scan = v[0];
+	GSVertexSW scan = v[0];
 
 	if(solid)
 	{
 		if(m_id == 0)
 		{
-			m_ds->FillRect(r, scan);
+			m_ds->DrawSolidRect(r, scan);
+
+			m_pixels += (r.z - r.x) * (r.w - r.y);
 		}
 
 		return;
@@ -433,12 +504,12 @@ void GSRasterizer::DrawSprite(Vertex* vertices, const GSVector4i& scissor, bool
 
 	GSVector4 zero = GSVector4::zero();
 
-	Vertex dedge, dscan;
+	GSVertexSW dedge, dscan;
 
 	dedge.p = zero;
 	dscan.p = zero;
 
-	Vertex dv = v[1] - v[0];
+	GSVertexSW dv = v[1] - v[0];
 
 	dedge.t = (dv.t / dv.p.yyyy()).xyxy(zero).wyww();
 	dscan.t = (dv.t / dv.p.xxxx()).xyxy(zero).xwww();
@@ -446,7 +517,7 @@ void GSRasterizer::DrawSprite(Vertex* vertices, const GSVector4i& scissor, bool
 	if(scan.p.y < (float)top) scan.t += dedge.t * ((float)top - scan.p.y);
 	if(scan.p.x < (float)left) scan.t += dscan.t * ((float)left - scan.p.x);
 
-	m_ds->SetupPrim(IDrawScanline::Sprite, v, dscan);
+	m_ds->SetupPrim(GS_SPRITE_CLASS, v, dscan);
 
 	IDrawScanline::DrawScanlinePtr dsf = m_ds->GetDrawScanlinePtr();
 
@@ -463,13 +534,13 @@ void GSRasterizer::DrawSprite(Vertex* vertices, const GSVector4i& scissor, bool
 
 //
 
-GSRasterizerMT::GSRasterizerMT(IDrawScanline* ds, int id, int threads, IDrawAsync* da, long* sync)
+GSRasterizerMT::GSRasterizerMT(IDrawScanline* ds, int id, int threads, long* sync)
 	: GSRasterizer(ds, id, threads)
-	, m_da(da)
 	, m_sync(sync)
 	, m_exit(false)
 	, m_ThreadId(0)
 	, m_hThread(NULL)
+	, m_data(NULL)
 {
 	if(id > 0)
 	{
@@ -492,18 +563,18 @@ GSRasterizerMT::~GSRasterizerMT()
 	}
 }
 
-int GSRasterizerMT::Draw(Vertex* vertices, int count, const void* texture)
+int GSRasterizerMT::Draw(const GSRasterizerData* data)
 {
-	m_ds->SetupDraw(vertices, count, texture);
-
 	int prims = 0;
 
 	if(m_id == 0)
 	{
-		prims = m_da->DrawAsync(this);
+		prims = __super::Draw(data);
 	}
 	else
 	{
+		m_data = data;
+
 		InterlockedBitTestAndSet(m_sync, m_id);
 	}
 
@@ -523,7 +594,7 @@ DWORD GSRasterizerMT::ThreadProc()
 	{
 		if(*m_sync & (1 << m_id))
 		{
-			m_da->DrawAsync(this);
+			__super::Draw(m_data);
 
 			InterlockedBitTestAndReset(m_sync, m_id);
 		}
@@ -560,7 +631,7 @@ void GSRasterizerList::FreeRasterizers()
 	}
 }
 
-int GSRasterizerList::Draw(GSVertexSW* vertices, int count, const void* texture)
+int GSRasterizerList::Draw(const GSRasterizerData* data)
 {
 	*m_sync = 0;
 
@@ -570,9 +641,7 @@ int GSRasterizerList::Draw(GSVertexSW* vertices, int count, const void* texture)
 
 	while(pos)
 	{
-		GSRasterizerMT* r = GetPrev(pos);
-
-		prims += r->Draw(vertices, count, texture);
+		prims += GetPrev(pos)->Draw(data);
 	}
 
 	while(*m_sync)
diff --git a/gsdx/GSRasterizer.h b/gsdx/GSRasterizer.h
index dd74c89..203a8c7 100644
--- a/gsdx/GSRasterizer.h
+++ b/gsdx/GSRasterizer.h
@@ -21,83 +21,93 @@
 
 #pragma once
 
+#include "GS.h"
 #include "GSVertexSW.h"
 
 #define FAST_DRAWSCANLINE
 
+__declspec(align(16)) class GSRasterizerData
+{
+public:
+	GSVector4i scissor;
+	GS_PRIM_CLASS primclass;
+	const GSVertexSW* vertices;
+	int count;
+	const void* param;
+};
+
+class IRasterizer
+{
+public:
+	virtual int Draw(const GSRasterizerData* data) = 0;
+	virtual int GetPixels() = 0;
+};
+
 class IDrawScanline
 {
 public:
-	typedef GSVertexSW Vertex;
-	typedef void (IDrawScanline::*DrawScanlinePtr)(int top, int left, int right, const Vertex& v);
-
-	enum PrimitiveType {Point, Line, Triangle, Sprite};
+	typedef void (IDrawScanline::*DrawScanlinePtr)(int top, int left, int right, const GSVertexSW& v);
 
 	virtual ~IDrawScanline() {}
 
-	virtual void SetupDraw(Vertex* vertices, int count, const void* texture) = 0;
-	virtual void SetupPrim(PrimitiveType type, const Vertex* vertices, const Vertex& dscan) = 0;
-	virtual void DrawScanline(int top, int left, int right, const Vertex& v) = 0;
-	virtual void FillRect(const GSVector4i& r, const Vertex& v) = 0;
+	virtual bool SetupDraw(const GSRasterizerData* data) = 0;
+	virtual void SetupPrim(GS_PRIM_CLASS primclass, const GSVertexSW* vertices, const GSVertexSW& dscan) = 0;
+	virtual void DrawScanline(int top, int left, int right, const GSVertexSW& v) = 0;
+	virtual void DrawSolidRect(const GSVector4i& r, const GSVertexSW& v) = 0;
 	virtual DrawScanlinePtr GetDrawScanlinePtr() = 0;
 };
 
-class GSRasterizer
+class GSRasterizer : public IRasterizer
 {
 protected:
-	typedef GSVertexSW Vertex;
-
 	IDrawScanline* m_ds;
 	int m_id;
 	int m_threads;
 	int m_pixels;
 
-	void DrawTriangleTop(Vertex* v, const GSVector4i& scissor);
-	void DrawTriangleBottom(Vertex* v, const GSVector4i& scissor);
-	void DrawTriangleTopBottom(Vertex* v, const GSVector4i& scissor);
+	void DrawPoint(const GSVertexSW* v, const GSVector4i& scissor);
+	void DrawLine(const GSVertexSW* v, const GSVector4i& scissor);
+	void DrawTriangle(const GSVertexSW* v, const GSVector4i& scissor);
+	void DrawSprite(const GSVertexSW* v, const GSVector4i& scissor, bool solid);
 
-	__forceinline void DrawTriangleSection(int top, int bottom, Vertex& l, const Vertex& dl, GSVector4& r, const GSVector4& dr, const Vertex& dscan, const GSVector4i& scissor);
+	void DrawTriangleTop(GSVertexSW* v, const GSVector4i& scissor);
+	void DrawTriangleBottom(GSVertexSW* v, const GSVector4i& scissor);
+	void DrawTriangleTopBottom(GSVertexSW* v, const GSVector4i& scissor);
+
+	__forceinline void DrawTriangleSection(int top, int bottom, GSVertexSW& l, const GSVertexSW& dl, GSVector4& r, const GSVector4& dr, const GSVertexSW& dscan, const GSVector4i& scissor);
 
 public:
 	GSRasterizer(IDrawScanline* ds, int id = 0, int threads = 0);
 	virtual ~GSRasterizer();
 
-	void DrawPoint(Vertex* v, const GSVector4i& scissor);
-	void DrawLine(Vertex* v, const GSVector4i& scissor);
-	void DrawTriangle(Vertex* v, const GSVector4i& scissor);
-	void DrawSprite(Vertex* v, const GSVector4i& scissor, bool solid);
-
-	IDrawScanline* GetDrawScanline() {return m_ds;}
+	// IRasterizer
 
+	int Draw(const GSRasterizerData* data);
 	int GetPixels() {int pixels = m_pixels; m_pixels = 0; return pixels;}
 };
 
-interface IDrawAsync
-{
-public:
-	virtual int DrawAsync(GSRasterizer* r) = 0;
-};
-
 class GSRasterizerMT : public GSRasterizer
 {
-	IDrawAsync* m_da;
 	long* m_sync;
 	bool m_exit;
     DWORD m_ThreadId;
     HANDLE m_hThread;
+	const GSRasterizerData* m_data;
 
 	static DWORD WINAPI StaticThreadProc(LPVOID lpParam);
 
 	DWORD ThreadProc();
 
 public:
-	GSRasterizerMT(IDrawScanline* ds, int id, int threads, IDrawAsync* da, long* sync);
+	GSRasterizerMT(IDrawScanline* ds, int id, int threads, long* sync);
 	virtual ~GSRasterizerMT();
 
-	int Draw(Vertex* vertices, int count, const void* texture);
+	// IRasterizer
+
+	int Draw(const GSRasterizerData* data);
 };
 
-class GSRasterizerList : public CAtlList<GSRasterizerMT*>
+class GSRasterizerList : public CAtlList<GSRasterizerMT*>, public IRasterizer
 {
 	long* m_sync;
 
@@ -107,7 +117,7 @@ public:
 	GSRasterizerList();
 	virtual ~GSRasterizerList();
 
-	template<class DS, class T> void Create(T* parent, IDrawAsync* da, int threads)
+	template<class DS, class T> void Create(T* parent, int threads)
 	{
 		FreeRasterizers();
 
@@ -115,10 +125,12 @@ public:
 
 		for(int i = 0; i < threads; i++) 
 		{
-			AddTail(new GSRasterizerMT(new DS(parent), i, threads, da, m_sync));
+			AddTail(new GSRasterizerMT(new DS(parent), i, threads, m_sync));
 		}
 	}
 
-	int Draw(GSVertexSW* vertices, int count, const void* texture);
+	// IRasterizer
+
+	int Draw(const GSRasterizerData* data);
 	int GetPixels();
 };
\ No newline at end of file
diff --git a/gsdx/GSRendererHW.h b/gsdx/GSRendererHW.h
index d31a764..546176a 100644
--- a/gsdx/GSRendererHW.h
+++ b/gsdx/GSRendererHW.h
@@ -330,7 +330,8 @@ protected:
 			if(PRIM->TME && tex->m_palette) if(s_save) tex->m_palette.Save(str, true);
 			str.Format(_T("c:\\temp2\\_%05d_f%I64d_rt0_%05x_%d.bmp"), s_n++, m_perfmon.GetFrame(), context->FRAME.Block(), context->FRAME.PSM);
 			if(s_save) rt->m_texture.Save(str);
-			// str.Format(_T("c:\\temp2\\_%05d_f%I64d_rz0_%05x_%d.bmp"), s_n-1, m_perfmon.GetFrame(), context->ZBUF.Block(), context->ZBUF.PSM);
+			str.Format(_T("c:\\temp2\\_%05d_f%I64d_rz0_%05x_%d.bmp"), s_n-1, m_perfmon.GetFrame(), context->ZBUF.Block(), context->ZBUF.PSM);
+			if(s_savez) ds->m_texture.Save(str);
 			// if(s_savez) m_dev.SaveToFileD32S8X24(ds->m_texture, str); // TODO
 			// if(s_savez) m_dev.SaveToFileD24S8(ds->m_texture, str); // TODO
 		}
@@ -353,7 +354,8 @@ protected:
 			CString str;
 			str.Format(_T("c:\\temp2\\_%05d_f%I64d_rt1_%05x_%d.bmp"), s_n++, m_perfmon.GetFrame(), context->FRAME.Block(), context->FRAME.PSM);
 			if(s_save) rt->m_texture.Save(str);
-			// str.Format(_T("c:\\temp2\\_%05d_f%I64d_rz1_%05x_%d.bmp"), s_n-1, m_perfmon.GetFrame(), context->ZBUF.Block(), context->ZBUF.PSM);
+			str.Format(_T("c:\\temp2\\_%05d_f%I64d_rz1_%05x_%d.bmp"), s_n-1, m_perfmon.GetFrame(), context->ZBUF.Block(), context->ZBUF.PSM);
+			if(s_savez) ds->m_texture.Save(str);
 			// if(s_savez) m_dev.SaveToFileD32S8X24(ds->m_texture, str); // TODO
 		}
 	}
diff --git a/gsdx/GSRendererHW10.cpp b/gsdx/GSRendererHW10.cpp
index 1548ccb..1101de5 100644
--- a/gsdx/GSRendererHW10.cpp
+++ b/gsdx/GSRendererHW10.cpp
@@ -220,7 +220,22 @@ void GSRendererHW10::Draw(int prim, Texture& rt, Texture& ds, GSTextureCache<Dev
 {
 	GSDrawingEnvironment& env = m_env;
 	GSDrawingContext* context = m_context;
+/*
+	if(s_dump)
+	{
+		TRACE(_T("\n"));
 
+		TRACE(_T("PRIM = %d, ZMSK = %d, ZTE = %d, ZTST = %d, ATE = %d, ATST = %d, AFAIL = %d, AREF = %02x\n"), 
+			PRIM->PRIM, context->ZBUF.ZMSK, 
+			context->TEST.ZTE, context->TEST.ZTST,
+			context->TEST.ATE, context->TEST.ATST, context->TEST.AFAIL, context->TEST.AREF);
+
+		for(int i = 0; i < m_count; i++)
+		{
+			TRACE(_T("[%d] %3.0f %3.0f %3.0f %3.0f\n"), i, (float)m_vertices[i].p.x / 16, (float)m_vertices[i].p.y / 16, (float)m_vertices[i].p.z, (float)m_vertices[i].a);
+		}
+	}
+*/
 	D3D10_PRIMITIVE_TOPOLOGY topology;
 	int prims = 0;
 
diff --git a/gsdx/GSRendererSW.h b/gsdx/GSRendererSW.h
index 30b77b2..7046b06 100644
--- a/gsdx/GSRendererSW.h
+++ b/gsdx/GSRendererSW.h
@@ -28,16 +28,37 @@
 extern const GSVector4 g_pos_scale;
 
 template <class Device>
-class GSRendererSW : public GSRendererT<Device, GSVertexSW>, public IDrawAsync
+class GSRendererSW : public GSRendererT<Device, GSVertexSW>
 {
-	typedef GSVertexSW Vertex;
-
 protected:
 	GSRasterizerList m_rl;
 	GSTextureCacheSW* m_tc;
 	Texture m_texture[2];
 	bool m_reset;
 
+	__declspec(align(16)) struct VertexTrace
+	{
+		GSVertexSW v; 
+
+		union
+		{
+			DWORD value; 
+			struct {DWORD s:1, t:1, q:1, _pad:1, r:1, g:1, b:1, a:1;};
+			struct {DWORD stq:4, rgba:4;};
+		} eq;
+
+		bool first;
+
+		void Reset()
+		{
+			first = true;
+			eq.value = 0xffffffff;
+		}
+
+		VertexTrace() {Reset();}
+
+	} m_vtrace;
+
 	void Reset() 
 	{
 		// TODO: GSreset can come from the main thread too => crash
@@ -45,6 +66,8 @@ protected:
 
 		m_reset = true;
 
+		m_vtrace.Reset();
+
 		__super::Reset();
 	}
 
@@ -116,35 +139,44 @@ protected:
 
 	void VertexKick(bool skip)
 	{
-		Vertex& v = m_vl.AddTail();
+		GSVertexSW v;
 
-		int x = (int)m_v.XYZ.X - (int)m_context->XYOFFSET.OFX;
-		int y = (int)m_v.XYZ.Y - (int)m_context->XYOFFSET.OFY;
+		GSVector4i p((int)m_v.XYZ.X, (int)m_v.XYZ.Y, 0, (int)m_v.FOG.F);
+		GSVector4i o((int)m_context->XYOFFSET.OFX, (int)m_context->XYOFFSET.OFY);
 
-		v.p = GSVector4(x, y, 0, (int)m_v.FOG.F) * g_pos_scale;
+		v.p = GSVector4(p - o) * g_pos_scale;
 		v.p.z = (float)min(m_v.XYZ.Z, 0xffffff00); // max value which can survive the DWORD=>float=>DWORD conversion
 
-		v.c = (DWORD)m_v.RGBAQ.ai32[0];
-		v.c *= 128.0f;
+		v.c = GSVector4((DWORD)m_v.RGBAQ.ai32[0]) * 128.0f;
 
 		if(PRIM->TME)
 		{
 			if(PRIM->FST)
 			{
-				v.t.x = (float)(int)m_v.UV.U;
-				v.t.y = (float)(int)m_v.UV.V;
-				v.t *= 0x10000 >> 4;
+				v.t = GSVector4(GSVector4i((int)m_v.UV.U, (int)m_v.UV.V) << (16 - 4));
 				v.t.z = 1.0f;
 			}
 			else
 			{
-				v.t.x = m_v.ST.S;
-				v.t.y = m_v.ST.T;
+				v.t = GSVector4(m_v.ST.S, m_v.ST.T, 0.0f, 0.0f);
 				v.t *= GSVector4((float)(0x10000 << m_context->TEX0.TW), (float)(0x10000 << m_context->TEX0.TH));
 				v.t.z = m_v.RGBAQ.Q;
 			}
 		}
 
+		if(m_vtrace.first)
+		{
+			m_vtrace.v.t = v.t;
+			m_vtrace.v.c = v.c;
+			m_vtrace.first = false;
+		}
+		else
+		{
+			m_vtrace.eq.value &= (m_vtrace.v.t == v.t).mask() | ((m_vtrace.v.c == v.c).mask() << 4); // v.p not needed
+		}
+
+		m_vl.AddTail() = v;
+
 		__super::VertexKick(skip);
 	}
 
@@ -158,7 +190,7 @@ protected:
 		return (v0 | v1).mask() & 3;
 	}
 
-	void DrawingKickPoint(Vertex* v, int& count)
+	void DrawingKickPoint(GSVertexSW* v, int& count)
 	{
 		GSVector4 p0 = v[0].p;
 		GSVector4 p1 = v[0].p;
@@ -170,7 +202,7 @@ protected:
 		}
 	}
 	
-	void DrawingKickLine(Vertex* v, int& count)
+	void DrawingKickLine(GSVertexSW* v, int& count)
 	{
 		GSVector4 p0 = v[0].p.maxv(v[1].p);
 		GSVector4 p1 = v[0].p.minv(v[1].p);
@@ -187,7 +219,7 @@ protected:
 		}
 	}
 
-	void DrawingKickTriangle(Vertex* v, int& count)
+	void DrawingKickTriangle(GSVertexSW* v, int& count)
 	{
 		GSVector4 p0 = v[0].p.maxv(v[1].p).maxv(v[2].p);
 		GSVector4 p1 = v[0].p.minv(v[1].p).minv(v[2].p);
@@ -205,7 +237,7 @@ protected:
 		}
 	}
 
-	void DrawingKickSprite(Vertex* v, int& count)
+	void DrawingKickSprite(GSVertexSW* v, int& count)
 	{
 		GSVector4 p0 = v[0].p.maxv(v[1].p);
 		GSVector4 p1 = v[0].p.minv(v[1].p);
@@ -230,83 +262,286 @@ protected:
 
 	void Draw()
 	{
-		// TODO: lot to optimize here
+		const GSDrawingEnvironment& env = m_env;
+		const GSDrawingContext* context = m_context;
+		const GS_PRIM prim = (GS_PRIM)PRIM->PRIM;
+		const GS_PRIM_CLASS primclass = GSUtil::GetPrimClass(prim);
 
-		GSDrawingContext* context = m_context;
+		//
 
-		// sanity check
+		GSScanlineParam p;
+
+		p.vm = m_mem.m_vm32;
+
+		p.sel.dw = 0;
+
+		p.sel.fpsm = 3;
+		p.sel.zpsm = 3;
+		p.sel.atst = ATST_ALWAYS;
+		p.sel.tfx = TFX_NONE;
+		p.sel.abe = 255;
+
+		//
+
+		p.fm = context->FRAME.FBMSK;
+		p.zm = context->ZBUF.ZMSK || context->TEST.ZTE == 0 ? 0xffffffff : 0;
+
+		// 
 
 		if(context->TEST.ZTE && context->TEST.ZTST == ZTST_NEVER)
+		{
+			p.fm = 0xffffffff;
+			p.zm = 0xffffffff;
+		}
+
+		if(context->TEST.ATE)
+		{
+			bool pass = context->TEST.ATST != ATST_NEVER;
+
+			if((!PRIM->TME || !context->TEX0.TCC && context->TEX0.TFX != TFX_DECAL) && m_vtrace.eq.a)
+			{
+				// surprisingly large number of games leave alpha test on when alpha is constant
+
+				DWORD a = (DWORD)((int)m_vtrace.v.c.a >> 7);
+				DWORD aref = context->TEST.AREF;
+
+				switch(context->TEST.ATST)
+				{
+				case ATST_NEVER: pass = false; break;
+				case ATST_ALWAYS: pass = true; break;
+				case ATST_LESS: pass = a < aref; break;
+				case ATST_LEQUAL: pass = a <= aref; break;
+				case ATST_EQUAL: pass = a == aref; break;
+				case ATST_GEQUAL: pass = a >= aref; break;
+				case ATST_GREATER: pass = a > aref; break;
+				case ATST_NOTEQUAL: pass = a != aref; break;
+				default: __assume(0);
+				}
+			}
+
+			if(!pass)
+			{
+				switch(context->TEST.AFAIL)
+				{
+				case AFAIL_KEEP: p.fm = p.zm = 0xffffffff; break;
+				case AFAIL_FB_ONLY: p.zm = 0xffffffff; break;
+				case AFAIL_ZB_ONLY: p.fm = 0xffffffff; break;
+				case AFAIL_RGB_ONLY: p.fm |= 0xff000000; p.zm = 0xffffffff; break;
+				default: __assume(0);
+				}
+
+				// "don't care" values
+
+				p.sel.atst = ATST_ALWAYS;
+				p.sel.afail = 0;
+			}
+			else
+			{
+				p.sel.atst = context->TEST.ATST;
+				p.sel.afail = context->TEST.AFAIL;
+			}
+		}
+
+		bool fwrite = p.fm != 0xffffffff;
+		bool ftest = p.sel.atst != ATST_ALWAYS || context->TEST.DATE && context->FRAME.PSM != PSM_PSMCT24;
+
+		if(fwrite || ftest)
+		{
+			p.sel.fpsm = GSUtil::EncodePSM(context->FRAME.PSM);
+
+			if((primclass == GS_LINE_CLASS || primclass == GS_TRIANGLE_CLASS) && m_vtrace.eq.rgba != 15)
+			{
+				p.sel.iip = PRIM->IIP;
+			}
+
+			if(PRIM->TME)
+			{
+				p.sel.tfx = context->TEX0.TFX;
+				p.sel.tcc = context->TEX0.TCC;
+				p.sel.fst = PRIM->FST;
+				p.sel.ltf = context->TEX1.IsLinear();
+				p.sel.tlu = GSLocalMemory::m_psm[context->TEX0.PSM].pal > 0;
+
+				if(p.sel.iip == 0 && p.sel.tfx == TFX_MODULATE && p.sel.tcc)
+				{
+					if(m_vtrace.eq.rgba == 15 && (m_vtrace.v.c == GSVector4(128.0f * 128.0f)).alltrue())
+					{
+						// modulate does not do anything when vertex color is 0x80
+
+						p.sel.tfx = TFX_DECAL;
+					}
+				}
+
+				if(p.sel.fst == 0)
+				{
+					// skip per pixel division if q is constant
+
+					GSVertexSW* v = m_vertices;
+
+					if(m_vtrace.eq.q)
+					{
+						p.sel.fst = 1;
+
+						GSVector4 w = v[0].t.zzzz().rcpnr();
+
+						for(int i = 0, j = m_count; i < j; i++)
+						{
+							v[i].t *= w;
+						}
+					}
+					else if(prim == GS_SPRITE)
+					{
+						p.sel.fst = 1;
+
+						for(int i = 0, j = m_count; i < j; i += 2)
+						{
+							GSVector4 w = v[i + 1].t.zzzz().rcpnr();
+
+							v[i + 0].t *= w;
+							v[i + 1].t *= w;
+						}
+					}
+				}
+
+				if(p.sel.fst && p.sel.ltf)
+				{
+					// if q is constant we can do the half pel shift for bilinear sampling on the vertices
+
+					GSVector4 half((float)0x8000, (float)0x8000, 0.0f, 0.0f);
+
+					for(int i = 0; i < m_count; i++)
+					{
+						m_vertices[i].t -= half;
+					}
+				}
+
+				int w = 1 << context->TEX0.TW;
+				int h = 1 << context->TEX0.TH;
+
+				int wms = context->CLAMP.WMS;
+				int wmt = context->CLAMP.WMT;
+
+				int minu = (int)context->CLAMP.MINU;
+				int minv = (int)context->CLAMP.MINV;
+				int maxu = (int)context->CLAMP.MAXU;
+				int maxv = (int)context->CLAMP.MAXV;
+
+				CRect r = CRect(0, 0, w, h);
+
+				switch(wms)
+				{
+				case CLAMP_REPEAT: // TODO
+					break;
+				case CLAMP_CLAMP: // TODO
+					break;
+				case CLAMP_REGION_REPEAT:
+					if(r.left < minu) r.left = minu;
+					if(r.right > maxu + 1) r.right = maxu + 1;
+					break;
+				case CLAMP_REGION_CLAMP:
+					r.left = maxu; 
+					r.right = r.left + (minu + 1);
+					break;
+				default: 
+					__assume(0);
+				}
+
+				switch(wmt)
+				{
+				case CLAMP_REPEAT: // TODO
+					break;
+				case CLAMP_CLAMP: // TODO
+					break;
+				case CLAMP_REGION_REPEAT:
+					if(r.top < minv) r.top = minv;
+					if(r.bottom > maxv + 1) r.bottom = maxv + 1;
+					break;
+				case CLAMP_REGION_CLAMP:
+					r.top = maxv; 
+					r.bottom = r.top + (minv + 1);
+					break;
+				default:
+					__assume(0);
+				}
+
+				r &= CRect(0, 0, w, h);
+
+				const GSTextureCacheSW::GSTexture* t = m_tc->Lookup(context->TEX0, env.TEXA, &r);
+
+				if(!t) {ASSERT(0); return;}
+
+				m_mem.m_clut.Read32(context->TEX0, env.TEXA);
+
+				p.tex = t->m_buff;
+				p.clut = m_mem.m_clut;
+				p.tw = t->m_tw;
+			}
+
+			p.sel.fge = PRIM->FGE;
+
+			if(context->FRAME.PSM != PSM_PSMCT24)
+			{
+				p.sel.date = context->TEST.DATE;
+			}
+
+			if(PRIM->ABE)
+			{
+				if(!context->ALPHA.IsOpaque())
+				{
+					p.sel.abe = context->ALPHA.ai32[0];
+					p.sel.pabe = env.PABE.PABE;
+				}
+				else
+				{
+					// printf("opaque\n");
+				}
+
+				if(PRIM->AA1)
+				{
+					// TODO: automatic alpha blending (ABE=1, A=0 B=1 C=0 D=1)
+				}
+			}
+
+			if(p.sel.date 
+			|| p.sel.abe != 255 
+			|| p.sel.atst != ATST_ALWAYS && p.sel.afail == AFAIL_RGB_ONLY 
+			|| p.fm != 0 && p.fm != 0xffffffff)
+			{
+				p.sel.rfb = 1;
+			}
+		}
+
+		bool zwrite = p.zm != 0xffffffff;
+		bool ztest = context->TEST.ZTE && context->TEST.ZTST > 1;
+
+		if(zwrite || ztest)
+		{
+			p.sel.zpsm = GSUtil::EncodePSM(context->ZBUF.PSM);
+			p.sel.ztst = ztest ? context->TEST.ZTST : 1;
+		}
+
+		m_vtrace.Reset();
+
+		if((p.fm & p.zm) == 0xffffffff)
 		{
 			return;
 		}
 
-		//
-
-		const GSTextureCacheSW::GSTexture* texture = NULL;
-
-		if(PRIM->TME)
-		{
-			m_mem.m_clut.Read32(context->TEX0, m_env.TEXA);
-
-			int w = 1 << context->TEX0.TW;
-			int h = 1 << context->TEX0.TH;
-
-			int wms = context->CLAMP.WMS;
-			int wmt = context->CLAMP.WMT;
-
-			int minu = (int)context->CLAMP.MINU;
-			int minv = (int)context->CLAMP.MINV;
-			int maxu = (int)context->CLAMP.MAXU;
-			int maxv = (int)context->CLAMP.MAXV;
-
-			CRect r = CRect(0, 0, w, h);
-
-			switch(wms)
-			{
-			case 0: // TODO
-				break;
-			case 1: // TODO
-				break;
-			case 2:
-				if(r.left < minu) r.left = minu;
-				if(r.right > maxu + 1) r.right = maxu + 1;
-				break;
-			case 3:
-				r.left = maxu; 
-				r.right = r.left + (minu + 1);
-				break;
-			default: 
-				__assume(0);
-			}
-
-			switch(wmt)
-			{
-			case 0: // TODO
-				break;
-			case 1: // TODO
-				break;
-			case 2:
-				if(r.top < minv) r.top = minv;
-				if(r.bottom > maxv + 1) r.bottom = maxv + 1;
-				break;
-			case 3:
-				r.top = maxv; 
-				r.bottom = r.top + (minv + 1);
-				break;
-			default:
-				__assume(0);
-			}
-
-			r &= CRect(0, 0, w, h);
-
-			texture = m_tc->Lookup(context->TEX0, m_env.TEXA, &r);
-
-			if(!texture) {ASSERT(0); return;}
-		}
-
 		if(s_dump)
 		{
+/*
+			TRACE(_T("\n"));
+
+			TRACE(_T("PRIM = %d, ZMSK = %d, ZTE = %d, ZTST = %d, ATE = %d, ATST = %d, AFAIL = %d, AREF = %02x\n"), 
+				PRIM->PRIM, context->ZBUF.ZMSK, 
+				context->TEST.ZTE, context->TEST.ZTST,
+				context->TEST.ATE, context->TEST.ATST, context->TEST.AFAIL, context->TEST.AREF);
+
+			for(int i = 0; i < m_count; i++)
+			{
+				TRACE(_T("[%d] %3.0f %3.0f %3.0f %3.0f\n"), i, m_vertices[i].p.x, m_vertices[i].p.y, m_vertices[i].p.z, m_vertices[i].c.w / 128);
+			}
+*/
 			CString str;
 			str.Format(_T("c:\\temp1\\_%05d_f%I64d_tex_%05x_%d.bmp"), s_n++, m_perfmon.GetFrame(), (int)m_context->TEX0.TBP0, (int)m_context->TEX0.PSM);
 			if(PRIM->TME) if(s_save) {m_mem.SaveBMP(str, m_context->TEX0.TBP0, m_context->TEX0.TBW, m_context->TEX0.PSM, 1 << m_context->TEX0.TW, 1 << m_context->TEX0.TH);}
@@ -317,16 +552,43 @@ protected:
 		}
 
 		//
+/*
+static FILE* s_fp = NULL;
+static UINT64 s_frame = 0;
+static __int64 s_total = 0;
+if(!s_fp) s_fp = fopen("c:\\log.txt", "w");
+UINT64 frame = m_perfmon.GetFrame();
+if(s_frame != frame) 
+{
+	fprintf(s_fp, "=> %I64d\n", s_total); 
+	s_frame = frame; 
+	s_total = 0;
+}
+__int64 start = __rdtsc();
+*/
+		GSRasterizerData data;
 
-		int prims = m_rl.Draw(m_vertices, m_count, texture);
+		data.scissor = GetScissor();
+		data.primclass = primclass;
+		data.vertices = m_vertices;
+		data.count = m_count;
+		data.param = &p;
+
+		int prims = m_rl.Draw(&data);
 		
 		m_perfmon.Put(GSPerfMon::Prim, prims);
 		m_perfmon.Put(GSPerfMon::Draw, 1);
 		
 		int pixels = m_rl.GetPixels();
 
-		m_perfmon.Put(GSPerfMon::Fillrate, pixels); 
+		m_perfmon.Put(GSPerfMon::Fillrate, pixels);
 
+/*
+__int64 diff = __rdtsc() - start;
+s_total += diff;
+//if(pixels > 50000)
+fprintf(s_fp, "[%I64d, %d, %d, %d] %08x, diff = %I64d /prim = %I64d /pixel = %I64d \n", frame, PRIM->PRIM, prims, pixels, p.sel, diff, diff / prims, pixels > 0 ? diff / pixels : 0);
+*/
 		// TODO
 
 		{
@@ -341,7 +603,7 @@ protected:
 				br = br.maxv(p);
 			}
 
-			GSVector4i scissor = GetScissor();
+			GSVector4i scissor = data.scissor;
 
 			CRect r;
 
@@ -351,14 +613,18 @@ protected:
 			r.bottom = max(scissor.y, min(scissor.w, (int)br.y));
 
 			GIFRegBITBLTBUF BITBLTBUF;
-			
-			BITBLTBUF.DBP = context->FRAME.Block();
+
 			BITBLTBUF.DBW = context->FRAME.FBW;
-			BITBLTBUF.DPSM = context->FRAME.PSM;
 
-			m_tc->InvalidateVideoMem(BITBLTBUF, r);
+			if(p.fm != 0xffffffff)
+			{
+				BITBLTBUF.DBP = context->FRAME.Block();
+				BITBLTBUF.DPSM = context->FRAME.PSM;
 
-			if(context->DepthWrite())
+				m_tc->InvalidateVideoMem(BITBLTBUF, r);
+			}
+
+			if(p.zm != 0xffffffff)
 			{
 				BITBLTBUF.DBP = context->ZBUF.Block();
 				BITBLTBUF.DPSM = context->ZBUF.PSM;
@@ -370,68 +636,13 @@ protected:
 		if(s_dump)
 		{
 			CString str;
-			str.Format(_T("c:\\temp1\\_%05d_f%I64d_rt1_%05x_%d.bmp"), s_n++, m_perfmon.GetFrame(), m_context->FRAME.Block(), m_context->FRAME.PSM);
+			str.Format(_T("c:\\temp1\\_%05d_f%I64d_rt1_%05x_%d_%d.bmp"), s_n++, m_perfmon.GetFrame(), m_context->FRAME.Block(), m_context->FRAME.PSM);
 			if(s_save) {m_mem.SaveBMP(str, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameSize(1).cx, 512);}//GetFrameSize(1).cy);
 			str.Format(_T("c:\\temp1\\_%05d_f%I64d_rz1_%05x_%d.bmp"), s_n-1, m_perfmon.GetFrame(), m_context->ZBUF.Block(), m_context->ZBUF.PSM);
 			if(s_savez) {m_mem.SaveBMP(str, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameSize(1).cx, 512);}
 		}
 	}
 
-	int DrawAsync(GSRasterizer* r)
-	{
-		GSDrawingContext* context = m_context;
-
-		//
-
-		bool solid = true;
-
-		if(PRIM->IIP || PRIM->TME || PRIM->ABE || PRIM->FGE
-		|| context->TEST.ZTE && context->TEST.ZTST != ZTST_ALWAYS 
-		|| context->TEST.ATE && context->TEST.ATST != ATST_ALWAYS
-		|| context->TEST.DATE
-		|| m_env.DTHE.DTHE
-		|| context->FRAME.FBMSK)
-		{
-			solid = false;
-		}
-
-		//
-
-		GSVector4i scissor = GetScissor();
-
-		int prims = 0;
-
-		switch(PRIM->PRIM)
-		{
-		case GS_POINTLIST:
-			prims = m_count;
-			for(int i = 0, j = m_count; i < j; i++) r->DrawPoint(&m_vertices[i], scissor);
-			break;
-		case GS_LINELIST: 
-		case GS_LINESTRIP: 
-			ASSERT(!(m_count & 1));
-			prims = m_count / 2;
-			for(int i = 0, j = m_count; i < j; i += 2) r->DrawLine(&m_vertices[i], scissor);
-			break;
-		case GS_TRIANGLELIST: 
-		case GS_TRIANGLESTRIP: 
-		case GS_TRIANGLEFAN:
-			ASSERT(!(m_count % 3));
-			prims = m_count / 3;
-			for(int i = 0, j = m_count; i < j; i += 3) r->DrawTriangle(&m_vertices[i], scissor);
-			break;
-		case GS_SPRITE:
-			ASSERT(!(m_count & 1));
-			prims = m_count / 2;
-			for(int i = 0, j = m_count; i < j; i += 2) r->DrawSprite(&m_vertices[i], scissor, solid);
-			break;
-		default:
-			__assume(0);
-		}
-
-		return prims;
-	}
-
 	void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, CRect r)
 	{
 		m_tc->InvalidateVideoMem(BITBLTBUF, r);
@@ -441,7 +652,7 @@ public:
 	GSRendererSW(BYTE* base, bool mt, void (*irq)(), int nloophack, const GSRendererSettings& rs, int threads)
 		: GSRendererT(base, mt, irq, nloophack, rs)
 	{
-		m_rl.Create<GSDrawScanline>(this, this, threads);
+		m_rl.Create<GSDrawScanline>(this, threads);
 
 		m_tc = new GSTextureCacheSW(this);
 
diff --git a/gsdx/GSTexture10.cpp b/gsdx/GSTexture10.cpp
index 6e53bd4..de5daf8 100644
--- a/gsdx/GSTexture10.cpp
+++ b/gsdx/GSTexture10.cpp
@@ -111,7 +111,60 @@ void GSTexture10::Unmap()
 
 bool GSTexture10::Save(CString fn, bool dds)
 {
-	return SUCCEEDED(D3DX10SaveTextureToFile(m_texture, dds ? D3DX10_IFF_DDS : D3DX10_IFF_BMP, fn));
+	CComPtr<ID3D10Resource> res;
+
+	if(m_desc.BindFlags & D3D10_BIND_DEPTH_STENCIL)
+	{
+		HRESULT hr;
+
+		D3D10_TEXTURE2D_DESC desc;
+
+		memset(&desc, 0, sizeof(desc));
+
+		m_texture->GetDesc(&desc);
+
+		desc.Usage = D3D10_USAGE_STAGING;
+		desc.BindFlags = 0;
+		desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
+
+		CComPtr<ID3D10Texture2D> src, dst;
+
+		hr = m_dev->CreateTexture2D(&desc, NULL, &src);
+
+		m_dev->CopyResource(src, m_texture);
+
+		desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+		desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
+
+		hr = m_dev->CreateTexture2D(&desc, NULL, &dst);
+
+		D3D10_MAPPED_TEXTURE2D sm, dm;
+
+		hr = src->Map(0, D3D10_MAP_READ, 0, &sm);
+		hr = dst->Map(0, D3D10_MAP_WRITE, 0, &dm);
+
+		BYTE* s = (BYTE*)sm.pData;
+		BYTE* d = (BYTE*)dm.pData;
+
+		for(UINT y = 0; y < desc.Height; y++, s += sm.RowPitch, d += dm.RowPitch)
+		{
+			for(UINT x = 0; x < desc.Width; x++)
+			{
+				((UINT*)d)[x] = (UINT)(((float*)s)[x*2] * UINT_MAX);
+			}
+		}
+
+		src->Unmap(0);
+		dst->Unmap(0);
+
+		res = dst;
+	}
+	else
+	{
+		res = m_texture;
+	}
+
+	return SUCCEEDED(D3DX10SaveTextureToFile(res, dds ? D3DX10_IFF_DDS : D3DX10_IFF_BMP, fn));
 }
 
 ID3D10Texture2D* GSTexture10::operator->()
diff --git a/gsdx/GSTexture9.cpp b/gsdx/GSTexture9.cpp
index faf6c46..6c020bf 100644
--- a/gsdx/GSTexture9.cpp
+++ b/gsdx/GSTexture9.cpp
@@ -140,12 +140,55 @@ void GSTexture9::Unmap()
 
 bool GSTexture9::Save(CString fn, bool dds)
 {
-	if(CComPtr<IDirect3DSurface9> surface = *this)
+	CComPtr<IDirect3DResource9> res;
+
+	if(m_desc.Usage & D3DUSAGE_DEPTHSTENCIL)
+	{
+		HRESULT hr;
+
+		D3DSURFACE_DESC desc;
+
+		m_surface->GetDesc(&desc);
+
+		if(desc.Format != D3DFMT_D32F_LOCKABLE)
+			return false;
+
+		CComPtr<IDirect3DSurface9> surface;
+		
+		hr = m_dev->CreateOffscreenPlainSurface(desc.Width, desc.Height, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL);
+
+		D3DLOCKED_RECT slr, dlr;
+
+		hr = m_surface->LockRect(&slr, NULL, 0);
+		hr = surface->LockRect(&dlr, NULL, 0);
+
+		BYTE* s = (BYTE*)slr.pBits;
+		BYTE* d = (BYTE*)dlr.pBits;
+
+		for(UINT y = 0; y < desc.Height; y++, s += slr.Pitch, d += dlr.Pitch)
+		{
+			for(UINT x = 0; x < desc.Width; x++)
+			{
+				((float*)d)[x] = ((float*)s)[x];
+			}
+		}
+
+		m_surface->UnlockRect();
+		surface->UnlockRect();
+
+		res = surface;
+	}
+	else
+	{
+		res = m_surface;
+	}
+
+	if(CComQIPtr<IDirect3DSurface9> surface = res)
 	{
 		return SUCCEEDED(D3DXSaveSurfaceToFile(fn, dds ? D3DXIFF_DDS : D3DXIFF_BMP, surface, NULL, NULL));
 	}
 
-	if(CComPtr<IDirect3DTexture9> texture = *this)
+	if(CComQIPtr<IDirect3DTexture9> texture = res)
 	{
 		return SUCCEEDED(D3DXSaveTextureToFile(fn, dds ? D3DXIFF_DDS : D3DXIFF_BMP, texture, NULL));
 	}
diff --git a/gsdx/GSUtil.cpp b/gsdx/GSUtil.cpp
index 19f7a0a..dacd4ab 100644
--- a/gsdx/GSUtil.cpp
+++ b/gsdx/GSUtil.cpp
@@ -33,14 +33,14 @@ static struct GSUtilMaps
 
 	struct GSUtilMaps()
 	{
-		PrimClassField[GS_POINTLIST] = 0;
-		PrimClassField[GS_LINELIST] = 1;
-		PrimClassField[GS_LINESTRIP] = 1;
-		PrimClassField[GS_TRIANGLELIST] = 2;
-		PrimClassField[GS_TRIANGLESTRIP] = 2;
-		PrimClassField[GS_TRIANGLEFAN] = 2;
-		PrimClassField[GS_SPRITE] = 3;
-		PrimClassField[GS_INVALID] = (BYTE)-1;
+		PrimClassField[GS_POINTLIST] = GS_POINT_CLASS;
+		PrimClassField[GS_LINELIST] = GS_LINE_CLASS;
+		PrimClassField[GS_LINESTRIP] = GS_LINE_CLASS;
+		PrimClassField[GS_TRIANGLELIST] = GS_TRIANGLE_CLASS;
+		PrimClassField[GS_TRIANGLESTRIP] = GS_TRIANGLE_CLASS;
+		PrimClassField[GS_TRIANGLEFAN] = GS_TRIANGLE_CLASS;
+		PrimClassField[GS_SPRITE] = GS_SPRITE_CLASS;
+		PrimClassField[GS_INVALID] = GS_INVALID_CLASS;
 
 		PrimVertexCount[GS_POINTLIST] = 1;
 		PrimVertexCount[GS_LINELIST] = 2;
@@ -82,9 +82,9 @@ static struct GSUtilMaps
 
 } s_maps;
 
-DWORD GSUtil::GetPrimClass(DWORD prim)
+GS_PRIM_CLASS GSUtil::GetPrimClass(DWORD prim)
 {
-	return s_maps.PrimClassField[prim];
+	return (GS_PRIM_CLASS)s_maps.PrimClassField[prim];
 }
 
 DWORD GSUtil::GetPrimVertexCount(DWORD prim)
diff --git a/gsdx/GSUtil.h b/gsdx/GSUtil.h
index 6ef5b32..4c3c495 100644
--- a/gsdx/GSUtil.h
+++ b/gsdx/GSUtil.h
@@ -26,7 +26,7 @@
 class GSUtil
 {
 public:
-	static DWORD GetPrimClass(DWORD prim);
+	static GS_PRIM_CLASS GetPrimClass(DWORD prim);
 	static DWORD GetPrimVertexCount(DWORD prim);
 
 	static bool HasSharedBits(DWORD spsm, DWORD dpsm);
diff --git a/gsdx/GSVector.h b/gsdx/GSVector.h
index efe330b..bd5ec30 100644
--- a/gsdx/GSVector.h
+++ b/gsdx/GSVector.h
@@ -85,6 +85,11 @@ public:
 			);
 	}
 
+	GSVector4i(int x, int y) 
+	{
+		m = _mm_unpacklo_epi32(_mm_cvtsi32_si128(x), _mm_cvtsi32_si128(y));
+	}
+
 	GSVector4i(char b0, char b1, char b2, char b3, char b4, char b5, char b6, char b7, char b8, char b9, char b10, char b11, char b12, char b13, char b14, char b15) 
 	{
 		m = _mm_set_epi8(b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0);
@@ -1865,6 +1870,11 @@ public:
 		m = _mm_cvtepi32_ps(_mm_set_epi32(w, z, y, x));
 	}
 
+	GSVector4(int x, int y)
+	{
+		m = _mm_cvtepi32_ps(_mm_unpacklo_epi32(_mm_cvtsi32_si128(x), _mm_cvtsi32_si128(y)));
+	}
+
 	GSVector4(const GSVector4& v) 
 	{
 		m = v.m;
@@ -2125,6 +2135,11 @@ public:
 		return GSVector4(_mm_setzero_ps());
 	}
 
+	static GSVector4 invzero() 
+	{
+		return zero() == zero();
+	}
+
 	static GSVector4 ps0123()
 	{
 		return GSVector4(m_ps0123);
diff --git a/gsdx/GSVertex.h b/gsdx/GSVertex.h
index 08799ab..06fdf74 100644
--- a/gsdx/GSVertex.h
+++ b/gsdx/GSVertex.h
@@ -81,6 +81,7 @@ struct GSVertexPT2
 
 struct GSVertexNull 
 {
+	GSVector4 p;
 };
 
 #pragma pack(pop)