diff --git a/pcsx2/Elfheader.c b/pcsx2/Elfheader.c
index f405089f0f..8763149bc5 100644
--- a/pcsx2/Elfheader.c
+++ b/pcsx2/Elfheader.c
@@ -31,8 +31,8 @@
 u32 ElfCRC;
 
 typedef struct {
-    u8	e_ident[16];    //0x7f,"ELF"  (ELF file identifier)
-    u16	e_type;         //ELF type: 0=NONE, 1=REL, 2=EXEC, 3=SHARED, 4=CORE
+	u8	e_ident[16];	//0x7f,"ELF"  (ELF file identifier)
+	u16	e_type;		 //ELF type: 0=NONE, 1=REL, 2=EXEC, 3=SHARED, 4=CORE
 	u16	e_machine;      //Processor: 8=MIPS R3000
 	u32	e_version;      //Version: 1=current
 	u32	e_entry;        //Entry point address
@@ -72,7 +72,7 @@ notes1
 
 typedef struct {
 	u32	sh_name;        //No. to the index of the Section header stringtable index
-    u32	sh_type;        //See notes2
+	u32	sh_type;        //See notes2
 	u32	sh_flags;       //see notes3
 	u32	sh_addr;        //Section start address
 	u32	sh_offset;      //Offset from start of file to section
@@ -446,22 +446,6 @@ BOOL loadSectionHeaders( char * Exepath )
 		if ( elfSectH[i].sh_flags & 0x2 ) {  
 			//2002-09-19 (Florin)
 			args_ptr = min( args_ptr, elfSectH[ i ].sh_addr & 0x1ffffff );
-			//---------------
-/*			if (elfSectH[i].sh_offset < elfsize) {
-				int size;
-
-				if ((elfSectH[i].sh_size + elfSectH[i].sh_offset) > elfsize) {
-					size = elfsize - elfSectH[i].sh_offset;
-				} else {
-					size = elfSectH[i].sh_size;
-				}
-				memcpy(&PS2MEM_BASE[ elfSectH[ i ].sh_addr &0x1ffffff ],
-					   &elfdata[elfSectH[i].sh_offset],
-					   size);
-			}
-#ifdef ELF_LOG  
-			ELF_LOG( "\t*LOADED*" );
-#endif*/
 		}
 #ifdef ELF_LOG  
       ELF_LOG("\n");
@@ -548,12 +532,7 @@ BOOL loadSectionHeaders( char * Exepath )
 
 		for ( i = 1; i < (int)( elfSectH[ i_st ].sh_size / sizeof( Elf32_Sym ) ); i++ ) {
 			if ( ( eS[ i ].st_value != 0 ) && ( ELF32_ST_TYPE( eS[ i ].st_info ) == 2 ) ) {
-//				SysPrintf("%x:%s\n", eS[i].st_value, &SymNames[eS[i].st_name]);
 				disR5900AddSym( eS[i].st_value, &SymNames[ eS[ i ].st_name ] );
-/*				if (!strcmp(&SymNames[eS[i].st_name], "sceSifCheckStatRpc")) {
-					psMu32(eS[i].st_value & 0x1ffffff) = (0x3b << 26) | 1;
-					SysPrintf("found sceSifCheckStatRpc!!\n");
-				}*/
 			}
 		}
 	}
@@ -587,15 +566,9 @@ int loadElfFile(char *filename) {
 	if (elfdata == NULL) return -1;
 	readFile(filename, (char*)elfdata, 0, elfsize);
 
-/*	{
-		FILE *f = fopen("game.elf", "wb");
-		fwrite(elfdata, 1, elfsize, f);
-		fclose(f);
-	}*/
-
 	//2002-09-19 (Florin)
 	args_ptr = 0xFFFFFFFF;	//big value, searching for minimum
-	//-------------------
+	
 	loadHeaders( filename );
 	cpuRegs.pc = elfHeader->e_entry; //set pc to proper place 
 	loadProgramHeaders( filename );
@@ -609,7 +582,6 @@ int loadElfFile(char *filename) {
 
 	//2002-09-19 (Florin)
 	cpuRegs.GPR.n.a0.UL[0] = parseCommandLine( filename );
-	//---------------
 
 	for ( i = 0; i < 0x100000; i++ ) {
 		if ( strcmp( "rom0:OSDSYS", (char*)PSM( i ) ) == 0 ) {
@@ -652,50 +624,55 @@ int loadElfFile(char *filename) {
 extern int g_FFXHack;
 extern int path3hack;
 int g_VUGameFixes = 0;
-void LoadGameSpecificSettings()
+
+// fixme - this should be moved to patches or eliminated
+void LoadGameSpecificSettings() 
 {
-    // default
-    g_VUGameFixes = 0;
-    g_FFXHack = 0;
+	// default
+	g_VUGameFixes = 0;
+	g_FFXHack = 0;
 
-    switch(ElfCRC) {
-        case 0x0c414549: // spacefisherman, missing gfx
-		    g_VUGameFixes |= VUFIX_SIGNEDZERO;
-            break;
-        case 0x4C9EE7DF: // crazy taxi (u)
-        case 0xC9C145BF: // crazy taxi, missing gfx
-            g_VUGameFixes |= VUFIX_EXTRAFLAGS;
-            break;
+	switch(ElfCRC) {
+		// The code involving VUFIX_SIGNEDZERO & VUFIX_EXTRAFLAGS
+		// is no longer in pcsx2.
+		
+		//case 0x0c414549: // spacefisherman, missing gfx
+		//	g_VUGameFixes |= VUFIX_SIGNEDZERO;
+		//	break;
+		//case 0x4C9EE7DF: // crazy taxi (u)
+		//case 0xC9C145BF: // crazy taxi, missing gfx
+		//	g_VUGameFixes |= VUFIX_EXTRAFLAGS;
+		//	break;
 
-        case 0xb99379b7: // erementar gerad (discolored chars)
-            g_VUGameFixes |= VUFIX_XGKICKDELAY2;
-            break;
+		case 0xb99379b7: // erementar gerad (discolored chars)
+			g_VUGameFixes |= VUFIX_XGKICKDELAY2;
+			break;
 		case 0xa08c4057:  //Sprint Cars (SLUS)
 		case 0x8b0725d5:  //Flinstones Bedrock Racing (SLES)
-			path3hack = 1;
+			path3hack = 1; // We can move this to patch files right now
 			break;
 
-        case 0x6a4efe60: // ffx(j)
+		case 0x6a4efe60: // ffx(j)
 		case 0xA39517AB: // ffx(e)
 		case 0xBB3D833A: // ffx(u)
 		case 0x941bb7d9: // ffx(g)
 		case 0xD9FC6310: // ffx int(j)
-        case 0xa39517ae: // ffx(f)
-        case 0xa39517a9: // ffx(i)
-        case 0x658597e2: // ffx int
-        case 0x941BB7DE: // ffx(s)
-        case 0x3866CA7E: // ffx(asia)
-        case 0x48FE0C71: // ffx2 (u)
+		case 0xa39517ae: // ffx(f)
+		case 0xa39517a9: // ffx(i)
+		case 0x658597e2: // ffx int
+		case 0x941BB7DE: // ffx(s)
+		case 0x3866CA7E: // ffx(asia)
+		case 0x48FE0C71: // ffx2 (u)
 		case 0x9aac530d: // ffx2 (g)
 		case 0x9AAC5309: // ffx2 (e)
 		case 0x8A6D7F14: // ffx2 (j)
-        case 0x9AAC530B: // ffx2 (i)
-        case 0x9AAC530A: // ffx2 (f)
-        case 0xe1fd9a2d: // ffx2 last mission (?)
-        case 0x93f9b89a: // ffx2 demo (g)
-        case 0x304C115C: // harvest moon - awl
+		case 0x9AAC530B: // ffx2 (i)
+		case 0x9AAC530A: // ffx2 (f)
+		case 0xe1fd9a2d: // ffx2 last mission (?)
+		case 0x93f9b89a: // ffx2 demo (g)
+		case 0x304C115C: // harvest moon - awl
 		case 0xF0A6D880: // harvest moon - sth
-            g_FFXHack = 1;
-            break;		
+			g_FFXHack = 1;
+			break;		
 	}
 }
diff --git a/pcsx2/Misc.h b/pcsx2/Misc.h
index 7d797b4228..030caceddf 100644
--- a/pcsx2/Misc.h
+++ b/pcsx2/Misc.h
@@ -344,6 +344,7 @@ extern __forceinline long InterlockedExchange(long volatile* Target, long Value)
 	__asm__ __volatile__(".intel_syntax\n"
 						 "lock xchg [%0], %%eax\n"
 						 ".att_syntax\n" : : "r"(Target), "a"(Value) : "memory" );
+	return 0; // The only function that even looks at this is a debugging function
 }
 
 extern __forceinline long InterlockedExchangeAdd(long volatile* Addend, long Value)
@@ -351,6 +352,7 @@ extern __forceinline long InterlockedExchangeAdd(long volatile* Addend, long Val
 	__asm__ __volatile__(".intel_syntax\n"
 						 "lock xadd [%0], %%eax\n"
 						 ".att_syntax\n" : : "r"(Addend), "a"(Value) : "memory" );
+	return 0; // The return value is never looked at.
 }
 
 #endif
diff --git a/pcsx2/Patch.c b/pcsx2/Patch.c
index dbef16fa92..c2945b3ad2 100644
--- a/pcsx2/Patch.c
+++ b/pcsx2/Patch.c
@@ -15,7 +15,7 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  */
-
+	
 //
 // Includes
 //
@@ -24,8 +24,9 @@
 
 
 #include "PsxCommon.h"
-
 #include "Paths.h"
+#include "Patch.h"
+#include "VU.h"
 
 #ifdef _WIN32
 #include "windows/cheats/cheats.h"
@@ -38,74 +39,8 @@
 #pragma warning(disable:4996) //ignore the stricmp deprecated warning
 #endif
 
-#include "Patch.h"
-
-int g_ZeroGSOptions=0;
-
-//
-// Variables
-//
-PatchTextTable commands[] =
-{
-   { "comment", 1, patchFunc_comment },
-   { "gametitle", 2, patchFunc_gametitle },
-   { "patch", 3, patchFunc_patch },
-   { "fastmemory", 4, patchFunc_fastmemory }, // enable for faster but bugger mem (mvc2 is faster)
-   { "roundmode", 5, patchFunc_roundmode }, // changes rounding mode for floating point
-											// syntax: roundmode=X,Y
-											// possible values for X,Y: NEAR, DOWN, UP, CHOP
-											// X - EE rounding mode (default is NEAR)
-											// Y - VU rounding mode (default is CHOP)
-   { "zerogs", 6, patchFunc_zerogs }, // zerogs=hex
-   { "path3hack", 7, patchFunc_path3hack },
-   { "vunanmode",8, patchFunc_vunanmode },
-   { "", 0, NULL }
-};
-
-PatchTextTable dataType[] =
-{
-   { "byte", 1, NULL },
-   { "short", 2, NULL },
-   { "word", 3, NULL },
-   { "double", 4, NULL },
-   { "extended", 5, NULL },
-   { "", 0, NULL }
-};
-
-PatchTextTable cpuCore[] =
-{
-   { "EE", 1, NULL },
-   { "IOP", 2, NULL },
-   { "", 0, NULL }
-};
-
 IniPatch patch[ MAX_PATCH ];
-int patchnumber;
 
-
-//
-// Function Implementations
-//
-
-int PatchTableExecute( char * text1, char * text2, PatchTextTable * Table )
-{
-   int i = 0;
-
-   while ( Table[ i ].text[ 0 ] )
-   {
-      if ( !strcmp( Table[ i ].text, text1 ) )
-      {
-         if ( Table[ i ].func )
-         {
-            Table[ i ].func( text1, text2 );
-         }
-         break;
-      }
-      i++;
-   }
-
-   return Table[ i ].code;
-}
 u32 SkipCount=0;
 u32 IterationCount=0;
 u32 IterationIncrement=0;
@@ -114,226 +49,298 @@ u32 PrevCheatType=0;
 u32 PrevCheataddr = 0;
 u32 LastType = 0;
 
+int g_ZeroGSOptions=0;
+int patchnumber;
+extern int RunExe;
 
+char strgametitle[256]= {0};
+
+//
+// Variables
+//
+PatchTextTable commands[] =
+{
+	{ "comment", 1, patchFunc_comment },
+	{ "gametitle", 2, patchFunc_gametitle },
+	{ "patch", 3, patchFunc_patch },
+	{ "fastmemory", 4, patchFunc_fastmemory }, // enable for faster but bugger mem (mvc2 is faster)
+	{ "roundmode", 5, patchFunc_roundmode }, // changes rounding mode for floating point
+											// syntax: roundmode=X,Y
+											// possible values for X,Y: NEAR, DOWN, UP, CHOP
+											// X - EE rounding mode (default is NEAR)
+											// Y - VU rounding mode (default is CHOP)
+	{ "zerogs", 6, patchFunc_zerogs }, // zerogs=hex
+	{ "path3hack", 7, patchFunc_path3hack },
+	{ "vunanmode",8, patchFunc_vunanmode },
+	{ "ffxhack",9, patchFunc_ffxhack},
+	{ "xkickdelay",10, patchFunc_xkickdelay},
+	{ "", 0, NULL }
+};
+
+PatchTextTable dataType[] =
+{
+	{ "byte", 1, NULL },
+	{ "short", 2, NULL },
+	{ "word", 3, NULL },
+	{ "double", 4, NULL },
+	{ "extended", 5, NULL },
+	{ "", 0, NULL }
+};
+
+PatchTextTable cpuCore[] =
+{
+	{ "EE", 1, NULL },
+	{ "IOP", 2, NULL },
+	{ "", 0, NULL }
+};
+
+//
+// Function Implementations
+//
+
+int PatchTableExecute( char * text1, char * text2, PatchTextTable * Table )
+{
+	int i = 0;
+
+	while ( Table[ i ].text[ 0 ] )
+	{
+		if ( !strcmp( Table[ i ].text, text1 ) )
+		{
+			if ( Table[ i ].func )
+			{
+				Table[ i ].func( text1, text2 );
+			}
+			break;
+		}
+		i++;
+	}
+
+	return Table[ i ].code;
+}
 
 void _applypatch(int place, IniPatch *p) {
-	u32 Cheataddr = 0;	
 	u8 u8Val=0;
 	u16 u16Val=0;
 	u32 u32Val=0;
 	u32 i;
 
 	if (p->placetopatch != place) return;
-
 	if (p->enabled == 0) return;
-
-	if (p->cpu == 1) { //EE
-		if (p->type == 1) { //byte
-			memWrite8(p->addr, (u8)p->data);
-		} else
-		if (p->type == 2) { //short
-			memWrite16(p->addr, (u16)p->data);
-		} else
-		if (p->type == 3) { //word
-			memWrite32(p->addr, (u32)p->data);
-		} else
-		if (p->type == 4) { //double
-			memWrite64(p->addr, p->data);
-		}
-		if (p->type == 5) { //extended
-			
-			if (SkipCount > 0){
-				SkipCount--;
-			}else if (PrevCheatType == 0x3040)	{         // vvvvvvvv  00000000  Inc
-				memRead32(PrevCheataddr,&u32Val);
-				memWrite32(PrevCheataddr, u32Val+(p->addr));
-			    PrevCheatType = 0;
-			}else if (PrevCheatType == 0x3050){           // vvvvvvvv  00000000  Dec
-				memRead32(PrevCheataddr,&u32Val);
-				memWrite32(PrevCheataddr, u32Val-(p->addr));
-			    PrevCheatType = 0;
-			}else if (PrevCheatType == 0x4000){           // vvvvvvvv  iiiiiiii  
-				for(i=0;i<IterationCount;i++)
-					memWrite32((u32)(PrevCheataddr+(i*IterationIncrement)),(u32)((u32)p->addr+((u32)p->data*i)));
-			    PrevCheatType = 0;
-			}else if (PrevCheatType == 0x5000){           // dddddddd  iiiiiiii  
-				for(i=0;i<IterationCount;i++){
-					memRead8(PrevCheataddr+i,&u8Val);
-					memWrite8(((u32)p->data)+i,u8Val);
-				}
-			    PrevCheatType = 0;
-			}else if (PrevCheatType == 0x6000){           // 000Xnnnn  iiiiiiii  
-				// Get Number of pointers 
-				if (IterationCount == 0)
-					IterationCount = (u32)p->addr&0x0000FFFF;
+	
+	switch (p->cpu) {
+		case EE:
+			switch (p->type) {
+				case BYTE_T: 
+					memWrite8(p->addr, (u8)p->data);
+					break;
+				case SHORT_T:
+					memWrite16(p->addr, (u16)p->data);
+					break;
+				case WORD_T:
+					memWrite32(p->addr, (u32)p->data);
+					break;
+				case DOUBLE_T:
+					memWrite64(p->addr, p->data);
+					break;
+				case EXTENDED_T:
+						if (SkipCount > 0){
+							SkipCount--;
+						}
+					else switch (PrevCheatType) {
+						case 0x3040:                                                          // vvvvvvvv  00000000  Inc
+							memRead32(PrevCheataddr,&u32Val);
+							memWrite32(PrevCheataddr, u32Val+(p->addr));
+							PrevCheatType = 0;
+							break;
+						case 0x3050:                                                          // vvvvvvvv  00000000  Dec
+							memRead32(PrevCheataddr,&u32Val);
+							memWrite32(PrevCheataddr, u32Val-(p->addr));
+							PrevCheatType = 0;
+							break;
+						case 0x4000:							  // vvvvvvvv  iiiiiiii  
+							for(i=0;i<IterationCount;i++)
+								memWrite32((u32)(PrevCheataddr+(i*IterationIncrement)),(u32)(p->addr+((u32)p->data*i)));
+							PrevCheatType = 0;
+							break;
+						case 0x5000:							  // dddddddd  iiiiiiii  
+							for(i=0;i<IterationCount;i++){
+								memRead8(PrevCheataddr+i,&u8Val);
+								memWrite8(((u32)p->data)+i,u8Val);
+							}
+							PrevCheatType = 0;
+							break;
+						case 0x6000:							  // 000Xnnnn  iiiiiiii  
+							// Get Number of pointers 
+							if (IterationCount == 0)
+								IterationCount = (u32)p->addr&0x0000FFFF;
 		
-				// Read first pointer
-				LastType = ((u32)p->addr&0x000F0000)/0x10000;
-				memRead32(PrevCheataddr,&u32Val);	
-				PrevCheataddr =u32Val+(u32)p->data;
-				IterationCount--;
+							// Read first pointer
+							LastType = ((u32)p->addr&0x000F0000)/0x10000;
+							memRead32(PrevCheataddr,&u32Val);	
+							PrevCheataddr = u32Val+(u32)p->data;
+							IterationCount--;
 
-				// Check if needed to read another pointer
-				if (IterationCount == 0){
-					PrevCheatType = 0;
-					if (LastType==0x0)
-						memWrite8(PrevCheataddr,IterationIncrement&0xFF);
-					if (LastType==0x1)
-						memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
-					if (LastType==0x2)
-						memWrite32(PrevCheataddr,IterationIncrement);
-				}else{
-					PrevCheatType = 0x6001;
-       			}
-			
-			}else if (PrevCheatType == 0x6001){           // 000Xnnnn  iiiiiiii  
-						
-				// Read first pointer
-				memRead32(PrevCheataddr,&u32Val);	
-				PrevCheataddr =u32Val+(u32)p->addr;
-				IterationCount--;
+							// Check if needed to read another pointer
+							if (IterationCount == 0){
+								PrevCheatType = 0;
+								if (LastType==0x0)
+									memWrite8(PrevCheataddr,IterationIncrement&0xFF);
+								if (LastType==0x1)
+									memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
+								if (LastType==0x2)
+									memWrite32(PrevCheataddr,IterationIncrement);
+							}
+							else
+								PrevCheatType = 0x6001;
+						case 0x6001:							// 000Xnnnn  iiiiiiii  
+							// Read first pointer
+							memRead32(PrevCheataddr,&u32Val);	
+							PrevCheataddr =u32Val+(u32)p->addr;
+							IterationCount--;
 
-				// Check if needed to read another pointer
-				if (IterationCount == 0){
-					PrevCheatType = 0;
-					if (LastType==0x0)
-						memWrite8(PrevCheataddr,IterationIncrement&0xFF);
-					if (LastType==0x1)
-						memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
-					if (LastType==0x2)
-						memWrite32(PrevCheataddr,IterationIncrement);
-				}else{
-					memRead32(PrevCheataddr,&u32Val);	
-					PrevCheataddr =u32Val+(u32)p->data;
-					IterationCount--;
-					if (IterationCount == 0){
-						PrevCheatType = 0;
-						if (LastType==0x0)
-							memWrite8(PrevCheataddr,IterationIncrement&0xFF);
-						if (LastType==0x1)
-							memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
-						if (LastType==0x2)
-							memWrite32(PrevCheataddr,IterationIncrement);
-					}
+							// Check if needed to read another pointer
+							if (IterationCount == 0){
+								PrevCheatType = 0;
+								if (LastType==0x0)
+									memWrite8(PrevCheataddr,IterationIncrement&0xFF);
+								if (LastType==0x1)
+									memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
+								if (LastType==0x2)
+									memWrite32(PrevCheataddr,IterationIncrement);
+							}
+							else
+								{
+								memRead32(PrevCheataddr,&u32Val);	
+								PrevCheataddr =u32Val+(u32)p->data;
+								IterationCount--;
+								if (IterationCount == 0){
+									PrevCheatType = 0;
+									if (LastType==0x0)
+										memWrite8(PrevCheataddr,IterationIncrement&0xFF);
+									if (LastType==0x1)
+										memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
+									if (LastType==0x2)
+										memWrite32(PrevCheataddr,IterationIncrement);
+								}
+							}
+						default:
+							if ((p->addr&0xF0000000) == 0x00000000){ // 0aaaaaaa 0000000vv
+								memWrite8(p->addr&0x0FFFFFFF, (u8)p->data&0x000000FF);
+								PrevCheatType = 0;
+							}
+							else if ((p->addr&0xF0000000) == 0x10000000){ // 0aaaaaaa 0000vvvv
+								memWrite16(p->addr&0x0FFFFFFF, (u16)p->data&0x0000FFFF);
+								PrevCheatType = 0;
+							}
+							else if ((p->addr&0xF0000000) == 0x20000000){ // 0aaaaaaa vvvvvvvv
+								memWrite32(p->addr&0x0FFFFFFF, (u32)p->data);
+								PrevCheatType = 0;
+							}
+							else if ((p->addr&0xFFFF0000) == 0x30000000){ // 300000vv 0aaaaaaa  Inc
+								memRead8((u32)p->data,&u8Val);
+								memWrite8((u32)p->data, u8Val+(p->addr&0x000000FF));
+								PrevCheatType = 0;
+							}
+							else if ((p->addr&0xFFFF0000) == 0x30100000){ // 301000vv 0aaaaaaa  Dec
+								memRead8((u32)p->data,&u8Val);
+								memWrite8((u32)p->data, u8Val-(p->addr&0x000000FF));
+								PrevCheatType = 0;
+							}
+							else if ((p->addr&0xFFFF0000) == 0x30200000){  // 3020vvvv 0aaaaaaa Inc
+								memRead16((u32)p->data,&u16Val);
+								memWrite16((u32)p->data, u16Val+(p->addr&0x0000FFFF));
+								PrevCheatType = 0;
+							}
+							else if ((p->addr&0xFFFF0000) == 0x30300000){  // 3030vvvv 0aaaaaaa Dec
+								memRead16((u32)p->data,&u16Val);
+								memWrite16((u32)p->data, u16Val-(p->addr&0x0000FFFF));
+								PrevCheatType = 0;
+							}
+							else if ((p->addr&0xFFFF0000) == 0x30400000){  // 30400000 0aaaaaaa Inc	+ Another line
+								PrevCheatType= 0x3040;
+								PrevCheataddr= (u32)p->data;
+							}
+							else if ((p->addr&0xFFFF0000) == 0x30500000){	// 30500000 0aaaaaaa Inc	+ Another line
+								PrevCheatType= 0x3050;
+								PrevCheataddr= (u32)p->data;
+							}
+							else if ((p->addr&0xF0000000) == 0x40000000){	// 4aaaaaaa nnnnssss + Another line
+								IterationCount=((u32)p->data&0xFFFF0000)/0x10000;
+								IterationIncrement=((u32)p->data&0x0000FFFF)*4;
+								PrevCheataddr=(u32)p->addr&0x0FFFFFFF;
+								PrevCheatType= 0x4000;
+							}
+							else if  ((p->addr&0xF0000000) == 0x50000000){  // 5sssssss nnnnnnnn + Another line
+								PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
+								IterationCount=((u32)p->data);
+								PrevCheatType= 0x5000;
+							}
+							else if  ((p->addr&0xF0000000) == 0x60000000){ // 6aaaaaaa 000000vv + Another line/s
+								PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
+								IterationIncrement=((u32)p->data);
+								IterationCount=0;
+								PrevCheatType= 0x6000;
+							}
+							else if ((p->addr&0xF0000000) == 0x70000000) {
+								if  ((p->data&0x00F00000) == 0x00000000){	 // 7aaaaaaa 000000vv 
+									memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
+									memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val|(p->data&0x000000FF)));
+								}else if  ((p->data&0x00F00000) == 0x00100000){ // 7aaaaaaa 0010vvvv
+									memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
+									memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val|(p->data&0x0000FFFF)));
+								}else if  ((p->data&0x00F00000) == 0x00200000){ // 7aaaaaaa 002000vv
+									memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
+									memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val&(p->data&0x000000FF)));
+								}else if  ((p->data&0x00F00000) == 0x00300000){ // 7aaaaaaa 0030vvvv
+									memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
+									memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val&(p->data&0x0000FFFF)));
+								}else if  ((p->data&0x00F00000) == 0x00400000){ // 7aaaaaaa 004000vv
+									memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
+									memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val^(p->data&0x000000FF)));
+								}else if  ((p->data&0x00F00000) == 0x00500000){ // 7aaaaaaa 0050vvvv
+									memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
+									memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val^(p->data&0x0000FFFF)));
+								}
+							}
+							else if (p->addr < 0xE0000000) {
+								if ((((u32)p->data & 0xFFFF0000)==0x00000000) ||
+								     (((u32)p->data & 0xFFFF0000)==0x00100000) ||
+								     (((u32)p->data & 0xFFFF0000)==0x00200000) ||
+								     (((u32)p->data & 0xFFFF0000)==0x00300000)) {
+									memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
+									if (u16Val != (0x0000FFFF&(u32)p->data))
+										SkipCount = 1;
+									PrevCheatType= 0;
+								}
+							}
+							else if (p->addr < 0xF0000000) {
+								if ((((u32)p->data&0xF0000000)==0x00000000) ||
+								     (((u32)p->data&0xF0000000)==0x10000000) ||
+								     (((u32)p->data&0xF0000000)==0x20000000) ||
+								     (((u32)p->data&0xF0000000)==0x30000000)) {
+										memRead16((u32)p->data&0x0FFFFFFF,&u16Val);
+										if (u16Val != (0x0000FFFF&(u32)p->addr))
+											SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
+										PrevCheatType= 0;
+									}
 				}
-			
-			}else if ((p->addr&0xF0000000) == 0x00000000){ // 0aaaaaaa 0000000vv
-				memWrite8(p->addr&0x0FFFFFFF, (u8)p->data&0x000000FF);
-				PrevCheatType = 0;
-			}else if ((p->addr&0xF0000000) == 0x10000000){ // 0aaaaaaa 0000vvvv
-				memWrite16(p->addr&0x0FFFFFFF, (u16)p->data&0x0000FFFF);
-				PrevCheatType = 0;
-			}else if ((p->addr&0xF0000000) == 0x20000000){ // 0aaaaaaa vvvvvvvv
-				memWrite32(p->addr&0x0FFFFFFF, (u32)p->data);
-				PrevCheatType = 0;
-			}else if ((p->addr&0xFFFF0000) == 0x30000000){ // 300000vv 0aaaaaaa  Inc
-				memRead8((u32)p->data,&u8Val);
-				memWrite8((u32)p->data, u8Val+(p->addr&0x000000FF));
-				PrevCheatType = 0;
-			}else if ((p->addr&0xFFFF0000) == 0x30100000){ // 301000vv 0aaaaaaa  Dec
-				memRead8((u32)p->data,&u8Val);
-				memWrite8((u32)p->data, u8Val-(p->addr&0x000000FF));
-				PrevCheatType = 0;
-			}else if ((p->addr&0xFFFF0000) == 0x30200000){  // 3020vvvv 0aaaaaaa Inc
-				memRead16((u32)p->data,&u16Val);
-				memWrite16((u32)p->data, u16Val+(p->addr&0x0000FFFF));
-				PrevCheatType = 0;
-			}else if ((p->addr&0xFFFF0000) == 0x30300000){  // 3030vvvv 0aaaaaaa Dec
-				memRead16((u32)p->data,&u16Val);
-				memWrite16((u32)p->data, u16Val-(p->addr&0x0000FFFF));
-				PrevCheatType = 0;
-			}else if ((p->addr&0xFFFF0000) == 0x30400000){  // 30400000 0aaaaaaa Inc   + Another line
-				PrevCheatType= 0x3040;
-				PrevCheataddr= (u32)p->data;
-			}else if ((p->addr&0xFFFF0000) == 0x30500000){   // 30500000 0aaaaaaa Inc   + Another line
-				PrevCheatType= 0x3050;
-				PrevCheataddr= (u32)p->data;
-			}else if ((p->addr&0xF0000000) == 0x40000000){   // 4aaaaaaa nnnnssss + Another line
-				IterationCount=((u32)p->data&0xFFFF0000)/0x10000;
-				IterationIncrement=((u32)p->data&0x0000FFFF)*4;
-				PrevCheataddr=(u32)p->addr&0x0FFFFFFF;
-				PrevCheatType= 0x4000;
-			}else if  ((p->addr&0xF0000000) == 0x50000000){  // 5sssssss nnnnnnnn + Another line
-				PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
-				IterationCount=((u32)p->data);
-				PrevCheatType= 0x5000;
-			}else if  ((p->addr&0xF0000000) == 0x60000000){ // 6aaaaaaa 000000vv + Another line/s
-				PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
-				IterationIncrement=((u32)p->data);
-				IterationCount=0;
-				PrevCheatType= 0x6000;
-			}else if  (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00000000)){ // 7aaaaaaa 000000vv 
-				memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
-				memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val|(p->data&0x000000FF)));
-			}else if  (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00100000)){ // 7aaaaaaa 0010vvvv
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val|(p->data&0x0000FFFF)));
-			}else if  (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00200000)){ // 7aaaaaaa 002000vv
-				memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
-				memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val&(p->data&0x000000FF)));
-			}else if  (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00300000)){ // 7aaaaaaa 0030vvvv
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val&(p->data&0x0000FFFF)));
-			}else if  (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00400000)){ // 7aaaaaaa 004000vv
-				memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
-				memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val^(p->data&0x000000FF)));
-			}else if  (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00500000)){ // 7aaaaaaa 0050vvvv
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val^(p->data&0x0000FFFF)));
-			}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00000000)){
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				if (u16Val != (0x0000FFFF&(u32)p->data))
-					SkipCount = 1;
-				PrevCheatType= 0;
-			}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00100000)){
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				if (u16Val == (0x0000FFFF&(u32)p->data))
-					SkipCount = 1;
-				PrevCheatType= 0;
-			}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00200000)){
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				if (u16Val <= (0x0000FFFF&(u32)p->data))
-					SkipCount = 1;
-				PrevCheatType= 0;
-			}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00300000)){
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				if (u16Val >= (0x0000FFFF&(u32)p->data))
-					SkipCount = 1;
-				PrevCheatType= 0;
-			}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x00000000)){
-				memRead16((u32)p->data&0x0FFFFFFF,&u16Val);
-				if (u16Val != (0x0000FFFF&(u32)p->addr))
-					SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
-				PrevCheatType= 0;
-			}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x10000000)){
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				if (u16Val == (0x0000FFFF&(u32)p->data))
-					SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
-				PrevCheatType= 0;
-			}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x20000000)){
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				if (u16Val <= (0x0000FFFF&(u32)p->data))
-					SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
-				PrevCheatType= 0;
-			}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x30000000)){
-				memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
-				if (u16Val >= (0x0000FFFF&(u32)p->data))
-					SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
-				PrevCheatType= 0;
 			}
 		}
-	} else
-	if (p->cpu == 2) { //IOP
-		if (p->type == 1) { //byte
-			psxMemWrite8(p->addr, (u8)p->data);
-		} else
-		if (p->type == 2) { //short
-			psxMemWrite16(p->addr, (u16)p->data);
-		} else
-		if (p->type == 3) { //word
-			psxMemWrite32(p->addr, (u32)p->data);
+		break;
+	case IOP: { 
+		switch (p->type) {
+			case BYTE_T:
+				psxMemWrite8(p->addr, (u8)p->data);
+				break;
+			case SHORT_T:
+				psxMemWrite16(p->addr, (u16)p->data);
+				break;
+			case WORD_T:
+				psxMemWrite32(p->addr, (u32)p->data);
+				break;
 		}
 	}
+	}
 }
 
 
@@ -352,10 +359,9 @@ void applypatch(int place) {
 
 void patchFunc_comment( char * text1, char * text2 )
 {
-   SysPrintf( "comment: %s \n", text2 );
+	SysPrintf( "comment: %s \n", text2 );
 }
 
-char strgametitle[256] = {0};
 
 void patchFunc_gametitle( char * text1, char * text2 )
 {
@@ -366,180 +372,176 @@ void patchFunc_gametitle( char * text1, char * text2 )
 #endif
 }
 
-extern int RunExe;
-
 void patchFunc_patch( char * cmd, char * param )
 {
-   //patch=placetopatch,cpucore,address,type,data 
-   char * pText;
+	char * pText;
 
-   if ( patchnumber >= MAX_PATCH )
-   {
-      SysPrintf( "Patch ERROR: Maximum number of patches reached: %s=%s\n", cmd, param );
-      return;
-   }
-
-   pText = strtok( param, "," );
-   pText = param;
-//   inifile_trim( pText );
-
-   if(RunExe == 1) patch[ patchnumber ].placetopatch   = 1;
-   else patch[ patchnumber ].placetopatch   = strtol( pText, (char **)NULL, 0 );
-
-   pText = strtok( NULL, "," );
-   inifile_trim( pText );
-   patch[ patchnumber ].cpu = PatchTableExecute( pText, NULL, cpuCore );
-	if ( patch[ patchnumber ].cpu == 0 ) 
-   {
-		SysPrintf( "Unrecognized patch '%s'\n", pText );
-      return;
+	if ( patchnumber >= MAX_PATCH )
+	{
+		SysPrintf( "Patch ERROR: Maximum number of patches reached: %s=%s\n", cmd, param );
+		return;
 	}
 
-   pText = strtok( NULL, "," );
-   inifile_trim( pText );
-   sscanf( pText, "%X", &patch[ patchnumber ].addr );
+	pText = strtok( param, "," );
+	pText = param;
 
-   pText = strtok( NULL, "," );
-   inifile_trim( pText );
-   patch[ patchnumber ].type = PatchTableExecute( pText, NULL, dataType );
+	if(RunExe == 1) 
+		patch[ patchnumber ].placetopatch = 1;
+	else 
+		patch[ patchnumber ].placetopatch = strtol( pText, (char **)NULL, 0 );
+
+	pText = strtok( NULL, "," );
+	inifile_trim( pText );
+	patch[ patchnumber ].cpu = PatchTableExecute( pText, NULL, cpuCore );
+	if ( patch[ patchnumber ].cpu == 0 ) 
+	{
+		SysPrintf( "Unrecognized patch '%s'\n", pText );
+		return;
+	}
+
+	pText = strtok( NULL, "," );
+	inifile_trim( pText );
+	sscanf( pText, "%X", &patch[ patchnumber ].addr );
+
+	pText = strtok( NULL, "," );
+	inifile_trim( pText );
+	patch[ patchnumber ].type = PatchTableExecute( pText, NULL, dataType );
 	if ( patch[ patchnumber ].type == 0 ) 
-   {
-      SysPrintf( "Unrecognized patch '%s'\n", pText );
-      return;
-   }
+	{
+		SysPrintf( "Unrecognized patch '%s'\n", pText );
+		return;
+	}
 	
-   pText = strtok( NULL, "," );
-   inifile_trim( pText );
-   sscanf( pText, "%I64X", &patch[ patchnumber ].data );
+	pText = strtok( NULL, "," );
+	inifile_trim( pText );
+	sscanf( pText, "%I64X", &patch[ patchnumber ].data );
 
-   patch[ patchnumber ].enabled = 1;
+	patch[ patchnumber ].enabled = 1;
 
-   patchnumber++;
+	patchnumber++;
 }
 
-//this routine is for execute the commands of the ini file
+//this routine is for executing the commands of the ini file
 void inifile_command( char * cmd )
 {
-   int code;
-   char command[ 256 ];
-   char parameter[ 256 ];
+	int code;
+	char command[ 256 ];
+	char parameter[ 256 ];
 
-   // extract param part (after '=')
-   char * pEqual = strchr( cmd, '=' );
+	// extract param part (after '=')
+	char * pEqual = strchr( cmd, '=' );
 
-   if ( ! pEqual )
-   {
-	   // fastmemory doesn't have =
-	   pEqual = cmd+strlen(cmd);
-//      SysPrintf( "Ini file ERROR: unknow line: %s \n", cmd );
-//      return;
-   }
+	if ( ! pEqual )
+	{
+		// fastmemory doesn't have =
+		pEqual = cmd+strlen(cmd);
+	}
 
-   memset( command, 0, sizeof( command ) );
-   memset( parameter, 0, sizeof( parameter ) );
-      
-   strncpy( command, cmd, pEqual - cmd );
-   strncpy( parameter, pEqual + 1, sizeof( parameter ) );
+	memset( command, 0, sizeof( command ) );
+	memset( parameter, 0, sizeof( parameter ) );
+		
+	strncpy( command, cmd, pEqual - cmd );
+	strncpy( parameter, pEqual + 1, sizeof( parameter ) );
 
-   inifile_trim( command );
-   inifile_trim( parameter );
+	inifile_trim( command );
+	inifile_trim( parameter );
 
-   code = PatchTableExecute( command, parameter, commands );
+	code = PatchTableExecute( command, parameter, commands );
 }
 
 void inifile_trim( char * buffer )
 {
-   char * pInit = buffer;
-   char * pEnd = NULL;
+	char * pInit = buffer;
+	char * pEnd = NULL;
 
-   while ( ( *pInit == ' ' ) || ( *pInit == '\t' ) ) //skip space
-   {
-      pInit++;
-   }
-   if ( ( pInit[ 0 ] == '/' ) && ( pInit[ 1 ] == '/' ) ) //remove comment
-   {
-      buffer[ 0 ] = '\0';
-      return;
-   }
-   pEnd = pInit + strlen( pInit ) - 1;
-   if ( pEnd <= pInit )
-   {
-      buffer[ 0 ] = '\0';
-      return;
-   }
-   while ( ( *pEnd == '\r' ) || ( *pEnd == '\n' ) ||
-           ( *pEnd == ' ' ) || ( *pEnd == '\t' ) )
-   {
-      pEnd--;
-   }
-   if ( pEnd <= pInit )
-   {
-      buffer[ 0 ] = '\0';
-      return;
-   }
-   memmove( buffer, pInit, pEnd - pInit + 1 );
-   buffer[ pEnd - pInit + 1 ] = '\0';
+	while ( ( *pInit == ' ' ) || ( *pInit == '\t' ) ) //skip space
+	{
+		pInit++;
+	}
+	if ( ( pInit[ 0 ] == '/' ) && ( pInit[ 1 ] == '/' ) ) //remove comment
+	{
+		buffer[ 0 ] = '\0';
+		return;
+	}
+	pEnd = pInit + strlen( pInit ) - 1;
+	if ( pEnd <= pInit )
+	{
+		buffer[ 0 ] = '\0';
+		return;
+	}
+	while ( ( *pEnd == '\r' ) || ( *pEnd == '\n' ) ||
+			  ( *pEnd == ' ' ) || ( *pEnd == '\t' ) )
+	{
+		pEnd--;
+	}
+	if ( pEnd <= pInit )
+	{
+		buffer[ 0 ] = '\0';
+		return;
+	}
+	memmove( buffer, pInit, pEnd - pInit + 1 );
+	buffer[ pEnd - pInit + 1 ] = '\0';
 }
 
 void inisection_process( FILE * f1 )
 {
-   char buffer[ 1024 ];
-   while( fgets( buffer, sizeof( buffer ), f1 ) )
-   {
-      inifile_trim( buffer );
-      if ( buffer[ 0 ] )
-      {
-         inifile_command( buffer );
-      }
-   }
+	char buffer[ 1024 ];
+	while( fgets( buffer, sizeof( buffer ), f1 ) )
+	{
+		inifile_trim( buffer );
+		if ( buffer[ 0 ] )
+		{
+			inifile_command( buffer );
+		}
+	}
 }
 
 //this routine is for reading the ini file
 
 void inifile_read( char * name )
 {
-   FILE * f1;
-   char buffer[ 1024 ];
+	FILE * f1;
+	char buffer[ 1024 ];
 
-   patchnumber = 0;
+	patchnumber = 0;
 #ifdef _WIN32
-   sprintf( buffer, PATCHES_DIR "\\%s.pnach", name );
+	sprintf( buffer, PATCHES_DIR "\\%s.pnach", name );
 #else
-   sprintf( buffer, PATCHES_DIR "/%s.pnach", name );
+	sprintf( buffer, PATCHES_DIR "/%s.pnach", name );
 #endif
 
-   f1 = fopen( buffer, "rt" );
+	f1 = fopen( buffer, "rt" );
 
 #ifndef _WIN32
-   if( !f1 ) {
-       // try all upper case because linux is case sensitive
-       char* pstart = buffer+8;
-       char* pend = buffer+strlen(buffer);
-       while(pstart != pend ) {
-           // stop at the first . since we only want to update the hex
-           if( *pstart == '.' )
-               break;
-           *pstart++ = toupper(*pstart);
-       }
+	if( !f1 ) {
+		 // try all upper case because linux is case sensitive
+		 char* pstart = buffer+8;
+		 char* pend = buffer+strlen(buffer);
+		 while(pstart != pend ) {
+			  // stop at the first . since we only want to update the hex
+			  if( *pstart == '.' )
+					break;
+			  *pstart++ = toupper(*pstart);
+		 }
 
-       f1 = fopen(buffer, "rt");
-   }
+		 f1 = fopen(buffer, "rt");
+	}
 #endif
 
-   if( !f1 )
-   {
-       SysPrintf( _( "No patch found.Resuming execution without a patch (this is NOT an error).\n" ));
-      return;
-   }
+	if( !f1 )
+	{
+		 SysPrintf( _( "No patch found.Resuming execution without a patch (this is NOT an error).\n" ));
+		return;
+	}
 
-   inisection_process( f1 );
+	inisection_process( f1 );
 
-   fclose( f1 );
+	fclose( f1 );
 }
 
 void resetpatch( void )
 {
-   patchnumber = 0;
+	patchnumber = 0;
 }
 
 int AddPatch(int Mode, int Place, int Address, int Size, u64 data)
@@ -551,14 +553,27 @@ int AddPatch(int Mode, int Place, int Address, int Size, u64 data)
 		return -1;
 	}
 
-	if(RunExe == 1) patch[patchnumber].placetopatch = 1;
-	else patch[patchnumber].placetopatch = Mode;
+	if(RunExe == 1) 
+		patch[patchnumber].placetopatch = 1;
+	else 
+		patch[patchnumber].placetopatch = Mode;
+	
 	patch[patchnumber].cpu = Place;
 	patch[patchnumber].addr=Address;
 	patch[patchnumber].type=Size;
 	patch[patchnumber].data = data;
 	return patchnumber++;
 }
+	
+void patchFunc_ffxhack( char * cmd, char * param )
+{
+	 g_FFXHack = 1;
+}
+
+void patchFunc_xkickdelay( char * cmd, char * param )
+{
+	g_VUGameFixes |= VUFIX_XGKICKDELAY2;
+}
 
 void patchFunc_fastmemory( char * cmd, char * param )
 {
@@ -568,17 +583,15 @@ void patchFunc_fastmemory( char * cmd, char * param )
 #endif
 }
 
-extern void SetVUNanMode(int mode);
 
 void patchFunc_vunanmode( char * cmd, char * param )
 {
 #ifndef PCSX2_NORECBUILD
 	// only valid for recompilers
-    SetVUNanMode(param != NULL ? atoi(param) : 1);
+	 SetVUNanMode(param != NULL ? atoi(param) : 1);
 #endif
 }
 
-extern int path3hack;
 void patchFunc_path3hack( char * cmd, char * param )
 {
 	path3hack = 1;
@@ -586,7 +599,6 @@ void patchFunc_path3hack( char * cmd, char * param )
 
 void patchFunc_roundmode( char * cmd, char * param )
 {
-	//roundmode = X,Y
 	int index;
 	char * pText;
 
@@ -597,6 +609,7 @@ void patchFunc_roundmode( char * cmd, char * param )
 	pText = strtok( param, ", " );
 	while(pText != NULL) {
 		u32 type = 0xffff;
+		
 		if( stricmp(pText, "near") == 0 ) {
 			type = 0x0000;
 		}
@@ -615,8 +628,10 @@ void patchFunc_roundmode( char * cmd, char * param )
 			break;
 		}
 
-		if( index == 0 ) eetype=type;
-		else			 vutype=type;
+		if( index == 0 ) 
+			eetype=type;
+		else			 
+			vutype=type;
 
 		if( index == 1 )
 			break;
@@ -630,7 +645,7 @@ void patchFunc_roundmode( char * cmd, char * param )
 
 void patchFunc_zerogs(char* cmd, char* param)
 {
-    sscanf(param, "%x", &g_ZeroGSOptions);
+	 sscanf(param, "%x", &g_ZeroGSOptions);
 }
 
 void SetRoundMode(u32 ee, u32 vu)
diff --git a/pcsx2/Patch.h b/pcsx2/Patch.h
index e8a27634dc..c6bffe8fae 100644
--- a/pcsx2/Patch.h
+++ b/pcsx2/Patch.h
@@ -27,9 +27,27 @@
 
 #define GETNEXT_PARAM() \
 	while ( *param && ( *param != ',' ) ) param++; \
-   if ( *param ) param++; \
+	if ( *param ) param++; \
 	while ( *param && ( *param == ' ' ) ) param++; \
 	if ( *param == 0 ) { SysPrintf( _( "Not enough params for inicommand\n" ) ); return; }
+	
+//
+// Enums
+//
+
+enum patch_cpu_type {
+	NO_CPU,
+	EE,
+	IOP
+};
+enum patch_data_type {
+	NO_TYPE,
+	BYTE_T,
+	SHORT_T,
+	WORD_T,
+	DOUBLE_T,
+	EXTENDED_T
+};
 
 //
 // Typedefs
@@ -38,20 +56,20 @@ typedef void (*PATCHTABLEFUNC)( char * text1, char * text2 );
 
 typedef struct
 {
-   char           * text;
-   int            code;
-   PATCHTABLEFUNC func;
+	char *text;
+	int code;
+	PATCHTABLEFUNC func;
 } PatchTextTable;
-
+	
 typedef struct
 {
-   int enabled;
-   int group;
-   int type;
-   int cpu;
-   int placetopatch;
-   u32 addr;
-   u64 data;
+	int enabled;
+	int group;
+	enum patch_data_type type;
+	enum patch_cpu_type cpu;
+	int placetopatch;
+	u32 addr;
+	u64 data;
 } IniPatch;
 
 //
@@ -65,6 +83,8 @@ void patchFunc_path3hack( char * text1, char * text2 );
 void patchFunc_roundmode( char * text1, char * text2 );
 void patchFunc_zerogs( char * text1, char * text2 );
 void patchFunc_vunanmode( char * text1, char * text2 );
+void patchFunc_ffxhack( char * text1, char * text2 );
+void patchFunc_xkickdelay( char * text1, char * text2 );
 
 void inifile_trim( char * buffer );
 
@@ -72,11 +92,8 @@ void inifile_trim( char * buffer );
 // Variables
 //
 extern PatchTextTable commands[];
-
 extern PatchTextTable dataType[];
-
 extern PatchTextTable cpuCore[];
-
 extern IniPatch patch[ MAX_PATCH ];
 extern int patchnumber;
 
@@ -91,6 +108,11 @@ int AddPatch(int Mode, int Place, int Address, int Size, u64 data);
 void SetFastMemory(int); // iR5900LoadStore.c
 void SetVUNanMemory(int); // iVUmicro.c
 
+extern void SetVUNanMode(int mode);
+
+extern int path3hack;
+extern int g_FFXHack;
+//extern int g_VUGameFixes;
 extern u32 g_sseMXCSR;
 extern u32 g_sseVUMXCSR;
 void SetCPUState(u32 sseMXCSR, u32 sseVUMXCSR);
diff --git a/pcsx2/configure.ac b/pcsx2/configure.ac
index a08bacc5f0..f74e510cb8 100644
--- a/pcsx2/configure.ac
+++ b/pcsx2/configure.ac
@@ -17,6 +17,7 @@ CXXFLAGS=
 CCASFLAGS=
 
 WARNING_FLAGS="-Wall -Wno-format -Wno-unused-value"
+dnl EXTRA_FLAGS = " -Xlinker -zmuldefs -fpermissive "
 NORMAL_FLAGS="-O3 -fomit-frame-pointer ${WARNING_FLAGS}"
 DEBUG_FLAGS=" -g ${WARNING_FLAGS}"
 
diff --git a/pcsx2/windows/cheats/browser.cpp b/pcsx2/windows/cheats/browser.cpp
index a010bb2e80..c235b443ce 100644
--- a/pcsx2/windows/cheats/browser.cpp
+++ b/pcsx2/windows/cheats/browser.cpp
@@ -607,7 +607,7 @@ int ReadPatch(HWND hWnd, IniPatch &temp)
 	}
 
 	// CPU
-	temp.cpu = SendMessage(GetDlgItem(hWnd, IDC_CPU), CB_GETCURSEL, 0, 0) + 1;
+	temp.cpu = (patch_cpu_type)(SendMessage(GetDlgItem(hWnd, IDC_CPU), CB_GETCURSEL, 0, 0) + 1);
 	if(temp.cpu < 1)
 	{
 		MessageBox(hWnd, "CPU is not selected.", "Error", 0);
@@ -631,7 +631,7 @@ int ReadPatch(HWND hWnd, IniPatch &temp)
 	}
 
 	// Type
-	temp.type = SendMessage(GetDlgItem(hWnd, IDC_TYPE), CB_GETCURSEL, 0, 0) + 1;
+	temp.type = (patch_data_type)(SendMessage(GetDlgItem(hWnd, IDC_TYPE), CB_GETCURSEL, 0, 0) + 1);
 	if(temp.type < 1)
 	{
 		MessageBox(hWnd, "Type is not selected.", "Error", 0);
diff --git a/pcsx2/x86/ir5900tables.c b/pcsx2/x86/ir5900tables.c
index 8d71347a50..10de65ed96 100644
--- a/pcsx2/x86/ir5900tables.c
+++ b/pcsx2/x86/ir5900tables.c
@@ -657,7 +657,7 @@ void rpropSPECIAL(EEINST* prev, EEINST* pinst)
 
 		case 16: // mfhi
 			rpropSetWrite(_Rd_, EEINST_LIVE1);
-			rpropSetRead(XMMGPR_HI, (pinst->regs[_Rd_]&EEINST_MMX|EEINST_REALXMM)|EEINST_LIVE1);
+			rpropSetRead(XMMGPR_HI, (pinst->regs[_Rd_]&(EEINST_MMX|EEINST_REALXMM))|EEINST_LIVE1);
 			break;
 		case 17: // mthi
 			rpropSetWrite(XMMGPR_HI, EEINST_LIVE1);
@@ -665,7 +665,7 @@ void rpropSPECIAL(EEINST* prev, EEINST* pinst)
 			break;
 		case 18: // mflo
 			rpropSetWrite(_Rd_, EEINST_LIVE1);
-			rpropSetRead(XMMGPR_LO, (pinst->regs[_Rd_]&EEINST_MMX|EEINST_REALXMM)|EEINST_LIVE1);
+			rpropSetRead(XMMGPR_LO, (pinst->regs[_Rd_]&(EEINST_MMX|EEINST_REALXMM))|EEINST_LIVE1);
 			break;
 		case 19: // mtlo
 			rpropSetWrite(XMMGPR_LO, EEINST_LIVE1);
@@ -687,6 +687,8 @@ void rpropSPECIAL(EEINST* prev, EEINST* pinst)
 			rpropSetWrite(XMMGPR_LO, EEINST_LIVE1);
 			rpropSetWrite(XMMGPR_HI, EEINST_LIVE1);
 			rpropSetWrite(_Rd_, EEINST_LIVE1);
+		
+			// fixme - temp is always 0, so I doubt the next three lines are right.
 			rpropSetRead(_Rs_, temp);
 			rpropSetRead(_Rt_, temp);
 			pinst->info |= temp;
diff --git a/pcsx2/xmlpatchloader.cpp b/pcsx2/xmlpatchloader.cpp
index 9c399934cf..a32204fec3 100644
--- a/pcsx2/xmlpatchloader.cpp
+++ b/pcsx2/xmlpatchloader.cpp
@@ -335,11 +335,11 @@ int LoadGroup(TiXmlNode *group,int gParent)
 		
 		if(strcmp(place,"EE")==0)
 		{
-			patch[patchnumber].cpu=1;
+			patch[patchnumber].cpu= EE;
 		} else
 		if(strcmp(place,"IOP")==0)
 		{
-			patch[patchnumber].cpu=2;
+			patch[patchnumber].cpu= IOP;
 		} else
 		{
 			SysPrintf("XML Patch Loader: ERROR: Invalid place attribute.\n");
@@ -349,19 +349,19 @@ int LoadGroup(TiXmlNode *group,int gParent)
 
 		if(strcmp(size,"64")==0)
 		{
-			patch[patchnumber].type=4;
+			patch[patchnumber].type = DOUBLE_T;
 		} else
 		if(strcmp(size,"32")==0)
 		{
-			patch[patchnumber].type=3;
+			patch[patchnumber].type = WORD_T;
 		} else
 		if(strcmp(size,"16")==0)
 		{
-			patch[patchnumber].type=2;
+			patch[patchnumber].type = SHORT_T;
 		} else
 		if(strcmp(size,"8")==0)
 		{
-			patch[patchnumber].type=1;
+			patch[patchnumber].type = BYTE_T;
 		} else
 		{
 			SysPrintf("XML Patch Loader: ERROR: Invalid size attribute.\n");