project64/Source/Project64/N64 System/N64 Class.cpp

/****************************************************************************
*                                                                           *
* Project 64 - A Nintendo 64 emulator.                                      *
* http://www.pj64-emu.com/                                                  *
* Copyright (C) 2012 Project64. All rights reserved.                        *
*                                                                           *
* License:                                                                  *
* GNU/GPLv2 http://www.gnu.org/licenses/gpl-2.0.html                        *
*                                                                           *
****************************************************************************/
#include "stdafx.h"

#pragma warning(disable:4355) // Disable 'this' : used in base member initializer list

#include <windows.h>
#include <commdlg.h>

CN64System::CN64System(CPlugins * Plugins, bool SavesReadOnly) :
CSystemEvents(this, Plugins),
m_EndEmulation(false),
m_SaveUsing((SAVE_CHIP_TYPE)g_Settings->LoadDword(Game_SaveChip)),
m_Plugins(Plugins),
m_SyncCPU(NULL),
m_SyncPlugins(NULL),
m_SyncWindow(NULL),
m_MMU_VM(this, SavesReadOnly),
m_TLB(this),
m_Reg(this, this),
m_Recomp(NULL),
m_InReset(false),
m_NextTimer(0),
m_SystemTimer(m_NextTimer),
m_bCleanFrameBox(true),
m_bInitialized(false),
m_RspBroke(true),
m_DMAUsed(false),
m_TestTimer(false),
m_NextInstruction(0),
m_JumpToLocation(0),
m_TLBLoadAddress(0),
m_TLBStoreAddress(0),
m_SyncCount(0),
m_CPU_Handle(NULL),
m_CPU_ThreadID(0),
m_CheatsSlectionChanged(false)
{
	DWORD gameHertz = g_Settings->LoadDword(Game_ScreenHertz);
	if (gameHertz == 0)
	{
		gameHertz = (SystemType() == SYSTEM_PAL) ? 50 : 60;
	}
	m_hPauseEvent = CreateEvent(NULL,true,false,NULL);
	m_Limitor.SetHertz(gameHertz);
	g_Settings->SaveDword(GameRunning_ScreenHertz,gameHertz);
	m_Cheats.LoadCheats(!g_Settings->LoadDword(Setting_RememberCheats), Plugins);
}

CN64System::~CN64System()
{
	SetActiveSystem(false);
	Mempak::Close();
	if (m_SyncCPU)
	{
		m_SyncCPU->CpuStopped();
		delete m_SyncCPU;
		m_SyncCPU = NULL;
	}
	if (m_Recomp)
	{
		delete m_Recomp;
		m_Recomp = NULL;
	}
	if (m_SyncPlugins)
	{
		delete m_SyncPlugins;
		m_SyncPlugins = NULL;
	}
	if (m_SyncWindow)
	{
		delete m_SyncWindow;
		m_SyncWindow = NULL;
	}
}

void CN64System::ExternalEvent ( SystemEvent action ) 
{
	switch (action) 
	{
	case SysEvent_Profile_GenerateLogs: 
	case SysEvent_Profile_StartStop: 
	case SysEvent_Profile_ResetLogs: 
	case SysEvent_ExecuteInterrupt: 
	case SysEvent_SaveMachineState: 
	case SysEvent_LoadMachineState: 
	case SysEvent_ChangingFullScreen:
	case SysEvent_GSButtonPressed:
	case SysEvent_ResetCPU_SoftDone:
	case SysEvent_Interrupt_SP:
	case SysEvent_Interrupt_SI:
	case SysEvent_Interrupt_AI:
	case SysEvent_Interrupt_VI:
	case SysEvent_Interrupt_PI:
	case SysEvent_Interrupt_DP:
	case SysEvent_ResetCPU_Hard:
	case SysEvent_ResetCPU_Soft:
	case SysEvent_CloseCPU:	
	case SysEvent_ChangePlugins:
		QueueEvent(action);
		break;
	case SysEvent_PauseCPU_FromMenu: 
	case SysEvent_PauseCPU_AppLostFocus: 
	case SysEvent_PauseCPU_AppLostActive: 
	case SysEvent_PauseCPU_SaveGame: 
	case SysEvent_PauseCPU_LoadGame: 
	case SysEvent_PauseCPU_DumpMemory: 
	case SysEvent_PauseCPU_SearchMemory: 
	case SysEvent_PauseCPU_Settings: 
	case SysEvent_PauseCPU_Cheats:
		if (!g_Settings->LoadBool(GameRunning_CPU_Paused))
		{
			QueueEvent(action);
		}
		break;
	case SysEvent_ResumeCPU_FromMenu:
		// always resume if from menu
		SetEvent(m_hPauseEvent);
		break;
	case SysEvent_ResumeCPU_AppGainedFocus:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_AppLostFocus )
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	case SysEvent_ResumeCPU_AppGainedActive:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_AppLostActive )
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	case SysEvent_ResumeCPU_SaveGame:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_SaveGame )
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	case SysEvent_ResumeCPU_LoadGame:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_LoadGame )
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	case SysEvent_ResumeCPU_DumpMemory:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_DumpMemory )
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	case SysEvent_ResumeCPU_SearchMemory:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_SearchMemory )
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	case SysEvent_ResumeCPU_Settings:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_Settings )
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	case SysEvent_ResumeCPU_Cheats:
		if (g_Settings->LoadDword(GameRunning_CPU_PausedType) == PauseType_Cheats)
		{
			SetEvent(m_hPauseEvent);
		}
		break;
	default:
		WriteTraceF(TraceError, __FUNCTION__ ": Unknown event %d", action);
		g_Notify->BreakPoint(__FILEW__, __LINE__);
	}
}

bool CN64System::RunFileImage ( const char * FileLoc ) 
{
	CloseSystem();
	if (g_Settings->LoadBool(GameRunning_LoadingInProgress))
	{
		return false;
	}
	g_Settings->SaveBool(GameRunning_LoadingInProgress,true);

	WriteTrace(TraceDebug,__FUNCTION__ ": Mark Rom as loading");

	//Mark the rom as loading
	g_Settings->SaveBool(GameRunning_LoadingInProgress,true);
	Notify().RefreshMenu();

	//Try to load the passed N64 rom
	if (g_Rom == NULL)
	{
		WriteTrace(TraceDebug,__FUNCTION__ ": Allocating global rom object");
		g_Rom = new CN64Rom();
	} 
	else 
	{
		WriteTrace(TraceDebug,__FUNCTION__ ": Use existing global rom object");
	}

	WriteTraceF(TraceDebug,__FUNCTION__ ": Loading \"%s\"",FileLoc);
	if (g_Rom->LoadN64Image(FileLoc)) 
	{
		g_System->RefreshGameSettings();

		WriteTrace(TraceDebug,__FUNCTION__ ": Add Recent Rom");
		Notify().AddRecentRom(FileLoc);
		Notify().SetWindowCaption(g_Settings->LoadStringVal(Game_GoodName).ToUTF16().c_str());

		g_Settings->SaveBool(GameRunning_LoadingInProgress, false);
		Notify().RefreshMenu();

		if (g_Settings->LoadDword(Setting_AutoStart) != 0)
		{
			g_BaseSystem = new CN64System(g_Plugins,false);
			if (g_BaseSystem)
			{
				g_BaseSystem->StartEmulation(true);
			}
		}
	}
	else
	{
		WriteTraceF(TraceError,__FUNCTION__ ": LoadN64Image failed (\"%s\")",FileLoc);
		g_Notify->DisplayError(g_Rom->GetError());
		delete g_Rom;
		g_Rom = NULL;
		g_Settings->SaveBool(GameRunning_LoadingInProgress,false);
		Notify().RefreshMenu();
		return false;
	}
	return true;
}

void CN64System::CloseSystem()
{
	if (g_BaseSystem)
	{
		g_BaseSystem->CloseCpu();
		delete g_BaseSystem;
		g_BaseSystem = NULL;
	}
}

bool CN64System::EmulationStarting ( HANDLE hThread, DWORD ThreadId )
{
	bool bRes = true;

	WriteTrace(TraceDebug, __FUNCTION__ ": Setting N64 system as active");
	if (g_BaseSystem->SetActiveSystem(true))
	{
		g_BaseSystem->m_CPU_Handle   = hThread;
		g_BaseSystem->m_CPU_ThreadID = ThreadId;
		WriteTrace(TraceDebug,__FUNCTION__ ": Setting up N64 system done");
		g_Settings->SaveBool(GameRunning_LoadingInProgress,false);
		Notify().RefreshMenu();
		try
		{
			WriteTrace(TraceDebug,__FUNCTION__ ": Game set to auto start, starting");
			g_BaseSystem->StartEmulation2(false);			
			WriteTrace(TraceDebug,__FUNCTION__ ": Game Done");
		} 
		catch (...)
		{
			WriteTraceF(TraceError,__FUNCTION__ ": Exception caught\nFile: %s\nLine: %d",__FILE__,__LINE__);
			char Message[600];
			sprintf(Message,__FUNCTION__ ": Exception caught\nFile: %s\nLine: %d",__FILE__,__LINE__);
			MessageBox(NULL,Message,"Exception",MB_OK);
		}
	}
	else 
	{
		WriteTrace(TraceError,__FUNCTION__ ": SetActiveSystem failed");
		g_Notify->DisplayError(__FUNCTIONW__ L": Failed to Initialize N64 System");
		g_Settings->SaveBool(GameRunning_LoadingInProgress,false);
		Notify().RefreshMenu();
		bRes = false;
	}
	return bRes;
}
	
void  CN64System::StartEmulation2   ( bool NewThread )
{
	if (NewThread)
	{
		WriteTrace(TraceDebug,__FUNCTION__ ": Starting");

		Notify().HideRomBrowser();

		if (bHaveDebugger()) 
		{
			g_LogOptions.GenerateLog = g_Settings->LoadBool(Debugger_GenerateDebugLog);
			LoadLogOptions(&g_LogOptions, FALSE);
			StartLog();
		}

		CInterpreterCPU::BuildCPU();

		DWORD CpuType = g_Settings->LoadDword(Game_CpuType);

		if(CpuType == CPU_SyncCores && !g_Settings->LoadBool(Debugger_Enabled))
		{
			g_Settings->SaveDword(Game_CpuType, CPU_Recompiler);
			CpuType = CPU_Recompiler;
		}

		if (CpuType == CPU_SyncCores)
		{
			g_Notify->DisplayMessage(5,L"Copy Plugins");
			g_Plugins->CopyPlugins(g_Settings->LoadStringVal(Directory_PluginSync));
#if defined(WINDOWS_UI)
			m_SyncWindow = new CMainGui(false);
			m_SyncPlugins = new CPlugins( g_Settings->LoadStringVal(Directory_PluginSync) ); 
			m_SyncPlugins->SetRenderWindows(m_SyncWindow,m_SyncWindow);

			m_SyncCPU = new CN64System(m_SyncPlugins, true);
#else
			g_Notify -> BreakPoint(__FILEW__, __LINE__);
#endif
		}

		if (CpuType == CPU_Recompiler || CpuType == CPU_SyncCores)
		{
			m_Recomp = new CRecompiler(m_Reg,m_Profile,m_EndEmulation);
		}

		bool bSetActive = true;
		if (m_SyncCPU)
		{
			bSetActive = m_SyncCPU->SetActiveSystem();
		}

		if (bSetActive)
		{
			bSetActive = SetActiveSystem();
		}

		if (!bSetActive)
		{
			g_Settings->SaveBool(GameRunning_LoadingInProgress,false);
			g_Notify->DisplayError(MSG_PLUGIN_NOT_INIT);

			Notify().RefreshMenu();
			Notify().ShowRomBrowser();
		}

		Notify().MakeWindowOnTop(g_Settings->LoadBool(UserInterface_AlwaysOnTop));

		ThreadInfo * Info = new ThreadInfo;
		HANDLE  * hThread = new HANDLE;
		*hThread = NULL;

		//create the needed info into a structure to pass as one parameter
		//for creating a thread
		Info->ThreadHandle = hThread;
		
		*hThread  = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)StartEmulationThread,Info,0, &Info->ThreadID);
	}
	else 
	{
		//mark the emulation as starting and fix up menus
		g_Notify->DisplayMessage(5,MSG_EMULATION_STARTED);

		if (g_Settings->LoadBool(Setting_AutoFullscreen)) 
		{
			WriteTrace(TraceDebug,__FUNCTION__ " 15");
			CIniFile RomIniFile(g_Settings->LoadStringVal(SupportFile_RomDatabase).c_str());
			stdstr Status = g_Settings->LoadStringVal(Rdb_Status);

			char String[100];
			RomIniFile.GetString("Rom Status",stdstr_f("%s.AutoFullScreen", Status.c_str()).c_str(),"true",String,sizeof(String));
			if (_stricmp(String,"true") == 0)
			{
				Notify().ChangeFullScreen();
			}
		}
		ExecuteCPU();
	}
}

void  CN64System::StartEmulation   ( bool NewThread )
{
	__try 
	{
		StartEmulation2(NewThread);
	}
	__except( g_MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()))
	{
		char Message[600];
		sprintf(Message,"Exception caught\nFile: %s\nLine: %d",__FILE__,__LINE__);
		MessageBox(NULL,Message,"Exception",MB_OK);
	}
}

void CN64System::StartEmulationThread (  ThreadInfo * Info ) 
{
	CoInitialize(NULL);
	
	EmulationStarting(*Info->ThreadHandle,Info->ThreadID);
	delete Info->ThreadHandle;
	delete Info;

	CoUninitialize();
}

void CN64System::CloseCpu()
{
	if (m_CPU_Handle == NULL) 
	{
		return; 
	}

	m_EndEmulation = true;
	if (g_Settings->LoadBool(GameRunning_CPU_Paused))
	{
		SetEvent(m_hPauseEvent);
	}
	
	if (GetCurrentThreadId() == m_CPU_ThreadID)
	{
		ExternalEvent(SysEvent_CloseCPU);
		return;
	}
	
	HANDLE hThread = m_CPU_Handle;
	for (int count = 0; count < 200; count ++ ) 
	{
		Sleep(100);
		if (Notify().ProcessGuiMessages())
		{
			return;
		}
	
		DWORD ExitCode;
		if (GetExitCodeThread(hThread,&ExitCode))
		{
			if (ExitCode != STILL_ACTIVE) 
			{
				break;
			}
		}
	}

	if (hThread)
	{ 
		DWORD ExitCode;
		GetExitCodeThread(hThread,&ExitCode);
		if (ExitCode == STILL_ACTIVE) 
		{
			TerminateThread(hThread,0); 
		}
	}
	CpuStopped();
}

void CN64System::DisplayRomInfo ( HWND hParent )
{
	if (!g_Rom) { return; }
	
	RomInformation Info(g_Rom);
	Info.DisplayInformation(hParent);
}

void CN64System::Pause()
{
	if (m_EndEmulation)
	{
		return;
	}
	ResetEvent(m_hPauseEvent);
	g_Settings->SaveBool(GameRunning_CPU_Paused,true);
	Notify().RefreshMenu();
	g_Notify->DisplayMessage(5,MSG_CPU_PAUSED);
	WaitForSingleObject(m_hPauseEvent, INFINITE);
	ResetEvent(m_hPauseEvent);
	g_Settings->SaveBool(GameRunning_CPU_Paused,(DWORD)false);
	Notify().RefreshMenu();
	Notify().DisplayMessage(5, MSG_CPU_RESUMED);
}

stdstr CN64System::ChooseFileToOpen ( HWND hParent ) 
{
	OPENFILENAME openfilename;
	char FileName[_MAX_PATH],Directory[_MAX_PATH];

	memset(&FileName, 0, sizeof(FileName));
	memset(&openfilename, 0, sizeof(openfilename));

	strcpy(Directory,g_Settings->LoadStringVal(Directory_Game).c_str());

	openfilename.lStructSize  = sizeof( openfilename );
	openfilename.hwndOwner    = (HWND)hParent;
	openfilename.lpstrFilter = "N64 ROMs (*.zip, *.7z, *.?64, *.rom, *.usa, *.jap, *.pal, *.bin)\0*.?64;*.zip;*.7z;*.bin;*.rom;*.usa;*.jap;*.pal\0All files (*.*)\0*.*\0";
	openfilename.lpstrFile    = FileName;
	openfilename.lpstrInitialDir    = Directory;
	openfilename.nMaxFile     = MAX_PATH;
	openfilename.Flags        = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;

	if (GetOpenFileName (&openfilename)) 
	{							
		return stdstr(FileName);
	}
	return stdstr("");
}

void CN64System::GameReset()
{
	m_SystemTimer.SetTimer(CSystemTimer::SoftResetTimer,0x3000000,false);
	m_Plugins->Gfx()->ShowCFB();
	m_Reg.FAKE_CAUSE_REGISTER |= CAUSE_IP4;
	m_Plugins->Gfx()->SoftReset();
	if (m_SyncCPU)
	{
		m_SyncCPU->GameReset();
	}
}

void CN64System::PluginReset()
{
	if (!m_Plugins->ResetInUiThread(this))
	{
		g_Notify->DisplayMessage(5,MSG_PLUGIN_NOT_INIT);
		if (g_BaseSystem)
		{
			g_BaseSystem->m_EndEmulation = true;
		}
	}
	if (m_SyncCPU)
	{
		if (!m_SyncCPU->m_Plugins->ResetInUiThread(m_SyncCPU))
		{
			g_Notify->DisplayMessage(5,MSG_PLUGIN_NOT_INIT);
			if (g_BaseSystem)
			{
				g_BaseSystem->m_EndEmulation = true;
			}
		}
	}
	Notify().RefreshMenu();
	if (m_Recomp)
	{
		m_Recomp->Reset();
	}
	m_Plugins->RomOpened();
	if (m_SyncCPU)
	{
		m_SyncCPU->m_Plugins->RomOpened();
	}
#ifndef _WIN64
	_controlfp(_PC_53, _MCW_PC);
#endif
}

void CN64System::Reset (bool bInitReg, bool ClearMenory) 
{
	g_Settings->SaveBool(GameRunning_InReset,true);
	RefreshGameSettings();
	m_Audio.Reset();
	m_MMU_VM.Reset(ClearMenory);
	Mempak::Close();

	m_CyclesToSkip = 0;
	m_AlistCount   = 0;
	m_DlistCount   = 0;
	m_UnknownCount = 0;
	m_DMAUsed      = false;
	m_RspBroke     = true;
	m_SyncCount    = 0;

	for (int i = 0, n = (sizeof(m_LastSuccessSyncPC)/sizeof(m_LastSuccessSyncPC[0])); i < n; i++)
	{
		m_LastSuccessSyncPC[i] = 0;
	}

	if (bInitReg)
	{
		bool PostPif = true;
		
		InitRegisters(PostPif,m_MMU_VM);
		if (PostPif) 
		{
			memcpy((m_MMU_VM.Dmem()+0x40), (g_Rom->GetRomAddress() + 0x040), 0xFBC);
		}
	}
	else 
	{
		m_Reg.Reset();
	}

	m_SystemTimer.Reset();
	m_SystemTimer.SetTimer(CSystemTimer::CompareTimer,m_Reg.COMPARE_REGISTER - m_Reg.COUNT_REGISTER,false);

	if (m_Recomp)
	{
		m_Recomp->Reset();
	}
	if (m_Plugins) { m_Plugins->GameReset(); }
	if (m_SyncCPU)
	{
		m_SyncCPU->Reset(bInitReg,ClearMenory);
	}
	g_Settings->SaveBool(GameRunning_InReset,true);
}

bool CN64System::SetActiveSystem( bool bActive )
{
	bool bInitPlugin = false;
	bool bReset = false;
	bool bRes = true;

	if (bActive && g_System == this)
	{
		return true;
	}

	if (bActive)
	{		
		m_Reg.SetAsCurrentSystem();

		if (g_System)
		{
			g_System->m_TestTimer = R4300iOp::m_TestTimer;
			g_System->m_NextInstruction = R4300iOp::m_NextInstruction;
			g_System->m_JumpToLocation = R4300iOp::m_JumpToLocation;
		}

		g_System    = this;
		if (g_BaseSystem == this)
		{
			g_SyncSystem   = m_SyncCPU;
		}
		g_Recompiler   = m_Recomp;
		g_MMU          = &m_MMU_VM;
		g_TLB          = &m_TLB;
		g_Reg          = &m_Reg;
		g_Audio        = &m_Audio;
		g_SystemTimer  = &m_SystemTimer;
		g_TransVaddr   = &m_MMU_VM;
		g_SystemEvents = this;
		g_NextTimer    = &m_NextTimer;		
		g_Plugins      = m_Plugins;
		g_TLBLoadAddress = &m_TLBLoadAddress;
		g_TLBStoreAddress = &m_TLBStoreAddress;
		R4300iOp::m_TestTimer = m_TestTimer;
		R4300iOp::m_NextInstruction = m_NextInstruction;
		R4300iOp::m_JumpToLocation = m_JumpToLocation;

		if (!m_bInitialized)
		{
			if (!m_MMU_VM.Initialize())
			{
				return false;
			}
			bReset = true;
			m_bInitialized = true;
			bInitPlugin = true;
		}
	}
	else
	{
		if (this == g_BaseSystem)
		{
			g_System          = NULL;
			g_SyncSystem      = NULL;
			g_Recompiler      = NULL;
			g_MMU             = NULL;
			g_TLB             = NULL;
			g_Reg             = NULL;
			g_Audio           = NULL;
			g_SystemTimer     = NULL;
			g_TransVaddr      = NULL;
			g_SystemEvents    = NULL;
			g_NextTimer       = NULL;
			g_Plugins         = m_Plugins;
			g_TLBLoadAddress  = NULL;
			g_TLBStoreAddress = NULL;
		}
	}

	if (bInitPlugin)
	{
		WriteTrace(TraceDebug,__FUNCTION__ ": Reseting Plugins");
		g_Notify->DisplayMessage(5,MSG_PLUGIN_INIT);
		m_Plugins->CreatePlugins();
		bRes = m_Plugins->Initiate(this);
		if (!bRes)
		{
			WriteTrace(TraceError, __FUNCTION__ ": g_Plugins->Initiate Failed");
		}
	}

	if (bReset)
	{
		Reset(true,true);
	}
	return bRes;
}

void CN64System::InitRegisters( bool bPostPif, CMipsMemory & MMU )
{
	m_Reg.Reset();

	//COP0 Registers
	m_Reg.RANDOM_REGISTER	  = 0x1F;
	m_Reg.COUNT_REGISTER	  = 0x5000;
	m_Reg.MI_VERSION_REG	  = 0x02020102;
	m_Reg.SP_STATUS_REG       = 0x00000001;
	m_Reg.CAUSE_REGISTER	  = 0x0000005C;
	m_Reg.CONTEXT_REGISTER    = 0x007FFFF0;
	m_Reg.EPC_REGISTER        = 0xFFFFFFFF;
	m_Reg.BAD_VADDR_REGISTER  = 0xFFFFFFFF;
	m_Reg.ERROREPC_REGISTER   = 0xFFFFFFFF;
	m_Reg.CONFIG_REGISTER     = 0x0006E463;
	m_Reg.STATUS_REGISTER     = 0x34000000;

	//m_Reg.REVISION_REGISTER   = 0x00000511;
	m_Reg.FixFpuLocations();

	if (bPostPif) 
	{
		m_Reg.m_PROGRAM_COUNTER	  = 0xA4000040;	
		
		m_Reg.m_GPR[0].DW=0x0000000000000000;
		m_Reg.m_GPR[6].DW=0xFFFFFFFFA4001F0C;
		m_Reg.m_GPR[7].DW=0xFFFFFFFFA4001F08;
		m_Reg.m_GPR[8].DW=0x00000000000000C0;
		m_Reg.m_GPR[9].DW=0x0000000000000000;
		m_Reg.m_GPR[10].DW=0x0000000000000040;
		m_Reg.m_GPR[11].DW=0xFFFFFFFFA4000040;
		m_Reg.m_GPR[16].DW=0x0000000000000000;
		m_Reg.m_GPR[17].DW=0x0000000000000000;
		m_Reg.m_GPR[18].DW=0x0000000000000000;
		m_Reg.m_GPR[19].DW=0x0000000000000000;
		m_Reg.m_GPR[21].DW=0x0000000000000000; 
		m_Reg.m_GPR[26].DW=0x0000000000000000;
		m_Reg.m_GPR[27].DW=0x0000000000000000;
		m_Reg.m_GPR[28].DW=0x0000000000000000;
		m_Reg.m_GPR[29].DW=0xFFFFFFFFA4001FF0;
		m_Reg.m_GPR[30].DW=0x0000000000000000;
		
		switch (g_Rom->GetCountry())
		{
		case Germany: case french:  case Italian:
		case Europe:  case Spanish: case Australia:
		case X_PAL:   case Y_PAL:
			switch (g_Rom->CicChipID())
			{
			case CIC_UNKNOWN:
			case CIC_NUS_6102:
				m_Reg.m_GPR[5].DW=0xFFFFFFFFC0F1D859;
				m_Reg.m_GPR[14].DW=0x000000002DE108EA;
				m_Reg.m_GPR[24].DW=0x0000000000000000;
				break;
			case CIC_NUS_6103:
				m_Reg.m_GPR[5].DW=0xFFFFFFFFD4646273;
				m_Reg.m_GPR[14].DW=0x000000001AF99984;
				m_Reg.m_GPR[24].DW=0x0000000000000000;
				break;
			case CIC_NUS_6105:
				MMU.SW_VAddr(0xA4001004,0xBDA807FC);
				m_Reg.m_GPR[5].DW=0xFFFFFFFFDECAAAD1;
				m_Reg.m_GPR[14].DW=0x000000000CF85C13;
				m_Reg.m_GPR[24].DW=0x0000000000000002;
				break;
			case CIC_NUS_6106:
				m_Reg.m_GPR[5].DW=0xFFFFFFFFB04DC903;
				m_Reg.m_GPR[14].DW=0x000000001AF99984;
				m_Reg.m_GPR[24].DW=0x0000000000000002;
				break;
			}
			m_Reg.m_GPR[20].DW=0x0000000000000000;
			m_Reg.m_GPR[23].DW=0x0000000000000006;
			m_Reg.m_GPR[31].DW=0xFFFFFFFFA4001554;
			break;
		case NTSC_BETA: case X_NTSC: case USA: case Japan:
		default:
			switch (g_Rom->CicChipID()) 
			{
			case CIC_UNKNOWN:
			case CIC_NUS_6102:
				m_Reg.m_GPR[5].DW=0xFFFFFFFFC95973D5;
				m_Reg.m_GPR[14].DW=0x000000002449A366;
				break;
			case CIC_NUS_6103:
				m_Reg.m_GPR[5].DW=0xFFFFFFFF95315A28;
				m_Reg.m_GPR[14].DW=0x000000005BACA1DF;
				break;
			case CIC_NUS_6105:
				MMU.SW_VAddr(0xA4001004,0x8DA807FC);
				m_Reg.m_GPR[5].DW=0x000000005493FB9A;
				m_Reg.m_GPR[14].DW=0xFFFFFFFFC2C20384;
			case CIC_NUS_6106:
				m_Reg.m_GPR[5].DW=0xFFFFFFFFE067221F;
				m_Reg.m_GPR[14].DW=0x000000005CD2B70F;
				break;
			}
			m_Reg.m_GPR[20].DW=0x0000000000000001;
			m_Reg.m_GPR[23].DW=0x0000000000000000;
			m_Reg.m_GPR[24].DW=0x0000000000000003;
			m_Reg.m_GPR[31].DW=0xFFFFFFFFA4001550;
		}

		switch (g_Rom->CicChipID())
		{
		case CIC_NUS_6101: 
			m_Reg.m_GPR[22].DW=0x000000000000003F; 
			break;
		case CIC_NUS_8303:		//64DD IPL CIC
		case CIC_NUS_5167:		//64DD CONVERSION CIC
			m_Reg.m_GPR[22].DW=0x00000000000000DD;
			break;
		case CIC_UNKNOWN:
		case CIC_NUS_6102: 
			m_Reg.m_GPR[1].DW=0x0000000000000001;
			m_Reg.m_GPR[2].DW=0x000000000EBDA536;
			m_Reg.m_GPR[3].DW=0x000000000EBDA536;
			m_Reg.m_GPR[4].DW=0x000000000000A536;
			m_Reg.m_GPR[12].DW=0xFFFFFFFFED10D0B3;
			m_Reg.m_GPR[13].DW=0x000000001402A4CC;
			m_Reg.m_GPR[15].DW=0x000000003103E121;
			m_Reg.m_GPR[22].DW=0x000000000000003F; 
			m_Reg.m_GPR[25].DW=0xFFFFFFFF9DEBB54F;
			break;
		case CIC_NUS_6103: 
			m_Reg.m_GPR[1].DW=0x0000000000000001;
			m_Reg.m_GPR[2].DW=0x0000000049A5EE96;
			m_Reg.m_GPR[3].DW=0x0000000049A5EE96;
			m_Reg.m_GPR[4].DW=0x000000000000EE96;
			m_Reg.m_GPR[12].DW=0xFFFFFFFFCE9DFBF7;
			m_Reg.m_GPR[13].DW=0xFFFFFFFFCE9DFBF7;
			m_Reg.m_GPR[15].DW=0x0000000018B63D28;
			m_Reg.m_GPR[22].DW=0x0000000000000078; 
			m_Reg.m_GPR[25].DW=0xFFFFFFFF825B21C9;
			break;
		case CIC_NUS_6105: 
			MMU.SW_VAddr(0xA4001000,0x3C0DBFC0);
			MMU.SW_VAddr(0xA4001008,0x25AD07C0);
			MMU.SW_VAddr(0xA400100C,0x31080080);
			MMU.SW_VAddr(0xA4001010,0x5500FFFC);
			MMU.SW_VAddr(0xA4001014,0x3C0DBFC0);
			MMU.SW_VAddr(0xA4001018,0x8DA80024);
			MMU.SW_VAddr(0xA400101C,0x3C0BB000);
			m_Reg.m_GPR[1].DW=0x0000000000000000;
			m_Reg.m_GPR[2].DW=0xFFFFFFFFF58B0FBF;
			m_Reg.m_GPR[3].DW=0xFFFFFFFFF58B0FBF;
			m_Reg.m_GPR[4].DW=0x0000000000000FBF;
			m_Reg.m_GPR[12].DW=0xFFFFFFFF9651F81E;
			m_Reg.m_GPR[13].DW=0x000000002D42AAC5;
			m_Reg.m_GPR[15].DW=0x0000000056584D60;
			m_Reg.m_GPR[22].DW=0x0000000000000091; 
			m_Reg.m_GPR[25].DW=0xFFFFFFFFCDCE565F;
			break;
		case CIC_NUS_6106: 
			m_Reg.m_GPR[1].DW=0x0000000000000000;
			m_Reg.m_GPR[2].DW=0xFFFFFFFFA95930A4;
			m_Reg.m_GPR[3].DW=0xFFFFFFFFA95930A4;
			m_Reg.m_GPR[4].DW=0x00000000000030A4;
			m_Reg.m_GPR[12].DW=0xFFFFFFFFBCB59510;
			m_Reg.m_GPR[13].DW=0xFFFFFFFFBCB59510;
			m_Reg.m_GPR[15].DW=0x000000007A3C07F4;
			m_Reg.m_GPR[22].DW=0x0000000000000085; 
			m_Reg.m_GPR[25].DW=0x00000000465E3F72;
			break;
		}
	}
	else
	{
		m_Reg.m_PROGRAM_COUNTER = 0xBFC00000;			
/*		PIF_Ram[36] = 0x00; PIF_Ram[39] = 0x3F; //common pif ram start values

		switch (g_Rom->CicChipID()) {
		case CIC_NUS_6101: PIF_Ram[37] = 0x06; PIF_Ram[38] = 0x3F; break;
		case CIC_UNKNOWN:
		case CIC_NUS_6102: PIF_Ram[37] = 0x02; PIF_Ram[38] = 0x3F; break;
		case CIC_NUS_6103:	PIF_Ram[37] = 0x02; PIF_Ram[38] = 0x78; break;
		case CIC_NUS_6105:	PIF_Ram[37] = 0x02; PIF_Ram[38] = 0x91; break;
		case CIC_NUS_6106:	PIF_Ram[37] = 0x02; PIF_Ram[38] = 0x85; break;
		}*/
	}
}

void CN64System::ExecuteCPU()
{
	//reset code
	g_Settings->SaveBool(GameRunning_CPU_Running,true);
	g_Settings->SaveBool(GameRunning_CPU_Paused,false);
	g_Notify->DisplayMessage(5,MSG_EMULATION_STARTED);
	
	m_EndEmulation = false;
	Notify().RefreshMenu();

	m_Plugins->RomOpened();
	if (m_SyncCPU)
	{
		m_SyncCPU->m_Plugins->RomOpened();
	}
#ifndef _WIN64
	_controlfp(_PC_53, _MCW_PC);
#endif

	switch ((CPU_TYPE)g_Settings->LoadDword(Game_CpuType))
	{
// Currently the compiler is 32-bit only.  We might have to ignore that RDB setting for now.
#ifndef _WIN64
	case CPU_Recompiler: ExecuteRecompiler(); break;
	case CPU_SyncCores:  ExecuteSyncCPU();    break;
#endif
	default:             ExecuteInterpret();  break;
	}
	g_Settings->SaveBool(GameRunning_CPU_Running,(DWORD)false);
	Notify().WindowMode();
	m_Plugins->RomClosed();
	if (m_SyncCPU)
	{
		m_SyncCPU->m_Plugins->RomClosed();
	}
}

void CN64System::ExecuteInterpret()
{
	SetActiveSystem();
	CInterpreterCPU::ExecuteCPU();
}

void CN64System::ExecuteRecompiler()
{	
	m_Recomp->Run();
}

void CN64System::ExecuteSyncCPU()
{
	Notify().BringToTop();
	m_Recomp->Run();
}

void CN64System::CpuStopped()
{
	g_Settings->SaveBool(GameRunning_CPU_Running,(DWORD)false);
	Notify().WindowMode();
	if (!m_InReset)
	{
		if (m_hPauseEvent)
		{
			CloseHandle(m_hPauseEvent);
			m_hPauseEvent = NULL;
		}

		Notify().RefreshMenu();
		Notify().MakeWindowOnTop(false);
		g_Notify->DisplayMessage(5,MSG_EMULATION_ENDED);
		if (g_Settings->LoadDword(RomBrowser_Enabled))
		{
			Notify().ShowRomBrowser();
		}	
	}
	if (m_SyncCPU)
	{
		m_SyncCPU->CpuStopped();
	}
}

void CN64System::UpdateSyncCPU (CN64System * const SecondCPU, DWORD const Cycles)
{
	int CyclesToExecute = Cycles - m_CyclesToSkip;
	
	//Update the number of cycles to skip
	m_CyclesToSkip -= Cycles;
	if (m_CyclesToSkip < 0) { m_CyclesToSkip = 0; }

	//Run the other CPU For the same amount of cycles
	if (CyclesToExecute < 0) { return; }
	
	SecondCPU->SetActiveSystem(true);
	
	CInterpreterCPU::ExecuteOps(Cycles);

	SetActiveSystem(true);
}

void CN64System::SyncCPUPC (CN64System * const SecondCPU) 
{
	bool ErrorFound = false;

	g_SystemTimer->UpdateTimers();
	if (m_Reg.m_PROGRAM_COUNTER != SecondCPU->m_Reg.m_PROGRAM_COUNTER) 
	{
		ErrorFound = true;
	}

	if (m_TLB != SecondCPU->m_TLB) { ErrorFound = true; }
	if (m_SystemTimer != SecondCPU->m_SystemTimer) { ErrorFound = true; }
	if (m_NextTimer != SecondCPU->m_NextTimer) { ErrorFound = true; }

	if (ErrorFound) { DumpSyncErrors(SecondCPU); }

	for (int i = (sizeof(m_LastSuccessSyncPC)/sizeof(m_LastSuccessSyncPC[0])) - 1; i > 0; i--) 
	{
		m_LastSuccessSyncPC[i] = m_LastSuccessSyncPC[i - 1];
	}
	m_LastSuccessSyncPC[0] = m_Reg.m_PROGRAM_COUNTER;
}

void CN64System::SyncCPU (CN64System * const SecondCPU) 
{
	bool ErrorFound = false;

	m_SyncCount += 1;
	//WriteTraceF(TraceError,"SyncCPU PC = %08X",m_Reg.m_PROGRAM_COUNTER);
	g_SystemTimer->UpdateTimers();
	
#ifdef TEST_SP_TRACKING
	if (m_CurrentSP != GPR[29].UW[0]) {
		ErrorFound = true;
	}
#endif
	if (m_Reg.m_PROGRAM_COUNTER != SecondCPU->m_Reg.m_PROGRAM_COUNTER) 
	{
		ErrorFound = true;
	}
	if (b32BitCore())
	{
		for (int count = 0; count < 32; count ++)
		{
			if (m_Reg.m_GPR[count].W[0] != SecondCPU->m_Reg.m_GPR[count].W[0])
			{
				ErrorFound = true;
			}
			if (m_Reg.m_FPR[count].DW != SecondCPU->m_Reg.m_FPR[count].DW)
			{
				ErrorFound = true;
			}
			if (m_Reg.m_CP0[count] != SecondCPU->m_Reg.m_CP0[count])
			{
				ErrorFound = true;
			}
		}
	}
	else
	{
		for (int count = 0; count < 32; count ++) 
		{
			if (m_Reg.m_GPR[count].DW != SecondCPU->m_Reg.m_GPR[count].DW)
			{
				ErrorFound = true;
			}
			if (m_Reg.m_FPR[count].DW != SecondCPU->m_Reg.m_FPR[count].DW) 
			{
				ErrorFound = true;
			}
			if (m_Reg.m_CP0[count] != SecondCPU->m_Reg.m_CP0[count])
			{
				ErrorFound = true;
			}
		}
	}
	
	if (m_TLB != SecondCPU->m_TLB) { ErrorFound = true; }
	if (m_Reg.m_FPCR[0] != SecondCPU->m_Reg.m_FPCR[0]) { ErrorFound = true; }
	if (m_Reg.m_FPCR[31] != SecondCPU->m_Reg.m_FPCR[31]) { ErrorFound = true; }
	if (m_Reg.m_HI.DW != SecondCPU->m_Reg.m_HI.DW) { ErrorFound = true; }
	if (m_Reg.m_LO.DW != SecondCPU->m_Reg.m_LO.DW) { ErrorFound = true; }
	/*if (m_SyncCount > 4788000)
	{
		if (memcmp(m_MMU_VM.Rdram(),SecondCPU->m_MMU_VM.Rdram(),RdramSize()) != 0) 
		{
			ErrorFound = true; 
		}
	}
	if (memcmp(m_MMU_VM.Imem(),SecondCPU->m_MMU_VM.Imem(),0x1000) != 0) 
	{
		ErrorFound = true; 
	}
	if (memcmp(m_MMU_VM.Dmem(),SecondCPU->m_MMU_VM.Dmem(),0x1000) != 0) 
	{
		ErrorFound = true; 
	}*/

	/*for (int z = 0; z < 0x100; z++)
	{	
		if (m_MMU_VM.Rdram()[0x00206970 + z] !=  SecondCPU->m_MMU_VM.Rdram()[0x00206970 + z]) 
		{
			ErrorFound = true;
			break;
		}
	}*/
	
	if (bFastSP() && m_Recomp) 
	{
		if (m_Recomp->MemoryStackPos() != (DWORD)(m_MMU_VM.Rdram() + (m_Reg.m_GPR[29].W[0] & 0x1FFFFFFF)))
		{
			ErrorFound = true;
		}
	}

	if (m_SystemTimer != SecondCPU->m_SystemTimer) { ErrorFound = true; }
	if (m_NextTimer != SecondCPU->m_NextTimer) { ErrorFound = true; }
	if (m_Reg.m_RoundingModel != SecondCPU->m_Reg.m_RoundingModel) { ErrorFound = true; }
	
	for (int i = 0, n = sizeof(m_Reg.m_Mips_Interface) / sizeof(m_Reg.m_Mips_Interface[0]); i < n; i ++) 
	{
		if (m_Reg.m_Mips_Interface[i] != SecondCPU->m_Reg.m_Mips_Interface[i])
		{
			ErrorFound = true;
		}
	}

	for (int i = 0, n = sizeof(m_Reg.m_SigProcessor_Interface) / sizeof(m_Reg.m_SigProcessor_Interface[0]); i < n; i ++) 
	{
		if (m_Reg.m_SigProcessor_Interface[i] != SecondCPU->m_Reg.m_SigProcessor_Interface[i])
		{
			ErrorFound = true;
		}
	}

	for (int i = 0, n = sizeof(m_Reg.m_Display_ControlReg) / sizeof(m_Reg.m_Display_ControlReg[0]); i < n; i ++) 
	{
		if (m_Reg.m_Display_ControlReg[i] != SecondCPU->m_Reg.m_Display_ControlReg[i])
		{
			ErrorFound = true;
		}
	}
	
	if (ErrorFound) { DumpSyncErrors(SecondCPU); }

	for (int i = (sizeof(m_LastSuccessSyncPC)/sizeof(m_LastSuccessSyncPC[0])) - 1; i > 0; i--) 
	{
		m_LastSuccessSyncPC[i] = m_LastSuccessSyncPC[i - 1];
	}
	m_LastSuccessSyncPC[0] = m_Reg.m_PROGRAM_COUNTER;
//	if (PROGRAM_COUNTER == 0x8009BBD8) {
//		g_Notify->BreakPoint(__FILEW__,__LINE__);
//	}
}

void CN64System::SyncSystem()
{
	SyncCPU(g_SyncSystem);
}

void CN64System::SyncSystemPC()
{
	SyncCPUPC(g_SyncSystem);
}

void CN64System::DumpSyncErrors (CN64System * SecondCPU) 
{
	int count;
	
	{
		CPath ErrorFile (CPath::MODULE_DIRECTORY);
		ErrorFile.AppendDirectory("Logs");
		ErrorFile.SetNameExtension("Sync Errors.txt");

		CLog Error;
		Error.Open(ErrorFile);
		Error.Log("Errors:\r\n");
		Error.Log("Register,        Recompiler,         Interpter\r\n");
	#ifdef TEST_SP_TRACKING
		if (m_CurrentSP != GPR[29].UW[0]) {
			Error.Log("m_CurrentSP,%X,%X\r\n",m_CurrentSP,GPR[29].UW[0]);
		}
	#endif
		if (m_Reg.m_PROGRAM_COUNTER != SecondCPU->m_Reg.m_PROGRAM_COUNTER) {
			Error.LogF("PROGRAM_COUNTER 0x%X,         0x%X\r\n",m_Reg.m_PROGRAM_COUNTER,SecondCPU->m_Reg.m_PROGRAM_COUNTER);
		}
		if (b32BitCore())
		{
			for (count = 0; count < 32; count ++) 
			{
				if (m_Reg.m_GPR[count].UW[0] != SecondCPU->m_Reg.m_GPR[count].UW[0])
				{
					Error.LogF("GPR[%s] 0x%08X%08X, 0x%08X%08X\r\n",CRegName::GPR[count],
						m_Reg.m_GPR[count].W[1],m_Reg.m_GPR[count].W[0],
						SecondCPU->m_Reg.m_GPR[count].W[1],SecondCPU->m_Reg.m_GPR[count].W[0]);
				}
			}
		}
		else 
		{
			for (count = 0; count < 32; count ++) 
			{
				if (m_Reg.m_GPR[count].DW != SecondCPU->m_Reg.m_GPR[count].DW)
				{
					Error.LogF("GPR[%s] 0x%08X%08X, 0x%08X%08X\r\n",CRegName::GPR[count],
						m_Reg.m_GPR[count].W[1],m_Reg.m_GPR[count].W[0],
						SecondCPU->m_Reg.m_GPR[count].W[1],SecondCPU->m_Reg.m_GPR[count].W[0]);
				}
			}
		}
		for (count = 0; count < 32; count ++) 
		{
			if (m_Reg.m_FPR[count].DW != SecondCPU->m_Reg.m_FPR[count].DW)
			{
				Error.LogF("FPR[%s] 0x%08X%08X, 0x%08X%08X\r\n",CRegName::FPR[count],
					m_Reg.m_FPR[count].W[1],m_Reg.m_FPR[count].W[0],
					SecondCPU->m_Reg.m_FPR[count].W[1],SecondCPU->m_Reg.m_FPR[count].W[0]);
			}
		}	
		for (count = 0; count < 32; count ++) 
		{
			if (m_Reg.m_FPCR[count] != SecondCPU->m_Reg.m_FPCR[count])
			{
				Error.LogF("FPCR[%s] 0x%08X, 0x%08X\r\n",CRegName::FPR_Ctrl[count],
					m_Reg.m_FPCR[count], SecondCPU->m_Reg.m_FPCR[count]);
			}
		}	
		for (count = 0; count < 32; count ++) 
		{
			if (m_Reg.m_CP0[count] != SecondCPU->m_Reg.m_CP0[count])
			{
				Error.LogF("CP0[%s] 0x%08X, 0x%08X\r\n",CRegName::Cop0[count],
					m_Reg.m_CP0[count], SecondCPU->m_Reg.m_CP0[count]);
			}
		}	
		if (m_Reg.m_HI.DW != SecondCPU->m_Reg.m_HI.DW) 
		{
			Error.LogF("HI Reg 0x%08X%08X, 0x%08X%08X\r\n",m_Reg.m_HI.UW[1],m_Reg.m_HI.UW[0],SecondCPU->m_Reg.m_HI.UW[1],SecondCPU->m_Reg.m_HI.UW[0]);
		}
		if (m_Reg.m_LO.DW != SecondCPU->m_Reg.m_LO.DW)
		{
			Error.LogF("LO Reg 0x%08X%08X, 0x%08X%08X\r\n",m_Reg.m_LO.UW[1],m_Reg.m_LO.UW[0], SecondCPU->m_Reg.m_LO.UW[1],SecondCPU->m_Reg.m_LO.UW[0]);
		}
		for (int i = 0, n = sizeof(m_Reg.m_Mips_Interface) / sizeof(m_Reg.m_Mips_Interface[0]); i < n; i ++) 
		{
			if (m_Reg.m_Mips_Interface[i] != SecondCPU->m_Reg.m_Mips_Interface[i])
			{
				Error.LogF("Mips_Interface[%d] 0x%08X, 0x%08X\r\n",i, m_Reg.m_Mips_Interface[i], SecondCPU->m_Reg.m_Mips_Interface[i]);
			}
		}

		for (int i = 0, n = sizeof(m_Reg.m_SigProcessor_Interface) / sizeof(m_Reg.m_SigProcessor_Interface[0]); i < n; i ++) 
		{
			if (m_Reg.m_SigProcessor_Interface[i] != SecondCPU->m_Reg.m_SigProcessor_Interface[i])
			{
				Error.LogF("SigProcessor_Interface[%d] 0x%08X, 0x%08X\r\n",i, m_Reg.m_SigProcessor_Interface[i], SecondCPU->m_Reg.m_SigProcessor_Interface[i]);
			}
		}
		for (int i = 0, n = sizeof(m_Reg.m_Display_ControlReg) / sizeof(m_Reg.m_Display_ControlReg[0]); i < n; i ++) 
		{
			if (m_Reg.m_Display_ControlReg[i] != SecondCPU->m_Reg.m_Display_ControlReg[i])
			{
				Error.LogF("Display_ControlReg[%d] 0x%08X, 0x%08X\r\n",i, m_Reg.m_Display_ControlReg[i], SecondCPU->m_Reg.m_Display_ControlReg[i]);
			}
		}

		if (m_NextTimer     != SecondCPU->m_NextTimer) 
		{ 
			Error.LogF("Current Time: %X %X\r\n",(DWORD)m_NextTimer,(DWORD)SecondCPU->m_NextTimer);
		}
		m_TLB.RecordDifference(Error,SecondCPU->m_TLB);
		m_SystemTimer.RecordDifference(Error,SecondCPU->m_SystemTimer);
		if (m_Reg.m_RoundingModel != SecondCPU->m_Reg.m_RoundingModel) 
		{ 
			Error.LogF("RoundingModel: %X %X\r\n",m_Reg.m_RoundingModel,SecondCPU->m_Reg.m_RoundingModel);
		}
		if (bFastSP() && m_Recomp) 
		{
			if (m_Recomp->MemoryStackPos() != (DWORD)(m_MMU_VM.Rdram() + (m_Reg.m_GPR[29].W[0] & 0x1FFFFFFF)))
			{
				Error.LogF("MemoryStack = %X  should be: %X\r\n",m_Recomp->MemoryStackPos(), (DWORD)(m_MMU_VM.Rdram() + (m_Reg.m_GPR[29].W[0] & 0x1FFFFFFF)));
			}
		}

		DWORD * Rdram = (DWORD *)m_MMU_VM.Rdram(), * Rdram2 = (DWORD *)SecondCPU->m_MMU_VM.Rdram();
		for (int z = 0, n = (RdramSize() >> 2); z < n; z ++)
		{	
			if (Rdram[z] != Rdram2[z]) 
			{
				Error.LogF("Rdram[%X]: %X %X\r\n",z << 2,Rdram[z],Rdram2[z]);
			}
		}

		DWORD * Imem = (DWORD *)m_MMU_VM.Imem(), * Imem2 = (DWORD *)SecondCPU->m_MMU_VM.Imem();
		for (int z = 0; z < (0x1000 >> 2); z ++)
		{	
			if (Imem[z] != Imem2[z]) 
			{
				Error.LogF("Imem[%X]: %X %X\r\n",z << 2,Imem[z],Imem2[z]);
			}
		}
		DWORD * Dmem = (DWORD *)m_MMU_VM.Dmem(), * Dmem2 = (DWORD *)SecondCPU->m_MMU_VM.Dmem();
		for (int z = 0; z < (0x1000 >> 2); z ++)
		{	
			if (Dmem[z] != Dmem2[z]) 
			{
				Error.LogF("Dmem[%X]: %X %X\r\n",z << 2,Dmem[z],Dmem2[z]);
			}
		}
		Error.Log("\r\n");
		Error.Log("Information:\r\n");
		Error.Log("\r\n");
		Error.LogF("PROGRAM_COUNTER,0x%X\r\n",m_Reg.m_PROGRAM_COUNTER);
		Error.LogF("Current Timer,0x%X\r\n",m_NextTimer);
		Error.LogF("Timer Type,0x%X\r\n",m_SystemTimer.CurrentType());
		Error.Log("\r\n");
		for (int i = 0; i < (sizeof(m_LastSuccessSyncPC)/sizeof(m_LastSuccessSyncPC[0])); i++) 
		{
			Error.LogF("LastSuccessSyncPC[%d],0x%X\r\n",i,m_LastSuccessSyncPC[i]);
		}
		Error.Log("\r\n");
		for (count = 0; count < 32; count ++) 
		{
			Error.LogF("GPR[%s],         0x%08X%08X, 0x%08X%08X\r\n",CRegName::GPR[count],
				m_Reg.m_GPR[count].W[1],m_Reg.m_GPR[count].W[0],
				SecondCPU->m_Reg.m_GPR[count].W[1],SecondCPU->m_Reg.m_GPR[count].W[0]);
		}	
		Error.Log("\r\n");
		for (count = 0; count < 32; count ++) 
		{
			Error.LogF("FPR[%s],%*s0x%08X%08X, 0x%08X%08X\r\n",CRegName::FPR[count],
				count < 10 ? 9 : 8," ",m_Reg.m_FPR[count].W[1],m_Reg.m_FPR[count].W[0],
				SecondCPU->m_Reg.m_FPR[count].W[1],SecondCPU->m_Reg.m_FPR[count].W[0]);
		}	
		Error.Log("\r\n");
		for (count = 0; count < 32; count ++) 
		{
			Error.LogF("FPR_S[%s],%*s%f, %f\r\n",CRegName::FPR[count],
				count < 10 ? 7 : 6," ",*(m_Reg.m_FPR_S[count]),*(SecondCPU->m_Reg.m_FPR_S[count]));
		}	
		Error.Log("\r\n");
		for (count = 0; count < 32; count ++) 
		{
			Error.LogF("FPR_D[%s],%*s%f, %f\r\n",CRegName::FPR[count],
				count < 10 ? 7 : 6," ",*(m_Reg.m_FPR_D[count]),*(SecondCPU->m_Reg.m_FPR_D[count]));
		}	
		Error.Log("\r\n");
		Error.LogF("Rounding Model,   0x%08X, 0x%08X\r\n",m_Reg.m_RoundingModel,SecondCPU->m_Reg.m_RoundingModel);
		Error.Log("\r\n");
		for (count = 0; count < 32; count ++)
		{
			Error.LogF("CP0[%s],%*s0x%08X, 0x%08X\r\n",CRegName::Cop0[count],
				12 - strlen(CRegName::Cop0[count]),"",
				m_Reg.m_CP0[count],SecondCPU->m_Reg.m_CP0[count]);
		}	
		Error.Log("\r\n");
		Error.LogF("HI                0x%08X%08X, 0x%08X%08X\r\n",m_Reg.m_HI.UW[1],m_Reg.m_HI.UW[0],
			SecondCPU->m_Reg.m_HI.UW[1],SecondCPU->m_Reg.m_HI.UW[0]);
		Error.LogF("LO                0x%08X%08X, 0x%08X%08X\r\n",m_Reg.m_LO.UW[1],m_Reg.m_LO.UW[0],
			SecondCPU->m_Reg.m_LO.UW[1],SecondCPU->m_Reg.m_LO.UW[0]);
		bool bHasTlb = false;
		for (count = 0; count < 32; count ++) 
		{
			if (!m_TLB.TlbEntry(count).EntryDefined) { continue; }
			if (!bHasTlb)
			{
				Error.Log("\r\n");
				Error.Log("         Hi Recomp, PageMask, Hi Interp, PageMask\r\n");
				bHasTlb = true;
			}
			Error.LogF("TLB[%2d], %08X,  %08X, %08X,  %08X\r\n", count,
				m_TLB.TlbEntry(count).EntryHi.Value,m_TLB.TlbEntry(count).PageMask.Value,
				SecondCPU->m_TLB.TlbEntry(count).EntryHi.Value,SecondCPU->m_TLB.TlbEntry(count).PageMask.Value
			);	
		}
		Error.Log("\r\n");
		Error.Log("Code at PC:\r\n");
		for (count = -10; count < 10; count++)
		{
			DWORD OpcodeValue, Addr = m_Reg.m_PROGRAM_COUNTER + (count << 2);
			if (g_MMU->LW_VAddr(Addr,(uint32_t &)OpcodeValue))
			{
				Error.LogF("%X: %s\r\n",Addr,R4300iOpcodeName(OpcodeValue,Addr));
			}

		}
		Error.Log("\r\n");
		Error.Log("Code at Last Sync PC:\r\n");
		for (count = 0; count < 50; count++)
		{
			DWORD OpcodeValue, Addr = m_LastSuccessSyncPC[0] + (count << 2);
			if (g_MMU->LW_VAddr(Addr,(uint32_t &)OpcodeValue))
			{
				Error.LogF("%X: %s\r\n",Addr,R4300iOpcodeName(OpcodeValue,Addr));
			}

		}
	}

	g_Notify->DisplayError(L"Sync Error");
	g_Notify->BreakPoint(__FILEW__,__LINE__);
}

bool CN64System::SaveState()
{
	WriteTrace(TraceDebug,__FUNCTION__ ": Start");

//	if (!m_SystemTimer.SaveAllowed()) { return false; }
	if ((m_Reg.STATUS_REGISTER & STATUS_EXL) != 0) { return false; }
	
	//Get the file Name
	stdstr FileName, ExtraInfoFileName, CurrentSaveName = g_Settings->LoadStringVal(GameRunning_InstantSaveFile);
	if (CurrentSaveName.empty())
	{
		int Slot = g_Settings->LoadDword(Game_CurrentSaveState);
		if (Slot != 0) 
		{ 
			CurrentSaveName.Format("%s.pj%d",g_Settings->LoadStringVal(Game_GoodName).c_str(), Slot);
		}
		else 
		{
			CurrentSaveName.Format("%s.pj",g_Settings->LoadStringVal(Game_GoodName).c_str());
		}
		FileName.Format("%s%s",g_Settings->LoadStringVal(Directory_InstantSave).c_str(),CurrentSaveName.c_str());
		stdstr_f ZipFileName("%s.zip",FileName.c_str());
		//Make sure the target dir exists	
		CreateDirectory(g_Settings->LoadStringVal(Directory_InstantSave).c_str(),NULL);
		//delete any old save
		DeleteFile(FileName.c_str());
		DeleteFile(ZipFileName.c_str());
		ExtraInfoFileName.Format("%s.dat",CurrentSaveName.c_str());
	
		//If ziping save add .zip on the end
		if (g_Settings->LoadDword(Setting_AutoZipInstantSave))
		{
			FileName = ZipFileName;
		}
		g_Settings->SaveDword(Game_LastSaveSlot,g_Settings->LoadDword(Game_CurrentSaveState));
	} 
	else
	{
		char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
		_splitpath(CurrentSaveName.c_str(), drive, dir, fname, ext);

		FileName.Format("%s.pj", CurrentSaveName.c_str());

		CurrentSaveName.Format("%s.pj", fname);
		ExtraInfoFileName.Format("%s.dat", fname);

		//If ziping save add .zip on the end
		if (g_Settings->LoadDword(Setting_AutoZipInstantSave))
		{
			FileName.Format("%s.zip", FileName.c_str());
		}
	}
	if (FileName.empty()) { return true; }

	//Open the file
	if (g_Settings->LoadDword(Game_FuncLookupMode) == FuncFind_ChangeMemory) 
	{
		if (m_Recomp)
		{
			m_Recomp->ResetRecompCode(true); 
		}
	}

	DWORD dwWritten, SaveID_0 = 0x23D8A6C8, SaveID_1 = 0x56D2CD23;
	DWORD RdramSize   = g_Settings->LoadDword(Game_RDRamSize);
	DWORD MiInterReg  = g_Reg->MI_INTR_REG;
	DWORD NextViTimer = m_SystemTimer.GetTimer(CSystemTimer::ViTimer);
	if (g_Settings->LoadDword(Setting_AutoZipInstantSave))
	{
		zipFile			file;

		file = zipOpen(FileName.c_str(),0);
		zipOpenNewFileInZip(file,CurrentSaveName.c_str(),NULL,NULL,0,NULL,0,NULL,Z_DEFLATED,Z_DEFAULT_COMPRESSION);
		zipWriteInFileInZip(file,&SaveID_0,sizeof(SaveID_0));
		zipWriteInFileInZip(file,&RdramSize,sizeof(DWORD));
		zipWriteInFileInZip(file,g_Rom->GetRomAddress(),0x40);	
		zipWriteInFileInZip(file,&NextViTimer,sizeof(DWORD));
		zipWriteInFileInZip(file,&m_Reg.m_PROGRAM_COUNTER,sizeof(m_Reg.m_PROGRAM_COUNTER));
		zipWriteInFileInZip(file,m_Reg.m_GPR,sizeof(__int64)*32);
		zipWriteInFileInZip(file,m_Reg.m_FPR,sizeof(__int64)*32);
		zipWriteInFileInZip(file,m_Reg.m_CP0,sizeof(DWORD)*32);
		zipWriteInFileInZip(file,m_Reg.m_FPCR,sizeof(DWORD)*32);
		zipWriteInFileInZip(file,&m_Reg.m_HI,sizeof(__int64));
		zipWriteInFileInZip(file,&m_Reg.m_LO,sizeof(__int64));
		zipWriteInFileInZip(file,m_Reg.m_RDRAM_Registers,sizeof(DWORD)*10);
		zipWriteInFileInZip(file,m_Reg.m_SigProcessor_Interface,sizeof(DWORD)*10);
		zipWriteInFileInZip(file,m_Reg.m_Display_ControlReg,sizeof(DWORD)*10);
		zipWriteInFileInZip(file,m_Reg.m_Mips_Interface,sizeof(DWORD)*4);
		zipWriteInFileInZip(file,m_Reg.m_Video_Interface,sizeof(DWORD)*14);
		zipWriteInFileInZip(file,m_Reg.m_Audio_Interface,sizeof(DWORD)*6);
		zipWriteInFileInZip(file,m_Reg.m_Peripheral_Interface,sizeof(DWORD)*13);
		zipWriteInFileInZip(file,m_Reg.m_RDRAM_Interface,sizeof(DWORD)*8);
		zipWriteInFileInZip(file,m_Reg.m_SerialInterface,sizeof(DWORD)*4);
		zipWriteInFileInZip(file,(void *const)&m_TLB.TlbEntry(0),sizeof(CTLB::TLB_ENTRY)*32);
		zipWriteInFileInZip(file,m_MMU_VM.PifRam(),0x40);
		zipWriteInFileInZip(file,m_MMU_VM.Rdram(),RdramSize);
		zipWriteInFileInZip(file,m_MMU_VM.Dmem(),0x1000);
		zipWriteInFileInZip(file,m_MMU_VM.Imem(),0x1000);
		zipCloseFileInZip(file);
		
		zipOpenNewFileInZip(file,ExtraInfoFileName.c_str(),NULL,NULL,0,NULL,0,NULL,Z_DEFLATED,Z_DEFAULT_COMPRESSION);
		zipWriteInFileInZip(file,&SaveID_1,sizeof(SaveID_1));
		m_SystemTimer.SaveData(file);
		zipCloseFileInZip(file);

		zipClose(file,"");
	} 
	else
	{
		HANDLE hSaveFile = CreateFile(FileName.c_str(),GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ,
			NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
		if (hSaveFile == INVALID_HANDLE_VALUE) 
		{
			g_Notify->DisplayError(GS(MSG_FAIL_OPEN_SAVE));
			m_Reg.MI_INTR_REG = MiInterReg;
			return true;
		}

		//Write info to file
		SetFilePointer(hSaveFile,0,NULL,FILE_BEGIN);	
		WriteFile( hSaveFile,&SaveID_0,sizeof(DWORD),&dwWritten,NULL);
		WriteFile( hSaveFile,&RdramSize,sizeof(DWORD),&dwWritten,NULL);
		WriteFile( hSaveFile,g_Rom->GetRomAddress(),0x40,&dwWritten,NULL);	
		WriteFile( hSaveFile,&NextViTimer,sizeof(DWORD),&dwWritten,NULL);
		WriteFile( hSaveFile,&m_Reg.m_PROGRAM_COUNTER,sizeof(m_Reg.m_PROGRAM_COUNTER),&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_GPR,sizeof(__int64)*32,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_FPR,sizeof(__int64)*32,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_CP0,sizeof(DWORD)*32,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_FPCR,sizeof(DWORD)*32,&dwWritten,NULL);
		WriteFile( hSaveFile,&m_Reg.m_HI,sizeof(__int64),&dwWritten,NULL);
		WriteFile( hSaveFile,&m_Reg.m_LO,sizeof(__int64),&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_RDRAM_Registers,sizeof(DWORD)*10,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_SigProcessor_Interface,sizeof(DWORD)*10,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_Display_ControlReg,sizeof(DWORD)*10,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_Mips_Interface,sizeof(DWORD)*4,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_Video_Interface,sizeof(DWORD)*14,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_Audio_Interface,sizeof(DWORD)*6,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_Peripheral_Interface,sizeof(DWORD)*13,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_RDRAM_Interface,sizeof(DWORD)*8,&dwWritten,NULL);
		WriteFile( hSaveFile,m_Reg.m_SerialInterface,sizeof(DWORD)*4,&dwWritten,NULL);
		WriteFile( hSaveFile,&g_TLB->TlbEntry(0),sizeof(CTLB::TLB_ENTRY)*32,&dwWritten,NULL);
		WriteFile( hSaveFile,g_MMU->PifRam(),0x40,&dwWritten,NULL);
		WriteFile( hSaveFile,g_MMU->Rdram(),RdramSize,&dwWritten,NULL);
		WriteFile( hSaveFile,g_MMU->Dmem(),0x1000,&dwWritten,NULL);
		WriteFile( hSaveFile,g_MMU->Imem(),0x1000,&dwWritten,NULL);

		CloseHandle(hSaveFile);
	}
	m_Reg.MI_INTR_REG = MiInterReg;
	g_Settings->SaveString(GameRunning_InstantSaveFile,"");
	std::wstring SaveMessage = g_Lang->GetString(MSG_SAVED_STATE);

	CPath SavedFileName(FileName);
	
    g_Notify->DisplayMessage(5,stdstr_f("%s %s",SaveMessage.c_str(),SavedFileName.GetNameExtension()).ToUTF16().c_str());
	Notify().RefreshMenu();
	WriteTrace(TraceDebug,__FUNCTION__ ": Done");
	return true;
}

bool CN64System::LoadState()
{
	stdstr InstantFileName = g_Settings->LoadStringVal(GameRunning_InstantSaveFile);
	if (!InstantFileName.empty())
	{
		bool Result = LoadState(InstantFileName.c_str());
		g_Settings->SaveString(GameRunning_InstantSaveFile,"");
		return Result;
	}

	CPath FileName;
	FileName.SetDriveDirectory(g_Settings->LoadStringVal(Directory_InstantSave).c_str());
	if (g_Settings->LoadDword(Game_CurrentSaveState) != 0) 
	{
		FileName.SetNameExtension(stdstr_f("%s.pj%d",g_Settings->LoadStringVal(Game_GoodName).c_str(),g_Settings->LoadDword(Game_CurrentSaveState)).c_str());
	} 
	else 
	{
		FileName.SetNameExtension(stdstr_f("%s.pj",g_Settings->LoadStringVal(Game_GoodName).c_str()).c_str());
	}

	CPath ZipFileName;
	ZipFileName = (stdstr&)FileName + ".zip";

	if ((g_Settings->LoadDword(Setting_AutoZipInstantSave) && ZipFileName.Exists()) || FileName.Exists())
	{
		if (LoadState(FileName))
		{
			return true;
		}
	}

	//Use old file Name
	if (g_Settings->LoadDword(Game_CurrentSaveState) != 0) 
	{ 
		FileName.SetNameExtension(stdstr_f("%s.pj%d",g_Settings->LoadStringVal(Game_GameName).c_str(),g_Settings->LoadDword(Game_CurrentSaveState)).c_str());
	}
	else
	{
		FileName.SetNameExtension(stdstr_f("%s.pj",g_Settings->LoadStringVal(Game_GameName).c_str()).c_str());
	}
	return LoadState(FileName);
}

bool CN64System::LoadState(LPCSTR FileName) 
{
	DWORD dwRead, Value,SaveRDRAMSize, NextVITimer = 0, old_status, old_width, old_dacrate;
	bool LoadedZipFile = false, AudioResetOnLoad;
	old_status = g_Reg->VI_STATUS_REG;
	old_width = g_Reg->VI_WIDTH_REG;
	old_dacrate = g_Reg->AI_DACRATE_REG;
	
	WriteTraceF((TraceType)(TraceDebug | TraceRecompiler),__FUNCTION__ "(%s): Start",FileName);

	char drive[_MAX_DRIVE] ,dir[_MAX_DIR], fname[_MAX_FNAME],ext[_MAX_EXT];
	_splitpath(FileName, drive, dir, fname, ext);

	stdstr FileNameStr(FileName);
	if (g_Settings->LoadDword(Setting_AutoZipInstantSave) || _stricmp(ext,".zip") == 0) 
	{
		//If ziping save add .zip on the end
		if (_stricmp(ext,".zip") != 0)
		{
			FileNameStr += ".zip";
		}
		unzFile file = unzOpen(FileNameStr.c_str());
		int port = -1;
		if (file != NULL) 
		{
			port = unzGoToFirstFile(file);
		}
		DWORD Value;
		while (port == UNZ_OK) 
		{
			unz_file_info info;
			char zname[132];

			unzGetCurrentFileInfo(file, &info, zname, 128, NULL,0, NULL,0);
			if (unzLocateFile(file, zname, 1) != UNZ_OK ) 
			{
				unzClose(file);
				port = -1;
				continue;
			}
			if( unzOpenCurrentFile(file) != UNZ_OK ) 
			{
				unzClose(file);
				port = -1;
				continue;
			}
			unzReadCurrentFile(file,&Value,4);
			if (Value != 0x23D8A6C8 && Value != 0x56D2CD23) 
			{
				unzCloseCurrentFile(file);
				port = unzGoToNextFile(file);
				continue;
			}
			if (!LoadedZipFile && Value == 0x23D8A6C8 && port == UNZ_OK) 
			{
				unzReadCurrentFile(file,&SaveRDRAMSize,sizeof(SaveRDRAMSize));
				//Check header

				BYTE LoadHeader[64];
				unzReadCurrentFile(file,LoadHeader,0x40);
				if (memcmp(LoadHeader,g_Rom->GetRomAddress(),0x40) != 0)
				{
					//if (inFullScreen) { return false; }
					int result = MessageBoxW(NULL,GS(MSG_SAVE_STATE_HEADER),GS(MSG_MSGBOX_TITLE),
						MB_YESNO|MB_ICONQUESTION|MB_DEFBUTTON2);

					if (result == IDNO)
						return false;
				}
				Reset(false,true);

				g_MMU->UnProtectMemory(0x80000000,0x80000000 + g_Settings->LoadDword(Game_RDRamSize) - 4);
				g_MMU->UnProtectMemory(0xA4000000,0xA4001FFC);
				g_Settings->SaveDword(Game_RDRamSize,SaveRDRAMSize);
				unzReadCurrentFile(file,&NextVITimer,sizeof(NextVITimer));
				unzReadCurrentFile(file,&m_Reg.m_PROGRAM_COUNTER,sizeof(m_Reg.m_PROGRAM_COUNTER));
				unzReadCurrentFile(file,m_Reg.m_GPR,sizeof(__int64)*32);
				unzReadCurrentFile(file,m_Reg.m_FPR,sizeof(__int64)*32);
				unzReadCurrentFile(file,m_Reg.m_CP0,sizeof(DWORD)*32);
				unzReadCurrentFile(file,m_Reg.m_FPCR,sizeof(DWORD)*32);
				unzReadCurrentFile(file,&m_Reg.m_HI,sizeof(__int64));
				unzReadCurrentFile(file,&m_Reg.m_LO,sizeof(__int64));
				unzReadCurrentFile(file,m_Reg.m_RDRAM_Registers,sizeof(DWORD)*10);
				unzReadCurrentFile(file,m_Reg.m_SigProcessor_Interface,sizeof(DWORD)*10);
				unzReadCurrentFile(file,m_Reg.m_Display_ControlReg,sizeof(DWORD)*10);
				unzReadCurrentFile(file,m_Reg.m_Mips_Interface,sizeof(DWORD)*4);
				unzReadCurrentFile(file,m_Reg.m_Video_Interface,sizeof(DWORD)*14);
				unzReadCurrentFile(file,m_Reg.m_Audio_Interface,sizeof(DWORD)*6);
				unzReadCurrentFile(file,m_Reg.m_Peripheral_Interface,sizeof(DWORD)*13);
				unzReadCurrentFile(file,m_Reg.m_RDRAM_Interface,sizeof(DWORD)*8);
				unzReadCurrentFile(file,m_Reg.m_SerialInterface,sizeof(DWORD)*4);
				unzReadCurrentFile(file,(void *const)&g_TLB->TlbEntry(0),sizeof(CTLB::TLB_ENTRY)*32);
				unzReadCurrentFile(file,m_MMU_VM.PifRam(),0x40);
				unzReadCurrentFile(file,m_MMU_VM.Rdram(),SaveRDRAMSize);
				unzReadCurrentFile(file,m_MMU_VM.Dmem(),0x1000);
				unzReadCurrentFile(file,m_MMU_VM.Imem(),0x1000);
				unzCloseCurrentFile(file);
				port = unzGoToFirstFile(file);
				LoadedZipFile = true;
				continue;
			}
			if (LoadedZipFile && Value == 0x56D2CD23 && port == UNZ_OK) 
			{
				m_SystemTimer.LoadData(file);
			}
			unzCloseCurrentFile(file);
			port = unzGoToNextFile(file);
		}
		unzClose(file);
	}
	if (!LoadedZipFile) 
	{
		HANDLE hSaveFile = CreateFile(FileNameStr.c_str(),GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ,NULL,
			OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
		if (hSaveFile == INVALID_HANDLE_VALUE) 
		{
			g_Notify->DisplayMessage(5,stdstr_f("%s %s",GS(MSG_UNABLED_LOAD_STATE),FileNameStr).ToUTF16().c_str());
			return false;
		}

		SetFilePointer(hSaveFile,0,NULL,FILE_BEGIN);
		ReadFile( hSaveFile,&Value,sizeof(Value),&dwRead,NULL);
		if (Value != 0x23D8A6C8)
			return false;

		ReadFile( hSaveFile,&SaveRDRAMSize,sizeof(SaveRDRAMSize),&dwRead,NULL);
		//Check header
		BYTE LoadHeader[64];
		ReadFile( hSaveFile,LoadHeader,0x40,&dwRead,NULL);
		if (memcmp(LoadHeader,g_Rom->GetRomAddress(),0x40) != 0)
		{
			//if (inFullScreen) { return false; }
			int result = MessageBoxW(NULL,GS(MSG_SAVE_STATE_HEADER),GS(MSG_MSGBOX_TITLE),
				MB_YESNO|MB_ICONQUESTION|MB_DEFBUTTON2);

			if (result == IDNO)
				return false;
		}
		Reset(false,true);
		m_MMU_VM.UnProtectMemory(0x80000000,0x80000000 + g_Settings->LoadDword(Game_RDRamSize) - 4);
		m_MMU_VM.UnProtectMemory(0xA4000000,0xA4001FFC);
		g_Settings->SaveDword(Game_RDRamSize,SaveRDRAMSize);

		ReadFile( hSaveFile,&NextVITimer,sizeof(NextVITimer),&dwRead,NULL);
		ReadFile( hSaveFile,&m_Reg.m_PROGRAM_COUNTER,sizeof(m_Reg.m_PROGRAM_COUNTER),&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_GPR,sizeof(__int64)*32,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_FPR,sizeof(__int64)*32,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_CP0,sizeof(DWORD)*32,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_FPCR,sizeof(DWORD)*32,&dwRead,NULL);
		ReadFile( hSaveFile,&m_Reg.m_HI,sizeof(__int64),&dwRead,NULL);
		ReadFile( hSaveFile,&m_Reg.m_LO,sizeof(__int64),&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_RDRAM_Registers,sizeof(DWORD)*10,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_SigProcessor_Interface,sizeof(DWORD)*10,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_Display_ControlReg,sizeof(DWORD)*10,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_Mips_Interface,sizeof(DWORD)*4,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_Video_Interface,sizeof(DWORD)*14,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_Audio_Interface,sizeof(DWORD)*6,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_Peripheral_Interface,sizeof(DWORD)*13,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_RDRAM_Interface,sizeof(DWORD)*8,&dwRead,NULL);
		ReadFile( hSaveFile,m_Reg.m_SerialInterface,sizeof(DWORD)*4,&dwRead,NULL);
		ReadFile( hSaveFile,(void *const)&g_TLB->TlbEntry(0),sizeof(CTLB::TLB_ENTRY)*32,&dwRead,NULL);
		ReadFile( hSaveFile,m_MMU_VM.PifRam(),0x40,&dwRead,NULL);
		ReadFile( hSaveFile,m_MMU_VM.Rdram(),SaveRDRAMSize,&dwRead,NULL);
		ReadFile( hSaveFile,m_MMU_VM.Dmem(),0x1000,&dwRead,NULL);
		ReadFile( hSaveFile,m_MMU_VM.Imem(),0x1000,&dwRead,NULL);
		CloseHandle(hSaveFile);
	}
	
	//Fix losing audio in certain games with certain plugins
	AudioResetOnLoad = g_Settings->LoadBool(Game_AudioResetOnLoad);
	if (AudioResetOnLoad)
	{
		m_Reg.m_AudioIntrReg |= MI_INTR_AI;
		m_Reg.AI_STATUS_REG &= ~AI_STATUS_FIFO_FULL;
		g_Reg->MI_INTR_REG |= MI_INTR_AI;
	}
	
	if (bFixedAudio())
	{
		m_Audio.SetFrequency(m_Reg.AI_DACRATE_REG, g_System->SystemType());
	}
	
	if (old_status != g_Reg->VI_STATUS_REG)
	{
		g_Plugins->Gfx()->ViStatusChanged();
	}
	
	if (old_width != g_Reg->VI_WIDTH_REG)
	{
		g_Plugins->Gfx()->ViWidthChanged();
	}
	
	if (old_dacrate != g_Reg->AI_DACRATE_REG)
	{
		g_Plugins->Audio()->DacrateChanged(g_System->SystemType());
	}
	
	//Fix Random Register
	while ((int)m_Reg.RANDOM_REGISTER < (int)m_Reg.WIRED_REGISTER)
	{
		m_Reg.RANDOM_REGISTER += 32 - m_Reg.WIRED_REGISTER;
	}
	//Fix up timer
	WriteTrace(TraceDebug,__FUNCTION__ ": 2");
	m_SystemTimer.SetTimer(CSystemTimer::CompareTimer,m_Reg.COMPARE_REGISTER - m_Reg.COUNT_REGISTER,false);
	m_SystemTimer.SetTimer(CSystemTimer::ViTimer,NextVITimer,false);
	m_Reg.FixFpuLocations();
	WriteTrace(TraceDebug,__FUNCTION__ ": 5");
	m_TLB.Reset(false);
	WriteTrace(TraceDebug,__FUNCTION__ ": 6");
	m_CPU_Usage.ResetCounters();
	WriteTrace(TraceDebug,__FUNCTION__ ": 7");
	m_Profile.ResetCounters();
	WriteTrace(TraceDebug,__FUNCTION__ ": 8");
	m_FPS.Reset(true);
	WriteTrace(TraceDebug,__FUNCTION__ ": 9");
	if (bLogX86Code())
	{
		Stop_x86_Log();
		Start_x86_Log();
	}
	WriteTrace(TraceDebug,__FUNCTION__ ": Done");

#ifdef TEST_SP_TRACKING
	m_CurrentSP = GPR[29].UW[0];
#endif
	if (bFastSP() && m_Recomp) { m_Recomp->ResetMemoryStackPos(); }

	if (g_Settings->LoadDword(Game_CpuType) == CPU_SyncCores) 
	{
		if (m_SyncCPU)
		{
			for (int i = 0; i < (sizeof(m_LastSuccessSyncPC)/sizeof(m_LastSuccessSyncPC[0])); i++) 
			{
				m_LastSuccessSyncPC[i] = 0;
			}
			m_SyncCPU->SetActiveSystem(true);
			m_SyncCPU->LoadState(FileNameStr.c_str());
			SetActiveSystem(true);
			SyncCPU(m_SyncCPU);
		}
	}
	WriteTrace(TraceDebug,__FUNCTION__ ": 13");
	std::wstring LoadMsg = g_Lang->GetString(MSG_LOADED_STATE);
	g_Notify->DisplayMessage(5,stdstr_f("%s %s",LoadMsg.c_str(),CPath(FileNameStr).GetNameExtension()).ToUTF16().c_str());
	WriteTrace(TraceDebug,__FUNCTION__ ": Done");
	return true;
}

void CN64System::DisplayRSPListCount()
{
	g_Notify->DisplayMessage(0, stdstr_f("Dlist: %d   Alist: %d   Unknown: %d", m_DlistCount, m_AlistCount, m_UnknownCount).ToUTF16().c_str());
}

void CN64System::RunRSP()
{
	WriteTraceF(TraceRSP, __FUNCTION__ ": Start (SP Status %X)",m_Reg.SP_STATUS_REG);
	if ( ( m_Reg.SP_STATUS_REG & SP_STATUS_HALT ) == 0) 
    {
		if ( ( m_Reg.SP_STATUS_REG & SP_STATUS_BROKE ) == 0 ) 
        {
			SPECIAL_TIMERS CPU_UsageAddr = Timer_None/*, ProfileAddr = Timer_None*/;
			
			DWORD Task = 0;
			if (m_RspBroke)
			{
				g_MMU->LW_VAddr(0xA4000FC0,(uint32_t &)Task);
				if (Task == 1 && (m_Reg.DPC_STATUS_REG & DPC_STATUS_FREEZE) != 0) 
				{
					WriteTrace(TraceRSP, __FUNCTION__ ": Dlist that is frozen");
					return;
				}

				switch (Task)
				{
				case 1:  
					WriteTrace(TraceRSP, __FUNCTION__ ": *** Display list ***");
					m_DlistCount   += 1; 
					m_FPS.UpdateDlCounter();
					break;
				case 2:  
					WriteTrace(TraceRSP, __FUNCTION__ ": *** Audio list ***");
					m_AlistCount   += 1; 
					break;
				default: 
					WriteTrace(TraceRSP, __FUNCTION__ ": *** Unknown list ***");
					m_UnknownCount += 1; 
					break;
				}

				if (bShowDListAListCount())
				{
					DisplayRSPListCount();
				}
				if (bShowCPUPer()) 
				{
					switch (Task) 
					{
					case 1:  CPU_UsageAddr = m_CPU_Usage.StartTimer(Timer_RSP_Dlist); break;
					case 2:  CPU_UsageAddr = m_CPU_Usage.StartTimer(Timer_RSP_Alist); break;
					default: CPU_UsageAddr = m_CPU_Usage.StartTimer(Timer_RSP_Unknown); break;
					}
				}
			}
			

			__try 
			{
				WriteTrace(TraceRSP, __FUNCTION__ ": do cycles - starting");
				g_Plugins->RSP()->DoRspCycles(100);
				WriteTrace(TraceRSP, __FUNCTION__ ": do cycles - Done");
			}
			__except( g_MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) ) 
			{
				WriteTrace(TraceError, __FUNCTION__ ": exception generated");
				g_Notify->FatalError(__FUNCTIONW__ L"\nUnknown memory action\n\nEmulation stop");
			}

			if (Task == 1 && bDelayDP() && ((m_Reg.m_GfxIntrReg & MI_INTR_DP) != 0))
			{
				g_SystemTimer->SetTimer(CSystemTimer::RSPTimerDlist,0x1000,false);
				m_Reg.m_GfxIntrReg &= ~MI_INTR_DP;
			}
			if (bShowCPUPer())  { m_CPU_Usage.StartTimer(CPU_UsageAddr); }
			//if (bProfiling) { m_Profile.StartTimer(ProfileAddr); }

			if ( ( m_Reg.SP_STATUS_REG & SP_STATUS_HALT ) == 0 && 
				( m_Reg.SP_STATUS_REG & SP_STATUS_BROKE ) == 0 && 
				m_Reg.m_RspIntrReg == 0) 
			{
				g_SystemTimer->SetTimer(CSystemTimer::RspTimer,0x200,false);
				m_RspBroke = false;
			}
			else
			{
				m_RspBroke = true;
			}
			WriteTrace(TraceRSP, __FUNCTION__ ": check interrupts");
			g_Reg->CheckInterrupts();
		}
	}
	WriteTraceF(TraceRSP, __FUNCTION__ ": Done (SP Status %X)",m_Reg.SP_STATUS_REG);
}

void CN64System::SyncToAudio()
{
	if (!bSyncToAudio() || !bLimitFPS())
	{
		return;
	}
	SPECIAL_TIMERS CPU_UsageAddr = Timer_None;

	if (bShowCPUPer()) { CPU_UsageAddr = m_CPU_Usage.StartTimer(Timer_Idel); }
	
	for (int i = 0; i < 50; i++)
	{
		if (g_Reg->m_AudioIntrReg != 0)
		{
			WriteTraceF(TraceAudio, __FUNCTION__ ": Audio Interrupt done (%d)",i);
			break;
		}
		Sleep(1);
	}
	if (bShowCPUPer()) 
	{
		m_CPU_Usage.StartTimer(CPU_UsageAddr != Timer_None ? CPU_UsageAddr : Timer_R4300 );
	}
}

void CN64System::RefreshScreen()
{
	SPECIAL_TIMERS CPU_UsageAddr = Timer_None/*, ProfilingAddr = Timer_None*/;
	DWORD VI_INTR_TIME = 500000;
	
	if (bShowCPUPer()) { CPU_UsageAddr = m_CPU_Usage.StartTimer(Timer_RefreshScreen); }
	//if (bProfiling)    { ProfilingAddr = m_Profile.StartTimer(Timer_RefreshScreen); }

	//Calculate how many cycles to next refresh
	if (m_Reg.VI_V_SYNC_REG == 0) 
	{
		VI_INTR_TIME = 500000;
	}
	else
	{
		VI_INTR_TIME = (m_Reg.VI_V_SYNC_REG + 1) * ViRefreshRate();
		if ((m_Reg.VI_V_SYNC_REG % 1) != 0) 
		{
			VI_INTR_TIME -= 38;
		}
	}
	g_SystemTimer->SetTimer(CSystemTimer::ViTimer,VI_INTR_TIME,true);
	if (bFixedAudio())
	{
		g_Audio->SetViIntr (VI_INTR_TIME);	
	}
	if (g_Plugins->Control()->GetKeys) 
	{
		BUTTONS Keys;
		memset(&Keys,0,sizeof(Keys));

		for (int Control = 0; Control < 4; Control++)
		{	
			g_Plugins->Control()->GetKeys(Control,&Keys);
			m_Buttons[Control] = Keys.Value;
		}
	}

	if (bShowCPUPer()) { m_CPU_Usage.StartTimer(Timer_UpdateScreen); }
//	if (bProfiling)    { m_Profile.StartTimer(Timer_UpdateScreen); }
	
	__try
	{
		WriteTrace(TraceGfxPlugin,__FUNCTION__ ": Starting");
		g_Plugins->Gfx()->UpdateScreen();
		WriteTrace(TraceGfxPlugin,__FUNCTION__ ": Done");
	}
	__except (g_MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation())) 
	{
		WriteTrace(TraceGfxPlugin,__FUNCTION__ ": Exception caught");
		WriteTrace(TraceError,__FUNCTION__ ": Exception caught");
	}

	g_MMU->UpdateFieldSerration((m_Reg.VI_STATUS_REG & 0x40) != 0);

	if ((bBasicMode() || bLimitFPS()) && !bSyncToAudio())
	{
		if (bShowCPUPer()) { m_CPU_Usage.StartTimer(Timer_Idel); }
		uint32_t FrameRate;
		if (m_Limitor.Timer_Process(&FrameRate) && bDisplayFrameRate())
		{
			m_FPS.DisplayViCounter(FrameRate);
			m_bCleanFrameBox = true;
		}
	}
	else if (bDisplayFrameRate())
	{
		if (bShowCPUPer()) { m_CPU_Usage.StartTimer(Timer_UpdateFPS); }
		m_FPS.UpdateViCounter();
		m_bCleanFrameBox = true;
	}
	
	if (m_bCleanFrameBox && !bDisplayFrameRate())
	{
		m_FPS.Reset (true);
		m_bCleanFrameBox = false;
	}

	if (bShowCPUPer()) 
	{
		m_CPU_Usage.StopTimer();
		m_CPU_Usage.ShowCPU_Usage();
		m_CPU_Usage.StartTimer(CPU_UsageAddr != Timer_None ? CPU_UsageAddr : Timer_R4300 );
	}
	if ((m_Reg.STATUS_REGISTER & STATUS_IE) != 0)
	{
		if (HasCheatsSlectionChanged())
		{
			if (this == g_BaseSystem && g_SyncSystem != NULL)
			{
				g_SyncSystem->SetCheatsSlectionChanged(true);
			}
			SetCheatsSlectionChanged(false);
			m_Cheats.LoadCheats(false, g_BaseSystem->m_Plugins);
		}
		m_Cheats.ApplyCheats(g_MMU);
	}
	//	if (bProfiling)    { m_Profile.StartTimer(ProfilingAddr != Timer_None ? ProfilingAddr : Timer_R4300); }
}

bool CN64System::WriteToProtectedMemory (uint32_t Address, int length)
{
	WriteTraceF(TraceDebug,__FUNCTION__ ": Address: %X Len: %d",Address,length);
	if (m_Recomp)
	{
		g_Notify->BreakPoint(__FILEW__,__LINE__);
#ifdef tofix
		return m_Recomp->ClearRecompCode_Phys(Address,length,CRecompiler::Remove_ProtectedMem);
#endif
	}
	return false;
}

void CN64System::TLB_Mapped ( uint32_t VAddr, uint32_t Len, uint32_t PAddr, bool bReadOnly )
{
	m_MMU_VM.TLB_Mapped(VAddr,Len,PAddr,bReadOnly);
}

void CN64System::TLB_Unmaped ( uint32_t VAddr, uint32_t Len )
{
	m_MMU_VM.TLB_Unmaped(VAddr,Len);
	if (m_Recomp && bSMM_TLB())
	{
		m_Recomp->ClearRecompCode_Virt(VAddr,Len,CRecompiler::Remove_TLB);
	}
}

void CN64System::TLB_Changed()
{
	if (g_Debugger)
	{
		g_Debugger->TLBChanged();
	}
}