diff --git a/source/fileio/cdfile.cpp b/source/fileio/cdfile.cpp
new file mode 100644
index 000000000..0550b212c
--- /dev/null
+++ b/source/fileio/cdfile.cpp
@@ -0,0 +1,53 @@
+/***********************************/
+/*** PSX CD BigLump FileIO Stuff ***/
+/***********************************/
+
+#include 	"system\global.h"
+#include	"fileio\fileio.h"
+#include 	"fileio\cdfile.h"
+#include 	<libcd.h>
+#include	"system\vid.h"
+#include	"sound\cdxa.h"
+
+/*****************************************************************************/
+CCDFileIO::CCDFileIO(u32 FilePos,sBigLump *BigLumpPtr)
+{
+		DbgMsg0("CD FILE SYSTEM\n");	
+		while (!CdInit());
+
+#if		!defined(__USER_CDBUILD__)
+		CFileIO::FindAllFilePos();
+#endif			
+		BigLump=BigLumpPtr;
+		FileStart=CFileIO::GetFilePos(FILEPOS_BIGLUMP);
+		CXAStream::SetSector(CFileIO::GetFilePos(FILEPOS_TRACK1));
+}
+
+/*****************************************************************************/
+void 	CCDFileIO::Open()
+{
+}
+
+/*****************************************************************************/
+void 	CCDFileIO::Read(u32 Count,void *Dst)
+{
+u8		Com=CdlModeSpeed;
+int		Error=0;
+// seek
+
+		while (!Error)
+	        {
+			CdIntToPos(BigLump->Sector+FileStart,&CdPos);
+	    	CdControlB(CdlSetloc, (u8*)&CdPos, 0);	// Set CD Pos
+	    	CdControlB(CdlSetmode, &Com, 0);
+			Error=CdRead(Count, (u32*)Dst, CdlModeSpeed);
+	        }
+		while (CdReadSync(1,0) > 0);
+		BigLump->Sector+=Count;
+}
+
+/*****************************************************************************/
+void 	CCDFileIO::Close()
+{
+}
+
diff --git a/source/fileio/cdfile.h b/source/fileio/cdfile.h
new file mode 100644
index 000000000..ab751fb95
--- /dev/null
+++ b/source/fileio/cdfile.h
@@ -0,0 +1,30 @@
+/***************************/
+/*** PSX CD FileIO Stuff ***/
+/***************************/
+
+#ifndef __CDFILE_H__
+#define __CDFILE_H__
+
+#include	"fileio\fileio.h"
+
+/*****************************************************************************/
+class CCDFileIO : public CLOFileIO
+{
+public:
+	CCDFileIO(u32 FilePos,sBigLump *BigLumpPtr);
+	virtual ~CCDFileIO(){};
+
+	void 		Open();
+	void 		Read(u32 Length,void *Buffer);
+	void 		Close();
+
+private:
+	sBigLump	*BigLump;
+	u32 		FileStart;
+	CdlLOC		CdPos;
+	static	int	HasInit;
+};
+
+/*****************************************************************************/
+#endif
+
diff --git a/source/fileio/fileio.cpp b/source/fileio/fileio.cpp
new file mode 100644
index 000000000..9758df28e
--- /dev/null
+++ b/source/fileio/fileio.cpp
@@ -0,0 +1,380 @@
+/***************************************/
+/*** PSX PC/CD Big Lump FileIO Stuff ***/
+/***************************************/
+
+#include	"system\global.h"
+#include	"fileio\fileio.h"
+#if			__FILE_SYSTEM__==PC
+#include	"fileio\pcfile.h"
+#else
+#include	"fileio\cdfile.h"
+#endif
+#include	"utils\replace.h"
+#include	"utils\utils.h"
+
+char	*LumpNames[]=
+{
+"BIGLUMP.BIN",
+};
+
+/*****************************************************************************/
+sBigLump	CFileIO::BigLump;
+CLOFileIO	*CFileIO::FileIO;
+int			CFileIO::FilePosList[FILEPOS_MAX];
+
+sFAT		*CFileIO::MainFAT=0;
+
+/*****************************************************************************/
+sDataBank	CFileIO::DataBank[DATABANK_MAX]=
+{
+/*	
+	{SYSTEM_CACHE	,0},
+	{FRONTEND_CACHE	,0},
+	{LEVEL1_CACHE	,0},
+	{LEVEL2_CACHE	,0},
+	{LEVEL3_CACHE	,0},
+	{LEVEL4_CACHE	,0},
+	{LEVEL5_CACHE	,0},
+	{LEVEL6_CACHE	,0},
+	{LEVEL7_CACHE	,0},
+	{LEVEL8_CACHE	,0},
+	{BACKEND_CACHE	,0},
+*/	
+};
+
+DataBankEquate	CFileIO::CurrentDataBank=DATABANK_MAX;
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+//sFAT	*FAT;
+void	CFileIO::Init()
+{
+		DBG_MSG0("IO INIT!!!!\n");
+
+#if		__FILE_SYSTEM__==PC
+		FileIO=new ("CFileIO::FileIOInit") CPCFileIO(LumpNames[DataLump],&BigLump);
+#else
+		FileIO=new ("CFileIO::FileIOInit") CCDFileIO(0,&BigLump);
+#endif
+		BigLump.Status=BLStatusReady;
+
+int		FATSize=FileEquate_MAX*sizeof(sFAT);
+// Read Main FAT (special case load)
+		MainFAT=(sFAT *)MemAlloc( FATSize,"MainFAT");
+
+		DBG_MSG1("FATSIZE=%i\n",FATSize);
+		FileIO->Open();
+
+		BigLump.Status = BLStatusOpen;
+		BigLump.Sector=0;
+		BigLump.Length=FATSize;
+		BigLump.LengthLeft=BigLump.Length;
+		BigLump.ReadSoFar=0;
+		BigLump.LoadMode = FILEIO_MODE_NONE;
+		BigLump.ChunkLeft=0;
+		ReadFile(MainFAT,FATSize);
+		CloseFile();
+
+		for (int Bank=0;Bank<DATABANK_MAX; Bank++) DataBank[Bank].Data=0;
+//		loadDataBank(DATABANK_SYSTEM);
+//		CurrentDataBank=DATABANK_MAX;
+}
+
+/*****************************************************************************/
+/*** Open ********************************************************************/
+/*****************************************************************************/
+void	CFileIO::OpenFile( FileEquate file )
+{
+	ASSERT(MainFAT);
+	FileIO->Open();
+	BigLump.Status = BLStatusOpen;
+	BigLump.Sector = getFileSector( ( file ) );
+	BigLump.Length = getFileSize( ( file ) );
+	BigLump.LengthLeft = BigLump.Length;
+	BigLump.ReadSoFar=0;
+	BigLump.LoadMode = FILEIO_MODE_NONE;
+	BigLump.ChunkLeft=0;
+}
+
+/*****************************************************************************/
+/*** Read ********************************************************************/
+/*****************************************************************************/
+void   	CFileIO::CheckChunk()
+{
+int	ChunkCount;
+	if (!BigLump.ChunkLeft)
+		{
+		ChunkCount=BigLump.LengthLeft/2048;
+		if (ChunkCount>FILEIO_MAXCHUNKS) ChunkCount=FILEIO_MAXCHUNKS;
+		else
+		if (ChunkCount<FILEIO_MINCHUNKS) ChunkCount=FILEIO_MINCHUNKS;
+	   	BigLump.ChunkPtr=BigLump.ChunkBuffer;
+	   	BigLump.ChunkLeft=ChunkCount*2048;
+	   	FileIO->Read(ChunkCount, (char*)BigLump.ChunkPtr);
+		}
+}
+
+/*****************************************************************************/
+long CFileIO::ReadFile( void * Buffer, s32 Length )
+{
+int	ThisLoadSize;
+
+	BigLump.LoadLeft=Length;
+	BigLump.DstPtr=(u8*)Buffer;
+
+	while (BigLump.LoadLeft)
+		{
+		if (BigLump.LoadMode==FILEIO_MODE_NONE)
+			{
+			if (BigLump.LoadLeft>=FILEIO_CHUNKSIZE)
+				BigLump.LoadMode = FILEIO_MODE_CHUNK;
+			else
+				BigLump.LoadMode = FILEIO_MODE_STREAM;
+			}
+
+		switch (BigLump.LoadMode)
+		    {
+		    case FILEIO_MODE_CHUNK:			// Load large chunk
+				ThisLoadSize=BigLump.LoadLeft-(BigLump.LoadLeft%FILEIO_CHUNKSIZE);
+			   	FileIO->Read(ThisLoadSize/FILEIO_CHUNKSIZE, (char*)BigLump.DstPtr);
+				BigLump.DstPtr+=ThisLoadSize;
+				BigLump.LoadLeft-=ThisLoadSize;
+				BigLump.LengthLeft-=ThisLoadSize;
+				BigLump.ReadSoFar+=ThisLoadSize;
+				BigLump.LoadMode=FILEIO_MODE_NONE;
+				break;
+	
+		    case FILEIO_MODE_STREAM:		// Stream chunk
+				CheckChunk();
+				ThisLoadSize=BigLump.LoadLeft;
+				if (ThisLoadSize>BigLump.ChunkLeft) ThisLoadSize=BigLump.ChunkLeft;
+	        	if (BigLump.DstPtr) MCmemcpy(BigLump.DstPtr, BigLump.ChunkPtr, ThisLoadSize );
+
+				BigLump.ChunkLeft-=ThisLoadSize; 
+				BigLump.DstPtr+=ThisLoadSize;
+				BigLump.ChunkPtr+=ThisLoadSize;
+				BigLump.LoadLeft-=ThisLoadSize;
+				BigLump.LengthLeft-=ThisLoadSize;
+				BigLump.ReadSoFar+=ThisLoadSize;
+				if (!BigLump.ChunkLeft) BigLump.LoadMode=FILEIO_MODE_NONE;
+				break;
+			default:
+				ASSERT(!"Unknown Load Type!");
+		    }
+		}
+
+	return (BigLump.LoadLeft);
+}
+
+/*****************************************************************************/
+/*** Load ********************************************************************/
+/*****************************************************************************/
+u8 * CFileIO::loadFile( FileEquate file, char *allocName )
+{
+	u8 *	buffer;
+	s32		Length;
+
+// Is Already loaded in a databank?
+	buffer=isFileInDataBank(file);
+	if (buffer) return(buffer);
+
+	Length = getFileSize( file );
+
+	buffer = (u8 *)MemAlloc( Length ,allocName);
+	ASSERT( buffer );
+#if defined(__USER_ART__)
+	EnterCriticalSection();
+#endif
+	OpenFile( file );
+	ReadFile( buffer, Length );
+	CloseFile();
+#if defined(__USER_ART__)
+	ExitCriticalSection();
+#endif
+
+	return buffer;
+}
+
+/*****************************************************************************/
+int		CFileIO::IsFromDataBank(void *Addr)
+{
+// See if we can find the file by its address
+// Simply check if address is within a bank range
+// Dont check start address, as this will prevent the bank from being freed
+		for (int Bank=0;Bank<DATABANK_MAX; Bank++) 
+			{
+			sDataBank	&ThisBank=DataBank[Bank];
+			if (ThisBank.Data)
+				{
+				int	Size=getFileSize(ThisBank.Filename);
+				u8	*StartAddr=(u8*)ThisBank.Data;
+				u8	*EndAddr=StartAddr+Size;
+				if (Addr>StartAddr && Addr <=EndAddr) return(1);
+				}
+			}
+	return(0);
+}
+
+/*****************************************************************************/
+u8 * CFileIO::loadFileAtAddr( FileEquate file, u8* buffer)
+{
+	s32		Length;
+
+	Length = getFileSize( file );
+
+	ASSERT( buffer );
+#if defined(__USER_ART__)
+	EnterCriticalSection();
+#endif
+	OpenFile( file );
+	ReadFile( buffer, Length );
+	CloseFile();
+#if defined(__USER_ART__)
+	ExitCriticalSection();
+#endif
+
+	return buffer;
+}
+
+/*****************************************************************************/
+/*** Close *******************************************************************/
+/*****************************************************************************/
+void 	CFileIO::CloseFile()
+{
+	FileIO->Close();
+	BigLump.Status=BLStatusReady;
+}
+
+
+/*****************************************************************************/
+void 	CFileIO::LoadFileSizeAtAddr(FileEquate Filename,void *Buffer,u32 Length)
+{
+#if defined(__USER_ART__)
+	EnterCriticalSection();
+#endif
+	OpenFile(Filename);
+	ReadFile(Buffer,Length);
+	CloseFile();
+#if defined(__USER_ART__)
+	ExitCriticalSection();
+#endif
+
+
+}
+
+/*****************************************************************************/
+void 	CFileIO::AlignFile(int Align)
+{
+int		Length = ((BigLump.ReadSoFar+Align-1)&-Align)-BigLump.ReadSoFar;
+
+	if (Length)
+		{
+		ReadFile( NULL, Length );
+		}
+}
+
+/*****************************************************************************/
+
+s32		CFileIO::getFileSize( FileEquate file )
+{
+s32	Ret=MainFAT[file].FileSize;
+	return (Ret);
+}
+
+
+s32	CFileIO::getFileSector( FileEquate file )
+{
+s32	Ret=MainFAT[file].FilePos/2048;
+	return (Ret);
+}
+
+s32	CFileIO::getFileOffset( FileEquate file )
+{
+s32	Ret=MainFAT[file].FilePos;
+	return (Ret);
+}
+
+/*****************************************************************************/
+void 	CFileIO::SkipFile(int Skip)
+{
+	if (Skip) ReadFile(0,Skip);
+}
+
+/*****************************************************************************/
+int		CFileIO::GetFilePos(int File)
+{
+	return(FilePosList[File]);
+}
+
+/*****************************************************************************/
+#if		!defined(__USER_CDBUILD__)
+#include	"fileio/filetab.cpp"
+#endif
+
+void	CFileIO::FindAllFilePos()
+{
+#if		!defined(__USER_CDBUILD__)
+		CalcFilePos(FilePosList);
+#endif
+}
+
+/*****************************************************************************/
+// File positions are passed by Bootstrap VIA Scratch Ram (nice!)
+void	CFileIO::GetAllFilePos()
+{
+int	*Pos=(int*)SCRATCH_RAM;
+
+	for (int Loop=0;Loop<FILEPOS_MAX;Loop++)	
+		{
+		FilePosList[Loop]=*Pos++;
+		}
+
+}
+
+/****************************************************************************/
+int	CFileIO::GetReadLeft()
+{
+	return(BigLump.LengthLeft);
+}
+/*****************************************************************************/
+/*** Data Banks **************************************************************/
+/*****************************************************************************/
+void	CFileIO::loadDataBank(DataBankEquate Bank)
+{
+// Check if already loaded
+		if (DataBank[Bank].Data) return;
+
+// Check to see no more are loaded
+		ASSERT(CurrentDataBank==DATABANK_MAX);
+
+		DataBank[Bank].Data=(sFAT*)loadFile(DataBank[Bank].Filename,"DataBank");
+		CurrentDataBank=Bank;
+}
+
+/*****************************************************************************/
+void	CFileIO::dumpDataBank()
+{
+// Check if loaded
+		ASSERT(CurrentDataBank!=DATABANK_MAX);
+		MemFree(DataBank[CurrentDataBank].Data);
+		DataBank[CurrentDataBank].Data=0;
+		CurrentDataBank=DATABANK_MAX;
+}
+
+/*****************************************************************************/
+u8		*CFileIO::isFileInDataBank(FileEquate File)
+{
+		for (int Bank=0;Bank<DATABANK_MAX; Bank++) 
+			{
+			sDataBank	&ThisBank=DataBank[Bank];
+			if (ThisBank.Data)
+				{
+				int		Pos=ThisBank.Data[File].FilePos;
+				if (Pos!=-1) return(MakePtr(ThisBank.Data,Pos));
+				}
+			}
+	DBG_MSG1("File Not in Cache [%i]",File);
+
+		return(0);
+}
diff --git a/source/fileio/fileio.h b/source/fileio/fileio.h
new file mode 100644
index 000000000..5aa5faaaf
--- /dev/null
+++ b/source/fileio/fileio.h
@@ -0,0 +1,130 @@
+/***************************************/
+/*** PSX PC/CD Big Lump FileIO Stuff ***/
+/***************************************/
+
+#ifndef _FILEIO_HEADER_
+#define _FILEIO_HEADER_
+
+#include 	"BigLump.h"
+#include	"fileio\filetab.h"
+
+/*****************************************************************************/
+#define FILEIO_MINCHUNKS		(1)		// 2k
+#define FILEIO_MAXCHUNKS		(1)		// 2k	64k (only needed for small files, daft streams and end of files now)
+#define FILEIO_CHUNKSIZE		(2048)
+#define FILEIO_MINCHUNKSIZE		(FILEIO_CHUNKSIZE*FILEIO_MINCHUNKS)
+#define FILEIO_MAXCHUNKSIZE		(FILEIO_CHUNKSIZE*FILEIO_MAXCHUNKS)
+
+enum
+{
+FILEIO_MODE_NONE=0,
+FILEIO_MODE_CHUNK,
+FILEIO_MODE_STREAM,
+};
+
+enum	
+{
+BLStatusOffline=-1,
+BLStatusReady,
+BLStatusOpen,
+BLStatusRead,
+BLStatusFail
+};
+
+enum	
+{
+DataLump=0,
+OverlayLump,
+MaxLumps
+};
+
+struct	sFAT
+{
+	s32	FilePos;
+	s32	FileSize;
+};
+
+struct	sBigLump
+	{
+	s16		Status;
+	u32		Sector;
+	u8		*ChunkPtr,*DstPtr;
+	int		ChunkLeft;
+	int		Length,LengthLeft,ReadSoFar;
+	int		LoadLeft;
+	int		LoadMode;
+	u8		ChunkBuffer[FILEIO_MAXCHUNKSIZE];
+	};
+
+
+/*****************************************************************************/
+enum DataBankEquate
+{
+DATABANK_MAX
+};
+
+struct	sDataBank
+{
+	FileEquate	Filename;
+	sFAT		*Data;
+};
+
+/*****************************************************************************/
+class CLOFileIO;
+class CFileIO
+{
+public:
+
+static	void		Init();
+static	void 		OpenFile(FileEquate file);
+static	long 		ReadFile(void *Buffer,s32 Length);
+static	void 		CloseFile();
+static	void 		AlignFile(int Length);
+static	void 		SkipFile(int Skip);
+
+static	int			GetStatus()	{return(BigLump.Status);}
+
+static	void 		LoadFileSizeAtAddr(FileEquate Filename,void *Buffer,u32 Length);
+
+static	u8			*loadFile( FileEquate file, char *allocName="CFileIO::loadFile" );
+static	int			IsFromDataBank(void *Addr);
+static	u8			*loadFileAtAddr(FileEquate file, u8* buffer);
+
+static	void		loadDataBank(DataBankEquate Bank);
+static	void		dumpDataBank();
+static	u8			*isFileInDataBank(FileEquate File);
+
+static s32			getFileSize( FileEquate file );
+static s32			getFileSector( FileEquate file );
+static s32			getFileOffset( FileEquate file );
+
+static	int			GetFilePos(int File);
+static	void		FindAllFilePos();
+static	void		GetAllFilePos();
+static	int			GetReadLeft();
+
+private:
+static	void   		CheckChunk();
+
+static	sBigLump	BigLump;
+static	CLOFileIO	*FileIO;
+static	int			FilePosList[FILEPOS_MAX];
+
+static	sDataBank		DataBank[DATABANK_MAX];
+static	DataBankEquate	CurrentDataBank;
+
+static	sFAT		*MainFAT;
+};
+
+/*****************************************************************************/
+class CLOFileIO
+{
+public:
+	virtual void 	Open()=0;
+	virtual void	Read(u32 Length,void *Buffer)=0;
+	virtual void 	Close()=0;
+};
+
+/*****************************************************************************/
+
+#endif
\ No newline at end of file
diff --git a/source/fileio/filetab.cpp b/source/fileio/filetab.cpp
new file mode 100644
index 000000000..86f0af919
--- /dev/null
+++ b/source/fileio/filetab.cpp
@@ -0,0 +1,44 @@
+/******************/
+/*** File Table ***/
+/******************/
+
+/*******************************************************************************/
+char	*FilenameList[FILEPOS_MAX]=
+{
+"BIGLUMP.BIN",
+"TRACK1.IXA",
+"CLIMAX.STR",
+"INTRO.STR",
+"LEVEL1.STR",
+"LEVEL2.STR",
+"LEVEL3.STR",
+"LEVEL4.STR",
+"LEVEL5.STR",
+"LEVEL6.STR",
+"LEVEL7.STR",
+"ZORD1.STR",
+"ZORD2.STR",
+/*
+"DEMO2.STR",
+"DEMO3.STR",
+"DEMO4.STR",
+"DEMO5.STR",
+"DEMO6.STR"
+*/
+};
+
+/*******************************************************************************/
+void	CalcFilePos(int *Dst)
+{
+		for (int Loop=0;Loop<FILEPOS_MAX;Loop++)	
+			{
+			CdlFILE	RetFile;
+			int		Pos;
+			char	Name[32];
+			sprintf(Name,"\\%s;1",FilenameList[Loop]);
+			while ( !CdSearchFile(&RetFile,Name) );
+			Dst[Loop]=CdPosToInt(&RetFile.pos);
+			}
+}
+
+
diff --git a/source/fileio/filetab.h b/source/fileio/filetab.h
new file mode 100644
index 000000000..dd70f74c7
--- /dev/null
+++ b/source/fileio/filetab.h
@@ -0,0 +1,36 @@
+/******************/
+/*** File Table ***/
+/******************/
+
+#ifndef	__FILE_TABLE___
+#define	__FILE_TABLE___
+
+/*******************************************************************************/
+enum	FILEPOS_ENUM
+{
+	FILEPOS_BIGLUMP,
+	FILEPOS_TRACK1,
+	FILEPOS_CLIMAX_STR,
+	FILEPOS_INTRO_STR,
+	FILEPOS_LEVEL1_STR,
+	FILEPOS_LEVEL2_STR,
+	FILEPOS_LEVEL3_STR,
+	FILEPOS_LEVEL4_STR,
+	FILEPOS_LEVEL5_STR,
+	FILEPOS_LEVEL6_STR,
+	FILEPOS_LEVEL7_STR,
+	FILEPOS_ZORD1_STR,
+	FILEPOS_ZORD2_STR,
+/*
+	FILEPOS_DEMO2_STR,
+	FILEPOS_DEMO3_STR,
+	FILEPOS_DEMO4_STR,
+	FILEPOS_DEMO5_STR,
+	FILEPOS_DEMO6_STR,
+*/
+	FILEPOS_MAX
+};
+
+/*******************************************************************************/
+
+#endif
\ No newline at end of file
diff --git a/source/fileio/pcfile.cpp b/source/fileio/pcfile.cpp
new file mode 100644
index 000000000..81275090c
--- /dev/null
+++ b/source/fileio/pcfile.cpp
@@ -0,0 +1,40 @@
+/***********************************/
+/*** PSX PC BigLump FileIO Stuff ***/
+/***********************************/
+
+#include 	"system\global.h"
+#include	"fileio\fileio.h"
+#include 	"fileio\pcfile.h"
+
+/*****************************************************************************/
+CPCFileIO::CPCFileIO(char *Filename,sBigLump *BigLumpPtr)
+{
+int		NoPath=0;
+		PCinit();
+		sprintf(FullFilename,"out\\%s\\%s\\version\\%s\\%s",INF_Territory,INF_Version,INF_FileSystem,Filename);
+		BigLump=BigLumpPtr;
+		FileHandle=-1;
+}
+
+/*****************************************************************************/
+void 	CPCFileIO::Open()
+{
+		FileHandle=PCopen(FullFilename,F_READ,0);
+		ASSERT(FileHandle!=-1);
+}
+
+/*****************************************************************************/
+void 	CPCFileIO::Read(u32 Count,void *Dst)
+{
+		PClseek(FileHandle,BigLump->Sector*FILEIO_CHUNKSIZE,0);
+		PCread(FileHandle,(char*)Dst,Count*FILEIO_CHUNKSIZE);
+		BigLump->Sector+=Count;
+}
+
+/*****************************************************************************/
+void 	CPCFileIO::Close()
+{
+		if (FileHandle!=-1) PCclose(FileHandle);
+		FileHandle=-1;
+
+}
diff --git a/source/fileio/pcfile.h b/source/fileio/pcfile.h
new file mode 100644
index 000000000..2f73014f7
--- /dev/null
+++ b/source/fileio/pcfile.h
@@ -0,0 +1,36 @@
+/***************************/
+/*** PSX PC FileIO Stuff ***/
+/***************************/
+
+#ifndef __PCFILE_H__
+#define __PCFILE_H__
+
+#include	"fileio\fileio.h"
+/*****************************************************************************/
+enum
+{
+	F_READ,
+	F_WRITE,
+	F_READWRITE,
+};
+
+/*****************************************************************************/
+class CPCFileIO : public CLOFileIO
+{
+public:
+	CPCFileIO(char *Filename,sBigLump *BigLumpPtr);
+	virtual ~CPCFileIO(){};
+
+	void 		Open();
+	void 		Read(u32 Length,void *Buffer);
+	void 		Close();
+
+private:
+	sBigLump	*BigLump;
+	s32			FileHandle;
+	char		FullFilename[256];
+
+};
+
+/*****************************************************************************/
+#endif
\ No newline at end of file