Patch #1341626: "New GP32 port"

svn-id: r19710

27 files changed, 4057 insertions, 977 deletions

diff --git a/backends/gp32/Makefile b/backends/gp32/Makefile
index e16c146cd1..6420c7b714 100644
--- a/backends/gp32/Makefile
+++ b/backends/gp32/Makefile
@@ -1,4 +1,7 @@
-CXX     := c++
+CC		:= arm-elf-gcc
+CXX		:= arm-elf-g++
+LD		:= arm-elf-g++
+AS		:= arm-elf-as
 AR      := arm-elf-ar cru
 RANLIB  := arm-elf-ranlib
 RM      := rm -f
@@ -10,6 +13,9 @@ RM      := rm -f
 RM_REC  := $(RM) -r
 ZIP     := zip -q
 CP      := cp
+OBJCOPY	:= arm-elf-objcopy
+FXETOOL	:= b2fxec
+
 
 #######################################################################
 # Default compilation parameters. Normally don't edit these           #
@@ -28,19 +34,114 @@ CXXFLAGS+= -Wshadow -Wuninitialized -Wimplicit -Wundef
 CXXFLAGS+= -Wno-long-long -Wno-multichar -Wno-unknown-pragmas -Wno-reorder
 CXXFLAGS+= -Wwrite-strings -fcheck-new -Wctor-dtor-privacy -Wnon-virtual-dtor
 
-# Seems GCC 2.95 doesn't support the following, so we do not yet turn them
-# on by default (but I'd strongly recommend to all GCC 2.95 users to update
-# to a better compiler like GCC 3.x).
-#CXXFLAGS+= -ansi -W -Wno-unused-parameter -Woverloaded-virtual -Wdisabled-optimization -Wfloat-equal
-
-# The following causes problems on some systems where the system header
-# contain duplicate declarations already. That's really a bug in the 
-# system headers, but since it causes lots of warnings on those systems,
-# we don't enable it by default
-#CXXFLAGS+= -Wredundant-decls
-
-# Load the build rules & settings for the chosen backend
--include build.rules
+# GPSDK (SDK, Includes and Startup Files) base dir
+GPSDK			=	/usr/compat/gp32/share/sdk
+
+# Outputs
+EXEEXT			=	.elf
+MAPFILE			=	scummvm.map
+BIN			=	scummvm.gxb
+FXE			=	scummvm.fxe
+
+# Stripped Build? (Smaller ELF, Minimal debug symbol information).
+# You MUST comment this out with a # if you wish to debug your code.
+# STRIP_DEBUG		=	-Wl,--strip-debug
+
+# Plugins hack
+srcdir			=	./
+
+# GP32 Direct Execute Tool (i.e. pclink -e on Windows, gplink run on Linux)
+EXECUTE_TOOL	=	pclink -e
+#
+#	       		-ffast-math \
+#	       		-fshort-double \
+#
+#
+#
+
+				#-Wno-multichar \
+				# Remove the below from the above flags for Debug.
+CFLAGS		=	-marm -march=armv4t -mtune=arm920 -mapcs \
+	       		-finline-functions \
+	       		-fshort-enums \
+	       		-mstructure-size-boundary=32 \
+	       		-mno-thumb-interwork \
+				-I$(GPSDK)/include \
+				-g \
+	       		-O3 \
+	       		-fomit-frame-pointer
+
+CPPFLAGS	=	$(CFLAGS)
+
+DEFINES 	= 	-D__GP32__
+DEFINES		+=	-DNONSTANDARD_PORT
+
+# Support Vorbis Tremor Patches.
+#DEFINES	+=	-DVORBIS_TREMOR
+
+# Support LIBMAD Patches.
+#DEFINES	+=	-DGP32_MADMP3
+
+# Support for 8:3 save files names (The GP32 uses FAT12/16 (no vFAT) for the file system).
+DEFINES		+=	-DSHORT_SAVENAMES
+
+# Support for the unsigned sound mixer.
+DEFINES		+=	-DOUTPUT_UNSIGNED_AUDIO
+
+# Support for the GP32 (fmOPL derived) MIDI engine.
+#	-	NOT fully implemented yet.
+DEFINES		+=	-DUSE_GP32_FMOPL
+
+LDSPECS		=	-specs=gp32_gpsdk.specs
+
+LDFLAGS 	= 	$(STRIP_DEBUG) \
+				-Wl,-Map,$(MAPFILE) \
+				$(LDSPECS) -Wl,--no-warn-mismatch
+
+LIBS		+=	-L$(GPSDK)/lib \
+				-lgpmem -lgpos -lgpstdio -lgpstdlib -lgpsound -lgpgraphic -lgpfont \
+				-lm -lc -lgcc
+
+INCLUDES	+=	-Ibackends/gp32 -I$(GPSDK)/include
+
+MODULES		+=	backends/gp32
+
+#GP32 Debug - Remove from Release builds
+#	This builds in the GP32 GDB USB Stub. Don't use it unless you know what your doing.
+#	You also need to remove ANY optemisation from the compiler flags.
+#DEFINES	+=	-DGP32_GDB
+#OBJS	+=	backends/gp32/debug-gdbstub-usb.o
+
+# Standard librarys and optimization modules
+OBJS	+=	backends/gp32/startup.o \
+			backends/gp32/memcpy.o \
+			backends/gp32/gp_asmlib.o \
+			backends/gp32/gp_clipped.o \
+			backends/gp32/fontdata.o
+
+# Custom GP32 std library
+OBJS	+=	backends/gp32/gp32std.o \
+			backends/gp32/gp32std_grap.o \
+			backends/gp32/gp32std_input.o \
+			backends/gp32/gp32std_sound.o \
+			#backends/gp32/dmaaudio_asm.o \
+			#backends/gp32/dmaaudio.o \
+
+#Main ScummVM for the GP32 Backend
+OBJS	+= 	backends/gp32/gp32_main.o \
+			backends/gp32/gp32_launcher.o \
+			backends/gp32/gp32_osys.o \
+			backends/gp32/gp-fs.o
+
+#install: all
+					#$(EXECUTE_TOOL) $(BIN)
+
+$(FXE): $(BIN)
+					$(FXETOOL) -f -a "The ScummVM Team" -t "ScummVM for the GP32" $< $@
+#					$(FXETOOL) -f -a "The ScummVM Team" -t "ScummVM for the GP32" -b scummvm.bmp $< $@
+
+$(BIN): scummvm$(EXEEXT)
+					$(OBJCOPY) -O binary $< $@
 
 #######################################################################
 # Compile options - you can modify these to tweak ScummVM compilation #
@@ -69,11 +170,17 @@ HAVE_GCC3 = 1
 # Control which modules are built - uncomment any to disable module   #
 #######################################################################
 
+DISABLE_SCALERS = 1
+DISABLE_HQ_SCALERS = 1
+
 #DISABLE_SCUMM = 1
+#DISABLE_SCUMM_7_8 = 1
+DISABLE_HE = 1
 DISABLE_SIMON = 1
 DISABLE_SKY = 1
 DISABLE_QUEEN = 1
 
+
 # The engines below are not supported on the GP32 port so there is
 # no point compiling support into the binary.
 DISABLE_SWORD1 = 1
@@ -83,6 +190,7 @@ DISABLE_SWORD2 = 1
 # Disable for ALL release builds.
 DISABLE_SAGA = 1
 DISABLE_KYRA = 1
+DISABLE_GOB = 1
 
 #######################################################################
 # Misc stuff - you should normally never have to edit this            #
@@ -96,32 +204,5 @@ dist:
 	$(RM) $(ZIPFILE)
 	$(ZIP) $(ZIPFILE) $(DISTFILES)
 
-# Pull in the GP32 backend build.rules here.
-build.rules: backends/gp32/build.rules
-	$(CP) backends/gp32/build.rules build.rules
-
-# Special target to create a application wrapper for Mac OS X
-bundle_name = ScummVM.app
-bundle: scummvm-static
-	mkdir -p $(bundle_name)/Contents/MacOS
-	mkdir -p $(bundle_name)/Contents/Resources
-	echo "APPL????" > $(bundle_name)/Contents/PkgInfo
-	cp Info.plist $(bundle_name)/Contents/
-	cp scummvm.icns $(bundle_name)/Contents/Resources/
-	cp scummvm-static $(bundle_name)/Contents/MacOS/scummvm
-	strip $(bundle_name)/Contents/MacOS/scummvm
-
 install: $(FXE)
 		$(EXECUTE_TOOL) $(BIN)	
-
-# Special target to create a static linked binary for Mac OS X
-scummvm-static: $(OBJS)
-	$(CXX) $(LDFLAGS) -o scummvm-static $(OBJS) \
-		/sw/lib/libSDLmain.a /sw/lib/libSDL.a \
-		/sw/lib/libmad.a \
-		/sw/lib/libvorbisfile.a /sw/lib/libvorbis.a /sw/lib/libogg.a \
-		-framework Cocoa -framework Carbon -framework IOKit \
-		-framework OpenGL -framework AGL -framework QuickTime \
-		-framework AudioUnit -framework AudioToolbox
-
-.PHONY: deb bundle
diff --git a/backends/gp32/README.GP32 b/backends/gp32/README.GP32
index dc5f7eb649..15120c7303 100644
--- a/backends/gp32/README.GP32
+++ b/backends/gp32/README.GP32
@@ -1,38 +1 @@
-ScummVM port for GamePark 32
-============================
-
-Compiling instructions:
- 1. download and install Fenix's devkit advance (see Windows.txt)
- 2. get chn's gp32 devkit and install it (see readme-gp32.txt)
- 3. In Makefile change the line: build.rules: to
-      $(CP) backends/gp32/build.rules build.rules 
- 4. run make
-
- * In case you have installed devkitadv to a different directory
- than it's default, you'll have to modify build.rules in backend/gp32/
-
-How to run:
- - upload scummvm.fxe in gp:\gpmm
- - upload all game data files in gp:\
-
-Controls:
- A:	left click
- B:	right click
- L:	debug console
- R:	game screen
- Start: menu
- Select:skip
- L+R:	save 
-
-For the latest source release visit the official ScummVM page:
-  http://www.scummvm.org/
-
-You can get the precompiled gp32 executable (fxe) from my site:
-  http://people.inf.elte.hu/ph0x
-
-
-Thanks to the following people for their help:
- Endy, khalek and the rest ScummVM team members,
- Jeff, DarkFader, Inopia, groepaz, chn, FireFly, #gp32dev
-
-	ph0x (ph0x@freemail.hu)  
+TODO. :)
diff --git a/backends/gp32/build.rules b/backends/gp32/build.rules
deleted file mode 100644
index 59ae58b3e7..0000000000
--- a/backends/gp32/build.rules
+++ /dev/null
@@ -1,131 +0,0 @@
-# ScummVM - Scumm Interpreter
-# Copyright (C) 2001  Ludvig Strigeus
-# Copyright (C) 2001/2004 The ScummVM project
-# Copyright (C) 2002 ph0x - GP32 port
-# Copyright (C) 2003-4 DJWillis - GP32 port
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# Module Details	-	ScummVM for the GP32
-#						Build.Rules for GP32 Backend.
-#
-# Port Maintainer	-	DJWillis <gp32@distant-earth.co.uk>
-
-# GPSDK (SDK, Includes and Startup Files) base dir
-GPSDK			=	/usr/compat/gp32/share/sdk
-
-# Outputs
-EXEEXT			=	.elf
-MAPFILE			=	scummvm.map
-BIN			=	scummvm.gxb
-FXE			=	scummvm.fxe
-
-# Stripped Build? (Smaller ELF, Minimal debug symbol information).
-# You MUST comment this out with a # if you wish to debug your code.
-# STRIP_DEBUG		=	-Wl,--strip-debug
-
-# Plugins hack
-srcdir			=	./
-
-# GP32 Direct Execute Tool (i.e. pclink -e on Windows, gplink run on Linux)
-EXECUTE_TOOL	=	pclink -e
-
-# GCC Tool-chain
-CC			=	arm-elf-gcc
-CXX			=	arm-elf-g++
-LD			=	arm-elf-g++
-AS			=	arm-elf-as
-OBJCOPY			=	arm-elf-objcopy
-FXETOOL			=	b2fxec
-
-CFLAGS  		=	-marm \
-				-march=armv4t \
-	       			-mapcs \
-	       			-finline-functions \
-	       			-fshort-enums \
-	       			-ffast-math \
-	       			-fshort-double \
-	       			-mstructure-size-boundary=32 \
-	       			-mno-thumb-interwork \
-				-I$(GPSDK)/include \
-				-g \
-				#-Wno-multichar \
-	       			#-O3 \
-	       			#-fomit-frame-pointer			
-					
-				# Remove the below from the above flags for Debug.
-	       			#-O3 \
-	       			#-fomit-frame-pointer
-
-CPPFLAGS		=	$(CFLAGS)
-
-DEFINES 		= 	-D__GP32__
-DEFINES			+=	-DNONSTANDARD_PORT
-
-# Support Vorbis Tremor Patches.
-#DEFINES		+=	-DUSE_TREMOR
-
-# Support LIBMAD Patches.
-#DEFINES		+=	-DGP32_MADMP3
-
-# Support for 8:3 save files names (The GP32 uses FAT12/16 (no vFAT) for the file system).
-DEFINES			+=	-DSHORT_SAVENAMES
-
-# Support for the unsigned sound mixer.
-DEFINES			+=	-DOUTPUT_UNSIGNED_AUDIO
-
-# Support for the GP32 (fmOPL derived) MIDI engine.
-#	-	NOT fully implemented yet.
-DEFINES			+=	-DUSE_GP32_FMOPL
-
-LDSPECS			=	-specs=gp32_gpsdk.specs
-
-LDFLAGS 		= 	$(STRIP_DEBUG) \
-					-Wl,-Map,$(MAPFILE) \
-					$(LDSPECS) -Wl,--no-warn-mismatch
-				
-LIBS			+=	-L$(GPSDK)/lib \
-					-lgpmem -lgpos -lgpstdio -lgpstdlib -lgpsound -lgpgraphic  -lgpgraphic16 -lgpfont -lgpfont16 \
-					-lm -lc -lgcc
-
-INCLUDES 		+=	-Ibackends/gp32 -I$(GPSDK)/include
-
-MODULES			+=	backends/gp32
-
-#GP32 Debug - Remove from Release builds
-#	This builds in the GP32 GDB USB Stub. Don't use it unless you know what your doing.
-#	You also need to remove ANY optemisation from the compiler flags.
-DEFINES			+=	-DGP32_GDB
-OBJS			+=	backends/gp32/debug-gdbstub-usb.o
-
-#GamePark SDK startup.
-OBJS			+=	backends/gp32/startup.o
-
-#Main ScummVM for the GP32 Backend
-OBJS			+=	backends/gp32/gp32.o \
-				backends/gp32/gp-fs.o \
-				backends/gp32/cpuspeed.o \
-					
-				#backends/gp32/dmaaudio_asm.o \
-				#backends/gp32/dmaaudio.o \
-
-#install: all
-					#$(EXECUTE_TOOL) $(BIN)
-
-$(FXE): $(BIN)
-					$(FXETOOL) -f -a "DJWillis/ScummVM Team" -t "ScummVM for the GP32" -b scummvm.bmp $< $@
-	
-$(BIN): scummvm$(EXEEXT)
-					$(OBJCOPY) -O binary $< $@
diff --git a/backends/gp32/fontdata.c b/backends/gp32/fontdata.c
new file mode 100644
index 0000000000..3b605958e0
--- /dev/null
+++ b/backends/gp32/fontdata.c
@@ -0,0 +1,283 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+const unsigned char fontresEng1[] =
+{
+	0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x81,0xA5,0x81,0x81,0xBD,0x81,0x7E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0xFF,0xDB,0xFF,0xFF,0xC3,0xFF,0x7E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x36,0x7F,0x7F,0x7F,0x7F,0x3E,0x1C,0x08,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x08,0x1C,0x3E,0x7F,0x3E,0x1C,0x08,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x3C,0x3C,0x7E,0x66,0x7E,0x18,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x3C,0x3C,0x7E,0x7E,0x3C,0x18,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x18,0x3C,0x3C,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0xFF,0xFF,0xFF,0xFF,0xE7,0xC3,0xC3,0xE7,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x3C,0x66,0x42,0x42,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0xFF,0xFF,0xFF,0xC3,0x99,0xBD,0xBD,0x99,0xC3,0xFF,0xFF,0xFF,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x0F,0x07,0x0D,0x19,0x3C,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x3C,0x18,0x7E,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x33,0x3C,0x33,0x30,0x70,0xF0,0x70,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7F,0x63,0x7F,0x63,0x63,0x67,0xE7,0xE6,0xC0,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0xDB,0x3C,0xE7,0x3C,0xDB,0x18,0x18,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x40,0x60,0x70,0x7C,0x7F,0x7C,0x70,0x60,0x40,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x01,0x03,0x07,0x1F,0x7F,0x1F,0x07,0x03,0x01,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x3C,0x7E,0x18,0x18,0x7E,0x3C,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x33,0x33,0x33,0x33,0x33,0x00,0x33,0x33,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7F,0xDB,0xDB,0xDB,0x7B,0x1B,0x1B,0x1B,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x3E,0x63,0x30,0x1C,0x36,0x63,0x63,0x36,0x1C,0x06,0x63,0x3E,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x7F,0x7F,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x3C,0x7E,0x18,0x18,0x7E,0x3C,0x18,0x7E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x3C,0x7E,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x18,0x18,0x18,0x7E,0x3C,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x0C,0x06,0x7F,0x06,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x18,0x30,0x7F,0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x60,0x7F,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x24,0x66,0xFF,0x66,0x24,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x08,0x1C,0x1C,0x3E,0x3E,0x7F,0x7F,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x7F,0x7F,0x3E,0x3E,0x1C,0x1C,0x08,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x18,0x3C,0x3C,0x3C,0x18,0x18,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x66,0x66,0x66,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x36,0x36,0x7F,0x36,0x36,0x7F,0x36,0x36,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x18,0x18,0x3C,0x66,0x60,0x3C,0x06,0x06,0x66,0x3C,0x18,0x18,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x61,0x63,0x06,0x0C,0x18,0x30,0x63,0x43,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x1C,0x36,0x36,0x1C,0x3B,0x6E,0x66,0x3B,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x30,0x30,0x30,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x0C,0x18,0x30,0x30,0x30,0x30,0x18,0x0C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x0C,0x06,0x06,0x06,0x06,0x0C,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x66,0x3C,0xFF,0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x18,0x18,0x18,0xFF,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x18,0x30,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x01,0x03,0x06,0x0C,0x18,0x30,0x60,0x40,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x6E,0x76,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x38,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x06,0x1C,0x06,0x06,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x0C,0x1C,0x3C,0x6C,0x6C,0x7E,0x0C,0x0C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x60,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x60,0x60,0x7C,0x66,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x06,0x06,0x0C,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x3C,0x66,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x66,0x3E,0x06,0x06,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x18,0x18,0x30,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x06,0x0C,0x18,0x30,0x30,0x18,0x0C,0x06,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x7E,0x00,0x00,0x7E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x60,0x30,0x18,0x0C,0x0C,0x18,0x30,0x60,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x06,0x0C,0x18,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x6E,0x6E,0x6E,0x60,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7C,0x66,0x66,0x7C,0x66,0x66,0x66,0x7C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x60,0x60,0x60,0x60,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7C,0x66,0x66,0x66,0x66,0x66,0x66,0x7C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x7E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x60,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x60,0x60,0x6E,0x66,0x66,0x3E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x06,0x06,0x06,0x06,0x06,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x6C,0x78,0x70,0x78,0x6C,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x63,0x77,0x7F,0x6B,0x6B,0x63,0x63,0x63,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x76,0x7E,0x6E,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7C,0x66,0x66,0x66,0x7C,0x60,0x60,0x60,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x04,0x06,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7C,0x66,0x66,0x7C,0x66,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x60,0x3C,0x06,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x63,0x63,0x63,0x63,0x6B,0x7F,0x77,0x63,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x06,0x0C,0x18,0x30,0x60,0x60,0x7E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x30,0x30,0x30,0x30,0x30,0x30,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x40,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x18,0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0x00,
+	0x00,0x00,0x18,0x18,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x60,0x60,0x7C,0x66,0x66,0x66,0x66,0x7C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3C,0x66,0x60,0x60,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x06,0x06,0x3E,0x66,0x66,0x66,0x66,0x3E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3C,0x66,0x7E,0x60,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3C,0x66,0x60,0x78,0x60,0x60,0x60,0x60,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3C,0x66,0x66,0x66,0x3E,0x06,0x66,0x3C,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x60,0x60,0x7C,0x66,0x66,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x06,0x00,0x06,0x06,0x06,0x06,0x06,0x66,0x66,0x3C,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x77,0x7F,0x6B,0x6B,0x6B,0x6B,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x6C,0x7E,0x66,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3C,0x66,0x66,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x7C,0x66,0x66,0x66,0x7C,0x60,0x60,0x60,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3E,0x66,0x66,0x66,0x3E,0x06,0x06,0x06,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x6E,0x78,0x60,0x60,0x60,0x60,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3C,0x66,0x38,0x0C,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x30,0x30,0x7C,0x30,0x30,0x30,0x36,0x1C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x63,0x63,0x63,0x6B,0x7F,0x36,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x66,0x3C,0x18,0x18,0x3C,0x66,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x06,0x66,0x3C,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x7E,0x0C,0x18,0x30,0x60,0x7E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x0E,0x18,0x18,0x18,0x70,0x18,0x18,0x18,0x0E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x70,0x18,0x18,0x18,0x0E,0x18,0x18,0x18,0x70,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3B,0x6E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x08,0x1C,0x36,0x63,0x63,0x7F,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x3C,0x66,0xC2,0xC0,0xC2,0x66,0x3C,0x18,0x0E,0x0C,0x78,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x66,0x00,0x00,0x66,0x66,0x66,0x66,0x66,0x66,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x06,0x0C,0x18,0x00,0x3E,0x63,0x7F,0x60,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x08,0x1C,0x36,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x30,0x18,0x0C,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x1C,0x36,0x1C,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x0C,0x06,0x3C,0x00,0x00,0x00,
+	0x00,0x00,0x08,0x1C,0x36,0x00,0x3E,0x63,0x7F,0x60,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x00,0x3E,0x63,0x7F,0x60,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x30,0x18,0x0C,0x00,0x3E,0x63,0x7F,0x60,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x66,0x66,0x00,0x38,0x18,0x18,0x18,0x18,0x3C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x18,0x3C,0x66,0x00,0x38,0x18,0x18,0x18,0x18,0x3C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x60,0x30,0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x3C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x63,0x63,0x08,0x1C,0x36,0x63,0x63,0x7F,0x63,0x63,0x00,0x00,0x00,0x00,
+	0x00,0x1C,0x36,0x1C,0x00,0x1C,0x36,0x63,0x63,0x7F,0x63,0x63,0x00,0x00,0x00,0x00,
+	0x00,0x0C,0x18,0x30,0x00,0x7F,0x33,0x30,0x3E,0x30,0x33,0x7F,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x6E,0x3B,0x1B,0x7E,0xD8,0xDC,0x77,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x1F,0x36,0x66,0x66,0x7F,0x66,0x66,0x66,0x67,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x08,0x1C,0x36,0x00,0x3E,0x63,0x63,0x63,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x63,0x63,0x00,0x3E,0x63,0x63,0x63,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x30,0x18,0x0C,0x00,0x3E,0x63,0x63,0x63,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x18,0x3C,0x66,0x00,0x66,0x66,0x66,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x30,0x18,0x0C,0x00,0x66,0x66,0x66,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x63,0x63,0x00,0x63,0x63,0x63,0x63,0x3F,0x03,0x06,0x3C,0x00,0x00,
+	0x00,0x00,0x63,0x63,0x1C,0x36,0x63,0x63,0x63,0x63,0x36,0x1C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x63,0x63,0x00,0x63,0x63,0x63,0x63,0x63,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x18,0x18,0x7E,0xC3,0xC0,0xC0,0xC3,0x7E,0x18,0x18,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x1C,0x36,0x32,0x30,0x78,0x30,0x30,0x30,0x73,0x7E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0xC3,0x66,0x3C,0x18,0xFF,0x18,0xFF,0x18,0x18,0x00,0x00,0x00,0x00,
+	0x00,0x00,0xFC,0x66,0x66,0x7C,0x62,0x66,0x6F,0x66,0x66,0xF3,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x0E,0x1B,0x18,0x18,0x18,0x7E,0x18,0x18,0x18,0x18,0xD8,0x70,0x00,0x00,
+	0x00,0x00,0x0C,0x18,0x30,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x0C,0x18,0x30,0x00,0x38,0x18,0x18,0x18,0x18,0x3C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x0C,0x18,0x30,0x00,0x3E,0x63,0x63,0x63,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x0C,0x18,0x30,0x00,0x66,0x66,0x66,0x66,0x66,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x3B,0x6E,0x00,0x6E,0x33,0x33,0x33,0x33,0x33,0x00,0x00,0x00,0x00,
+	0x00,0x3B,0x6E,0x00,0x63,0x73,0x7B,0x7F,0x6F,0x67,0x63,0x63,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x3C,0x6C,0x6C,0x3E,0x00,0x7E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x38,0x6C,0x6C,0x38,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30,0x63,0x63,0x3E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x60,0x60,0x60,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x60,0xE0,0x63,0x66,0x6C,0x18,0x30,0x6E,0xC3,0x06,0x0C,0x1F,0x00,0x00,
+	0x00,0x00,0x60,0xE0,0x63,0x66,0x6C,0x18,0x33,0x67,0xCF,0x1F,0x03,0x03,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x3C,0x3C,0x3C,0x18,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x1B,0x36,0x6C,0x36,0x1B,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x6C,0x36,0x1B,0x36,0x6C,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,
+	0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55,
+	0x77,0xDD,0x77,0xDD,0x77,0xDD,0x77,0xDD,0x77,0xDD,0x77,0xDD,0x77,0xDD,0x77,0xDD,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xF8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x18,0x18,0xF8,0x18,0xF8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xF6,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x18,0xF8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x36,0x36,0x36,0x36,0x36,0x36,0xF6,0x06,0xF6,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x06,0xF6,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x36,0x36,0x36,0x36,0x36,0x36,0xF6,0x06,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x18,0x18,0x18,0x18,0x18,0x18,0xF8,0x18,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1F,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x1F,0x18,0x1F,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x37,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x37,0x30,0x3F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0x30,0x37,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x36,0x36,0x36,0x36,0x36,0x36,0xF7,0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0xF7,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x37,0x30,0x37,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x36,0x36,0x36,0x36,0x36,0x36,0xF7,0x00,0xF7,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0xFF,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x3F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x1F,0x18,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x18,0x1F,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xFF,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+	0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0x18,0xFF,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,
+	0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x3B,0x6E,0x6C,0x6C,0x6E,0x3B,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3E,0x63,0x7E,0x63,0x63,0x7E,0x60,0x60,0x20,0x00,0x00,
+	0x00,0x00,0x00,0x7F,0x63,0x63,0x60,0x60,0x60,0x60,0x60,0x60,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x7F,0x36,0x36,0x36,0x36,0x36,0x36,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7F,0x63,0x30,0x18,0x0C,0x18,0x30,0x63,0x7F,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0x6C,0x6C,0x6C,0x6C,0x38,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x33,0x33,0x33,0x33,0x3E,0x30,0x30,0x60,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3F,0x6C,0x0C,0x0C,0x0C,0x0C,0x0C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x7E,0x18,0x3C,0x66,0x66,0x66,0x3C,0x18,0x7E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x1C,0x36,0x63,0x63,0x7F,0x63,0x63,0x36,0x1C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x1C,0x36,0x63,0x63,0x63,0x36,0x36,0x36,0x77,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x1E,0x30,0x18,0x0C,0x3E,0x66,0x66,0x66,0x3C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x7E,0xDB,0xDB,0x7E,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x03,0x06,0x7E,0xDB,0xDB,0xF3,0x7E,0x60,0xC0,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x1C,0x30,0x60,0x60,0x7C,0x60,0x60,0x30,0x1C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x3E,0x63,0x63,0x63,0x63,0x63,0x63,0x63,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x7F,0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x18,0xFF,0x18,0x18,0x18,0x00,0xFF,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00,0x7E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00,0x7E,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x0E,0x1B,0x1B,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,
+	0x00,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xD8,0xD8,0x70,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x00,0x00,0xFF,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3B,0x6E,0x00,0x3B,0x6E,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x38,0x6C,0x6C,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x0F,0x0C,0x0C,0x0C,0x0C,0x0C,0xEC,0x6C,0x3C,0x1C,0x00,0x00,0x00,0x00,
+	0x00,0x00,0xD8,0x6C,0x6C,0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x70,0xD8,0x30,0x60,0xC8,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x3E,0x3E,0x3E,0x3E,0x3E,0x3E,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+};
diff --git a/backends/gp32/gfx_splash.h b/backends/gp32/gfx_splash.h
index 5d0ca42050..ec7b5ac6ca 100644
--- a/backends/gp32/gfx_splash.h
+++ b/backends/gp32/gfx_splash.h
@@ -1,3 +1,26 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
 /////////////////////////////////////////
 //
 // Header file for GP32
@@ -18,7 +41,7 @@
 
 #define gfx_splash_palnb      256
 
-#include "gpgraphic.h"
+#include <gpgraphic.h>
 
 GP_PALETTEENTRY gfx_splash_Pal[256] = {
       0x843, 0x88B, 0x1941, 0x110D, 0x2883, 0x30C9, 0x2945, 0x2109, 0x214D, 0x2989, 0x218F, 0x3149, 0x394D, 0x3989, 0x318D, 0x8D1,
diff --git a/backends/gp32/gp-fs.cpp b/backends/gp32/gp-fs.cpp
index 0c70d568f8..663bb5afba 100644
--- a/backends/gp32/gp-fs.cpp
+++ b/backends/gp32/gp-fs.cpp
@@ -1,8 +1,8 @@
 /* ScummVM - Scumm Interpreter
- * Copyright (C) 2001  Ludvig Strigeus
- * Copyright (C) 2001/2004 The ScummVM project
+ * Copyright (C) 2001-2005 The ScummVM project
  * Copyright (C) 2002 Ph0x - GP32 Backend
  * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -22,104 +22,98 @@
  *
  */
 
-#if defined (__GP32__)
+#include "stdafx.h"
 
-#include "common/stdafx.h"
-
-#include "backends/gp32/gp32.h"
 #include "backends/fs/fs.h"
-#include <stdio.h>
-#include <gpstdio.h>
 
-/*
- * Implementation of the ScummVM file system API based on GP32 SMC File Access.
- */
-
-class GP32FilesystemNode : public FilesystemNode {
+class GP32FilesystemNode : public AbstractFilesystemNode {
 protected:
-	Common::String _displayName;
+	String _displayName;
 	bool _isDirectory;
-	bool _isValid;
-	Common::String _path;
+	bool _isRoot;
+	String _path;
 
 public:
-	GP32FilesystemNode();
-	GP32FilesystemNode(const Common::String &path);
+	GP32FilesystemNode(void);
 	GP32FilesystemNode(const GP32FilesystemNode *node);
+	GP32FilesystemNode(const String &path);
 
-	virtual Common::String displayName() const { return _displayName; }
-	virtual bool isValid() const { return _isValid; }
+	virtual String displayName() const { return _displayName; }
+	virtual bool isValid() const { return true; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual Common::String path() const { return _path; }
+	virtual String path() const { return _path; }
 
-	virtual FSList listDir(ListMode mode = kListDirectoriesOnly) const;
-	virtual FilesystemNode *parent() const;
-	virtual FilesystemNode *clone() const { return new GP32FilesystemNode(this); }
+	virtual FSList listDir(ListMode) const;
+	virtual AbstractFilesystemNode *parent() const;
+	virtual AbstractFilesystemNode *clone() const { return new GP32FilesystemNode(this); }
 };
 
-
-AbstractFilesystemNode *FilesystemNode::getRoot() {
+AbstractFilesystemNode *FilesystemNode::getRoot(void) {
 	return new GP32FilesystemNode();
 }
 
-GP32FilesystemNode::GP32FilesystemNode() {
-	_displayName = "gp:\\SCUMMVM\\GAMES\\";
-	_isValid = true;
-	_isDirectory = true;
-	_path = "gp:\\scummvm\\games\\";
+AbstractFilesystemNode *FilesystemNode::getNodeForPath(const String &path) {
+	return new GP32FilesystemNode(path);
 }
 
-/*
-GP32FilesystemNode::GP32FilesystemNode() {
-	_displayName = "gp:\\";
-	_isValid = true;
+GP32FilesystemNode::GP32FilesystemNode(void) {
 	_isDirectory = true;
+	_isRoot = true;
+	_displayName = "GP32 Root";
 	_path = "gp:\\";
 }
-*/
 
-GP32FilesystemNode::GP32FilesystemNode(const Common::String &p) {
-	// TODO - extract last component from path
-	_displayName = p;
-	// TODO - check whether it is a directory, and whether the file actually exists
-	_isValid = true;
+GP32FilesystemNode::GP32FilesystemNode(const String &path) {
+	_path = path;
+	const char *dsplName = NULL, *pos = path.c_str();
+	while (*pos)
+		if (*pos++ == '\\')
+			dsplName = pos;
+			
+	BP("path name: %s", path.c_str());
+
+	if (strcmp(path.c_str(), "gp:\\") == 0) {
+		_isRoot = true;
+		_displayName = "GP32 Root";
+	} else {
+		_displayName = String(dsplName);
+	}
 	_isDirectory = true;
-	_path = p;
 }
 
 GP32FilesystemNode::GP32FilesystemNode(const GP32FilesystemNode *node) {
 	_displayName = node->_displayName;
-	_isValid = node->_isValid;
 	_isDirectory = node->_isDirectory;
 	_path = node->_path;
-}
-
-AbstractFilesystemNode *FilesystemNode::getNodeForPath(const String &path) {
-	return new GP32FilesystemNode(path);
+	_isRoot = node->_isRoot;
 }
 
 FSList GP32FilesystemNode::listDir(ListMode mode) const {
 	assert(_isDirectory);
 
-	GPDIRENTRY dp;
-	ulong read;
-
+	GPDIRENTRY dirEntry;
+	uint32 read;
 	FSList myList;
 
-	int start=0; // current file
+	if (mode == AbstractFilesystemNode::kListAll)
+		LP("listDir(kListAll)");
+	else
+		LP("listDir(kListDirectoriesOnly)");
 
-	// ... loop over dir entries using readdir
-	while (GpDirEnumList(_path.c_str(), start++, 1, &dp, &read)  == SM_OK) {
-		if (strcmp(dp.name,".")==0|| strcmp(dp.name,"..")==0) continue;
+	int startIdx = 0; // current file
+	String listDir(_path);
+	//listDir += "/";
+	while (GpDirEnumList(listDir.c_str(), startIdx++, 1, &dirEntry, &read)  == SM_OK) {
+		if (dirEntry.name[0] == '.')
+			continue;
 		GP32FilesystemNode entry;
-		entry._displayName = dp.name;
+		entry._displayName = dirEntry.name;
 		entry._path = _path;
-		entry._path += dp.name;
+		entry._path += dirEntry.name;
 
 		GPFILEATTR attr;
-		char s[256];
-		sprintf(s, "%s%s", _path.c_str(), dp.name);
-		GpFileAttr(s, &attr);
+		String fileName(entry._path);
+		GpFileAttr(fileName.c_str(), &attr);
 		entry._isDirectory = attr.attr & (1<<4);
 
 		// Honor the chosen mode
@@ -128,11 +122,36 @@ FSList GP32FilesystemNode::listDir(ListMode mode) const {
 			continue;
 
 		if (entry._isDirectory)
-			entry._path += "\\"; //ph0x
-		myList.push_back(entry);
+			entry._path += "\\";
+		myList.push_back(wrap(new GP32FilesystemNode(&entry)));
 	}
+
+	BP("Dir... %s", listDir.c_str());
+
 	return myList;
 }
+/*
+AbstractFilesystemNode *GP32FilesystemNode::parent() const {
+	if (_isRoot)
+		return new GP32FilesystemNode(this);
+
+	GP32FilesystemNode *p = new GP32FilesystemNode();
+
+	const char *slash = NULL;
+	const char *cnt = _path.c_str();
+
+	while (*cnt) {
+		if (*cnt == '\\')
+			slash = cnt;
+		cnt++;
+	}
+
+	p->_path = String(_path.c_str(), slash - _path.c_str());
+	p->_isDirectory = true;
+	p->_displayName = slash + 1;
+	return p;
+}
+*/
 
 const char *lastPathComponent(const Common::String &str) {
 	const char *start = str.c_str();
@@ -145,25 +164,10 @@ const char *lastPathComponent(const Common::String &str) {
 	return cur+1;
 }
 
-FilesystemNode *GP32FilesystemNode::parent() const {
+AbstractFilesystemNode *GP32FilesystemNode::parent() const {
 
 	GP32FilesystemNode *p = new GP32FilesystemNode();
 
-// OLD - REMOVE ON CLEAN COMPILE
-//	// Root node is its own parent. Still we can't just return this
-//	// as the GUI code will call delete on the old node.
-//	if (_path != "gp:\\") {  //ph0x
-//		const char *start = _path.c_str();
-//		const char *end = lastPathComponent(_path);
-//
-//		p->_path = String(start, end - start);
-//		p->_isValid = true;
-//		p->_isDirectory = true;
-//		p->_displayName = lastPathComponent(p->_path);
-//	}
-//	return p;
-//}
-
 	// Root node is its own parent. Still we can't just return this
 	// as the GUI code will call delete on the old node.
 	if (_path != "gp:\\") {
@@ -172,13 +176,12 @@ FilesystemNode *GP32FilesystemNode::parent() const {
 
 		p->_path = Common::String(start, end - start);
 		p->_displayName = lastPathComponent(p->_path);
+		p->_isRoot = true;
 	} else {
+		p->_isRoot = false;
 		p->_path = _path;
 		p->_displayName = _displayName;
 	}
-	p->_isValid = true;
 	p->_isDirectory = true;
 	return p;
 }
-
-#endif /* defined(__GP32__) */
diff --git a/backends/gp32/gp32.h b/backends/gp32/gp32.h
deleted file mode 100644
index 5e2e542449..0000000000
--- a/backends/gp32/gp32.h
+++ /dev/null
@@ -1,316 +0,0 @@
-/* ScummVM - Scumm Interpreter
- * Copyright (C) 2001  Ludvig Strigeus
- * Copyright (C) 2001/2004 The ScummVM project
- * Copyright (C) 2002 Ph0x - GP32 Backend
- * Copyright (C) 2003/2004 DJWillis - GP32 Backend
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $Header$
- *
- */
-
-#ifndef GP32_H
-#define GP32_H
-
-/////////////////////////////////////////////////////////////////////////////
-// Header for GP32 ScummVM Backend
-/////////////////////////////////////////////////////////////////////////////
-
-//Standard ScummVM includes.
-#include "common/stdafx.h"
-#include "common/scummsys.h"
-#include "common/scaler.h"
-#include "common/system.h"
-#include "backends/intern.h"
-
-#include "base/engine.h"
-//#include "scumm/saveload.h"
-
-//Graphics wrapper - SDL Derived.
-#include "backends/gp32/graphics.h"
-
-//Pre-ScummVM Config stuff
-//#include "backends/gp32/config.h"
-
-#define LCD_WIDTH 				320
-#define LCD_HEIGHT 				240
-#define LCD_WIDTH_CENTER 		LCD_WIDTH / 2
-#define LCD_HEIGHT_CENTER 		LCD_HEIGHT / 2
-#define LCD_SIZE				(LCD_WIDTH * LCD_HEIGHT)
-
-// Graphics Bits
-#define GAME_SURFACE		0
-#define GAME_SURFACE2		1
-#define DEBUG_SURFACE		2
-
-extern int nflip, keydata;	// Flip Index
-extern GP_HPALETTE PAL; //palette
-
-//void Delay(int ms);
-//void FadeToBlack(int delay_time);
-
-
-#define BUFFERCOUNT 2
-extern GPDRAWSURFACE LCDbuffer[BUFFERCOUNT + 1];  //buffers
-
-#define BACKGROUND_COLOR		0	//Black color
-#define COLOUR_8BIT_MODE		8
-#define COLOUR_16BIT_MODE		16
-
-/* Assembly routines from cpuspeed.s */
-extern "C" {void cpu_speed(int,int,int);}	// CPU Speed control (3 int's, clock, bus, dividor)
-
-/* Fake main() entry point */
-//int main_scummvm(int argc, char *argv[]);
-
-//Prototypes
-class OSystem_GP32 : public OSystem
-{
-public:
-	OSystem_GP32();
-	virtual ~OSystem_GP32();
-
-	// Set colors of the palette
-	void setPalette(const byte *colors, uint start, uint num);
-
-	// Set the size of the video bitmap.
-	// Typically, 320x200
-	void initSize(uint w, uint h, int overlayScale);
-	int16 getHeight() { return _screenHeight; }
-	int16 getWidth() { return _screenWidth; }
-
-	// Draw a bitmap to screen.
-	// The screen will not be updated to reflect the new bitmap
-	void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h);
-
-	// Update the dirty areas of the screen
-	void updateScreen();
-
-	// Either show or hide the mouse cursor
-	bool showMouse(bool visible);
-
-	void warpMouse(int x, int y);
-
-	// Set the bitmap that's used when drawing the cursor.
-	void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor = 255, int cursorTargetScale = 1);
-
-	// Shaking is used in SCUMM. Set current shake position.
-	void setShakePos(int shake_pos);
-
-	// Get the number of milliseconds since the program was started.
-	uint32 getMillis();
-
-	// Delay for a specified amount of milliseconds
-	void delayMillis(uint msecs);
-
-	// Get the next event.
-	// Returns true if an event was retrieved.
-	bool pollEvent(Event &event);
-
-	// Set the function to be invoked whenever samples need to be generated
-	// Format is the sample type format.
-	// Only 16-bit signed mode is needed for simon & scumm
-	bool setSoundCallback(SoundProc proc, void *param);
-
-	// Clear Sound Sample
-	void clearSoundCallback();
-
-	// OLD - Delete when sure not needed.
-	// Get or set a property
-	//uint32 property(int param, Property *value);
-	//virtual uint32 property(int param, Property *value);
-
-	// Poll cdrom status
-	// Returns true if cd audio is playing
-	bool pollCD();
-
-	// Play cdrom audio track
-	void playCD(int track, int num_loops, int start_frame, int duration);
-
-	// Stop cdrom audio track
-	void stopCD();
-
-	// Update cdrom audio status
-	void updateCD();
-
-	// Add a new callback timer
-	void setTimerCallback(TimerProc callback, int timer);
-
-	// Mutex handling
-	OSystem::MutexRef createMutex();
-	void lockMutex(MutexRef mutex);
-	void unlockMutex(MutexRef mutex);
-	void deleteMutex(MutexRef mutex);
-	// DJWillis
-
-	//helper
-	int16 get_height();
-	int16 get_width();
-
-	// Quit
-	void quit();
-
-	// Overlay
-	void showOverlay();
-	void hideOverlay();
-	void clearOverlay();
-	void grabOverlay(int16 *buf, int pitch);
-	void copyRectToOverlay(const int16 *buf, int pitch, int x, int y, int w, int h);
-
-	//static OSystem *create(int gfx_mode, bool full_screen);
-
-	int16 RBGToColor(uint8 r, uint8 g, uint8 b);
-	void colorToRBG(int16 color, uint8 &r, uint8 &g, uint8 &b);
-
-	//void *gm_yocalloc(size_t num_elem, size_t size_elem);
-	//void *gm_realloc(void *ptr, size_t size);
-
-	// New 0.6.0 +
-	const GraphicsMode *getSupportedGraphicsModes() const;
-	int getDefaultGraphicsMode() const;
-	bool setGraphicsMode(int mode);
-	int getGraphicsMode() const;
-
-	void setWindowCaption(const char *caption);
-	bool openCD(int drive);
-
-	// Determine the output sample rate. Audio data provided by the sound
-	// Callback sound be played using this rate.
-	// FIXME: GP32 Hardcodes rate currently.
-	int getOutputSampleRate() const;
-
-	bool hasFeature(Feature f);
-	void setFeatureState(Feature f, bool enable);
-	bool getFeatureState(Feature f);
-
-	//static OSystem *create();
-
-private:
-
-	// Set the position of the mouse cursor - Not part of OSystem anymore.
-	void set_mouse_pos(int x, int y);
-
-	gpSurface *_tmpscreen;   // temporary screen (for scalers/overlay)
-	gpSurface *_hwscreen;    // hardware screen
-	bool _overlayVisible;
-
-	ScalerProc *_scaler_proc;
-
-	int TMP_SCREEN_WIDTH;
-
-	//uint msec_start;
-	//uint32 get_ticks();
-
-	// unseen game screen
-	gpSurface *_screen;
-	int _screenWidth, _screenHeight;
-
-	// CD Audio, Not used in GP32 backend
-	int cd_track, cd_num_loops, cd_start_frame, cd_end_frame;
-	uint32 cd_end_time, cd_stop_time, cd_next_second;
-
-	enum {
-		DF_WANT_RECT_OPTIM			= 1 << 0,
-		DF_UPDATE_EXPAND_1_PIXEL	= 1 << 3
-	};
-
-	bool _forceFull; // Force full redraw on next updateScreen
-	int _scaleFactor;
-	int _mode;
-	bool _full_screen;
-	uint32 _mode_flags;
-	bool _modeChanged;
-
-	/** True if aspect ratio correction is enabled. */
-	bool _adjustAspectRatio;
-
-	enum {
-		NUM_DIRTY_RECT = 100,
-		MAX_MOUSE_W = 40,
-		MAX_MOUSE_H = 40,
-		MAX_SCALING = 3
-	};
-
-	// Dirty rect managment
-	gpRect _dirty_rect_list[100];
-	int _num_dirty_rects;
-	uint32 *_dirty_checksums;
-	bool cksum_valid;
-	int CKSUM_NUM;
-
-	// Keyboard mouse emulation
-	struct KbdMouse {
-		int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;
-		uint32 last_time, delay_time, x_down_time, y_down_time;
-	} km;
-
-	struct MousePos {
-		int16 x, y, w, h;
-	};
-
-	bool _mouseVisible;
-	bool _mouseDrawn;
-	byte *_mouseData;
-	byte *_mouseBackup;
-	MousePos _mouseCurState;
-	MousePos _mouseOldState;
-	int16 _mouseHotspotX;
-	int16 _mouseHotspotY;
-	byte _mouseKeycolor;
-
-	// Shake mode
-	int _currentShakePos;
-	int _newShakePos;
-
-	// Palette data
-	gpColor *_currentPalette;
-	uint _paletteDirtyStart, _paletteDirtyEnd;
-
-	/**
-	 * Mutex which prevents multiple threads from interfering with each other
-	 * when accessing the screen.
-	 */
-	MutexRef _graphicsMutex;
-
-	void add_dirty_rgn_auto(const byte *buf);
-	void mk_checksums(const byte *buf);
-
-	static void fill_sound(void *userdata, Uint8 * stream, int len);
-
-	void add_dirty_rect(int x, int y, int w, int h);
-
-	void draw_mouse();
-	void undraw_mouse();
-
-	void internUpdateScreen();
-
-	void load_gfx_mode();
-	void unload_gfx_mode();
-	void hotswap_gfx_mode();
-
-	void setFullscreenMode(bool enable);
-
-	void get_screen_image(byte *buf);
-
-	void setup_icon();
-	void kbd_mouse();
-	//static OSystem_GP32 *create();
-};
-
-#else
-	#warning GP32.H Called more then once.
-#endif /* GP32_H */
-
diff --git a/backends/gp32/gp32_launcher.cpp b/backends/gp32/gp32_launcher.cpp
new file mode 100644
index 0000000000..5eaa1158a7
--- /dev/null
+++ b/backends/gp32/gp32_launcher.cpp
@@ -0,0 +1,148 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+#include "common/scaler.h"
+#include "common/system.h"
+#include "backends/intern.h"
+
+#include "base/engine.h"
+
+#include "backends/gp32/gp32std.h"
+#include "backends/gp32/gp32std_grap.h"
+#include "backends/gp32/gp32std_input.h"
+
+#include "backends/gp32/gfx_splash.h"
+#include "backends/gp32/gp32_launcher.h"
+
+uint16 cpuSpeedTable[15] = {40, 66, 100, 120, 133, 144, 156, 160, 166, 172, 176, 180, 188, 192, 200};
+uint16 gammaTable[16] = {50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200};
+char *oplTable[3] = {"LOW", "MEDIUM", "HIGH"};
+uint16 sampleTable[3] = {11025, 22050, 44100};
+
+uint8 maxTable[5] = {15, 16, 3, 3, 2};
+uint8 currentSetting[5] = {3, 5, 1, 0, 0};
+
+int g_cpuSpeed = 120;
+int g_gammaRamp = 100;
+
+void configMenu() {
+	uint32 nKeyUD;
+	uint16 nKeyP;
+
+	int currentSelect = 0;
+	char text[32];
+
+	while (1) {
+		gp_fillRect(frameBuffer2, 0, 0, 320, 240, 0xffff);
+		gp_textOut(frameBuffer2, 90, 10, "Configuration Menu", 0);
+
+		gp_textOut(frameBuffer2, 30, 40, "CPU clock speed", 0);
+		gp_textOut(frameBuffer2, 30, 80, "Gamma ramp", 0);
+		gp_textOut(frameBuffer2, 30, 120, "FMOPL (AdLib) quality", gp_RGBTo16(128, 128, 128));
+		gp_textOut(frameBuffer2, 30, 160, "Sampling rate", gp_RGBTo16(128, 128, 128));
+
+		gp_textOut(frameBuffer2, 100, 210, "OK         CANCEL", 0);
+
+		if (currentSelect == 4)
+			gp_textOut(frameBuffer2, 80, 210, "@", 0);
+		else
+			gp_textOut(frameBuffer2, 20, (currentSelect + 1) * 40, "@", 0);
+
+		sprintf(text, "%d MHz", cpuSpeedTable[currentSetting[0]]);
+		gp_textOut(frameBuffer2, 220, 40, text, 0);
+		sprintf(text, "%d %%", gammaTable[currentSetting[1]]);
+		gp_textOut(frameBuffer2, 220, 80, text, 0);
+		gp_textOut(frameBuffer2, 220, 120, oplTable[currentSetting[2]], gp_RGBTo16(128, 128, 128));
+		sprintf(text, "%d Hz", sampleTable[currentSetting[3]]);
+		gp_textOut(frameBuffer2, 220, 160, text, gp_RGBTo16(128, 128, 128));
+
+		gp_flipScreen();
+
+		gp_getButtonEvent(&nKeyUD, &nKeyP);
+
+		if (gpd_getButtonDown(nKeyUD, GPC_VK_UP)) {
+			if (currentSelect > 0)
+				currentSelect--;
+		}
+		if (gpd_getButtonDown(nKeyUD, GPC_VK_DOWN)) {
+			if (currentSelect < 4)
+				currentSelect++;
+		}
+		if (gpd_getButtonDown(nKeyUD, GPC_VK_LEFT)) {
+			if (currentSelect <= 1)
+				if (currentSetting[currentSelect] > 0)
+					currentSetting[currentSelect]--;
+		}
+		if (gpd_getButtonDown(nKeyUD, GPC_VK_RIGHT)) {
+			if (currentSelect <= 1)
+				if (currentSetting[currentSelect] < maxTable[currentSelect] - 1)
+					currentSetting[currentSelect]++;
+		}
+
+		if (gpd_getButtonUp(nKeyUD, GPC_VK_START) ||
+			gpd_getButtonUp(nKeyUD, GPC_VK_FA)) {
+			if (currentSelect == 4) {
+				if (currentSetting[currentSelect] == 0) { // OK
+					g_cpuSpeed = cpuSpeedTable[currentSetting[0]];
+					g_gammaRamp = gammaTable[currentSetting[1]];
+					return;
+				} else { // CANCEL
+					return;
+				}
+			}
+		}
+	}
+}
+
+void splashScreen() {
+	uint32 nKeyUD;
+	uint16 nKeyP;
+
+	while (1) {
+		uint16 *buffer = frameBuffer2;//&frameBuffer1[240 - _screenHeight];
+		uint8 *picBuffer = gfx_splash;
+
+		for (int c = 0; c < LCD_WIDTH * LCD_HEIGHT; c++) {
+			*buffer++ = gfx_splash_Pal[*picBuffer++];
+		}
+
+		gp_flipScreen();
+
+		while (1) {
+			gp_getButtonEvent(&nKeyUD, &nKeyP);
+
+			if (gpd_getButtonUp(nKeyUD, GPC_VK_START) ||
+				gpd_getButtonUp(nKeyUD, GPC_VK_FA)) {
+				gp_fillRect(frameBuffer1, 0, 0, 320, 240, 0xffff);
+				gp_fillRect(frameBuffer2, 0, 0, 320, 240, 0xffff);
+				return;
+			}
+			if (gpd_getButtonUp(nKeyUD, GPC_VK_SELECT)) {
+				configMenu();
+				break;
+			}
+		}
+	}
+}
diff --git a/backends/gp32/gp32_launcher.h b/backends/gp32/gp32_launcher.h
new file mode 100644
index 0000000000..6acc74f715
--- /dev/null
+++ b/backends/gp32/gp32_launcher.h
@@ -0,0 +1,34 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifndef __GP32_LAUNCHER_H
+#define __GP32_LAUNCHER_H
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+
+extern void splashScreen();
+
+extern int g_cpuSpeed;
+extern int g_gammaRamp;
+
+#endif
diff --git a/backends/gp32/gp32_main.cpp b/backends/gp32/gp32_main.cpp
new file mode 100644
index 0000000000..46496ccf51
--- /dev/null
+++ b/backends/gp32/gp32_main.cpp
@@ -0,0 +1,183 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+#include "common/scaler.h"
+#include "common/system.h"
+#include "backends/intern.h"
+
+#include "base/engine.h"
+
+#include "backends/gp32/gp32std.h"
+#include "backends/gp32/gp32std_grap.h"
+
+#include "backends/gp32/gp32_launcher.h"
+
+#include "backends/gp32/gp32_osys.h"
+
+extern "C" int scummvm_main(int argc, char *argv[]);
+
+extern void gp_delay(uint32 msecs);
+
+extern "C" void cpu_speed(int MCLK, int CLKDIV, int CLKMODE); // CPU Speed control (3 int's, clock, bus, dividor)
+
+// Where's better position?
+static int CLKDIV = 0x48013;
+static int MCLK = 40000000;
+static int CLKMODE = 0;
+static int HCLK = 40000000;
+static int PCLK = 40000000;
+/*
+int gp_getPCLK() {
+   return PCLK;
+}
+
+int gp_getHCLK() {
+   return HCLK;
+}
+*/
+void gp_clockSpeedChange(int freq, int magic, int div) {
+	#define rTCFG0 (*(volatile unsigned *)0x15100000)
+	#define rTCFG1 (*(volatile unsigned *)0x15100004)
+	#define rTCNTB4 (*(volatile unsigned *)0x1510003c)
+	unsigned int pclk;
+	unsigned int prescaler0;
+
+	/* Change CPU Speed */
+	GpClockSpeedChange(freq, magic, div);
+	pclk = GpPClkGet();
+
+	/* Repair SDK timer - it forgets to set prescaler */
+	prescaler0 = (pclk / (8000 * 40)) - 1;
+	rTCFG0 = (rTCFG0 & 0xFFFFFF00) | prescaler0;
+	rTCFG1 = 0x30033;
+
+	/* Repair GpTickCountGet */
+	rTCNTB4 = pclk / 1600;
+}
+
+void gp_setCpuSpeed(int freq) {
+	switch (freq) {
+		// overclocked
+		case 168: { CLKDIV = 0x14000; MCLK = 168000000; CLKMODE = 3; break; }
+		case 172: { CLKDIV = 0x23010; MCLK = 172000000; CLKMODE = 3; break; }
+		case 176: { CLKDIV = 0x24010; MCLK = 176000000; CLKMODE = 3; break; }
+		case 180: { CLKDIV = 0x16000; MCLK = 180000000; CLKMODE = 3; break; }
+		case 184: { CLKDIV = 0x26010; MCLK = 184000000; CLKMODE = 3; break; }
+		case 188: { CLKDIV = 0x27010; MCLK = 188000000; CLKMODE = 3; break; }
+		case 192: { CLKDIV = 0x18000; MCLK = 192000000; CLKMODE = 3; break; }
+		case 196: { CLKDIV = 0x29010; MCLK = 196000000; CLKMODE = 3; break; }
+		case 200: { CLKDIV = 0x2A010; MCLK = 200000000; CLKMODE = 3; break; }
+		case 204: { CLKDIV = 0x2b010; MCLK = 204000000; CLKMODE = 3; break; }
+		case 208: { CLKDIV = 0x2c010; MCLK = 208000000; CLKMODE = 3; break; }
+		case 212: { CLKDIV = 0x2d010; MCLK = 212000000; CLKMODE = 3; break; }
+		case 216: { CLKDIV = 0x2e010; MCLK = 216000000; CLKMODE = 3; break; }
+		case 220: { CLKDIV = 0x2f010; MCLK = 220000000; CLKMODE = 3; break; }
+		case 224: { CLKDIV = 0x30010; MCLK = 224000000; CLKMODE = 3; break; }
+		case 228: { CLKDIV = 0x1e000; MCLK = 228000000; CLKMODE = 3; break; }
+		case 232: { CLKDIV = 0x32010; MCLK = 232000000; CLKMODE = 3; break; }
+		case 236: { CLKDIV = 0x33010; MCLK = 236000000; CLKMODE = 3; break; }
+		case 240: { CLKDIV = 0x20000; MCLK = 240000000; CLKMODE = 3; break; }
+		case 244: { CLKDIV = 0x35010; MCLK = 244000000; CLKMODE = 3; break; }
+		case 248: { CLKDIV = 0x36010; MCLK = 248000000; CLKMODE = 3; break; }
+		case 252: { CLKDIV = 0x22000; MCLK = 252000000; CLKMODE = 3; break; }
+		case 256: { CLKDIV = 0x38010; MCLK = 256000000; CLKMODE = 3; break; }
+
+		// normal
+//		case 166: { CLKDIV = 0x4B011; MCLK = 166000000; CLKMODE = 3; break; }
+		case 166: { CLKDIV = 0x2f001; MCLK = 165000000; CLKMODE = 3; break; }
+		case 164: { CLKDIV = 0x4a011; MCLK = 164000000; CLKMODE = 3; break; }
+		case 160: { CLKDIV = 0x48011; MCLK = 160000000; CLKMODE = 3; break; }
+//		case 156: { CLKDIV = 0x2c001; MCLK = 156000000; CLKMODE = 3; break; }
+		case 156: { CLKDIV = 0x2c001; MCLK = 156000000; CLKMODE = 3; break; }
+		case 144: { CLKDIV = 0x28001; MCLK = 144000000; CLKMODE = 3; break; }
+//		case 133: { CLKDIV = 0x3a011; MCLK = 132000000; CLKMODE = 3; break; }
+		case 133: { CLKDIV = (81 << 12) | (2 << 4) | 1; MCLK = 133500000; CLKMODE = 2; break; }
+		case 132: { CLKDIV = 0x3a011; MCLK = 132000000; CLKMODE = 3; break; }
+		case 120: { CLKDIV = 0x24001; MCLK = 120000000; CLKMODE = 2; break; }
+//		case 100: { CLKDIV = 0x2b011; MCLK = 102000000; CLKMODE=2; break; }
+		case 100: { CLKDIV =( 43 << 12) | (1 << 4) | 1; MCLK = 102000000; CLKMODE = 2; break; }
+//		case  66: { CLKDIV = 0x25002; MCLK= 67500000; CLKMODE=2; break; }
+		case  66: { CLKDIV = (37 << 12) | (0 << 4) | 2; MCLK= 67500000; CLKMODE = 2; break; }
+		case  50: { CLKDIV = 0x2a012; MCLK= 50000000; CLKMODE = 0; break; }
+//		case  40: { CLKDIV = 0x48013; MCLK= 40000000; CLKMODE = 0; break; }
+		case  40: { CLKDIV = 0x48013; MCLK= 40000000; CLKMODE = 1; break; }
+//		case  33: { CLKDIV = 0x25003; MCLK= 33750000; CLKMODE = 0; break; }
+		case  33: { CLKDIV = (37 << 12) | (0 << 4) | 3; MCLK = 33750000; CLKMODE = 2; break; }
+		case  22: { CLKDIV = 0x33023; MCLK = 22125000; CLKMODE = 0; break; }
+	}
+	if (CLKMODE==0) { HCLK = MCLK;     PCLK = MCLK; }
+	if (CLKMODE==1) { HCLK = MCLK;     PCLK = MCLK / 2; }
+	if (CLKMODE==2) { HCLK = MCLK / 2; PCLK = MCLK / 2; }
+	if (CLKMODE==3) { HCLK = MCLK / 2; PCLK = MCLK / 4; }
+	//cpu_speed(MCLK, CLKDIV, CLKMODE);
+	gp_clockSpeedChange(MCLK, CLKDIV, CLKMODE);
+}
+
+void gp_Reset() {
+   gp_setCpuSpeed(66);
+   asm volatile("swi #4\n");
+}
+
+void init() {
+	gp_setCpuSpeed(66); // Default CPU Speed
+
+	GpGraphicModeSet(16, NULL);
+
+	//if (type == NLU || type == FLU || type == BLU)
+	//	gp_initFramebuffer(frameBuffer, 16, 85);
+	//else if (type == BLUPLUS)
+	//	gp_initFramebufferBP(frameBuffer, 16, 85);
+	// else
+	//	error("Invalid Console");
+	gp_initFrameBuffer();
+
+
+	GpFatInit();
+	GpRelativePathSet("gp:\\gpmm");
+	//ERR_CODE err_code;
+	//err_code = GpDirCreate("temp", 0);
+	//	if (err_code != SM_OK)	return;
+	g_cpuSpeed = 120;
+}
+
+void GpMain(void *arg) {
+	init();
+
+	splashScreen();
+	
+	//doConfig
+	gp_setCpuSpeed(g_cpuSpeed);
+	GPDEBUG("Set CPU Speed: %d", g_cpuSpeed);
+
+	// FOR DEBUG PURPOSE!
+	int argc = 2;
+	//char *argv[] = { "scummvm", "playfate" };
+	//char *argv[] = { "scummvm", "-enull", "-pgp:\\game\\loomcd\\", "loomcd" };
+	//char *argv[] = { "scummvm", "-enull", "-pgp:\\game\\dott\\", "tentacle" };
+	char *argv[] = { "scummvm", "-enull", "-d3" };
+
+	//scummvm_main(argc, argv);
+
+	scummvm_main(1, NULL);
+}
diff --git a/backends/gp32/gp32_osys.cpp b/backends/gp32/gp32_osys.cpp
new file mode 100644
index 0000000000..61125e22e5
--- /dev/null
+++ b/backends/gp32/gp32_osys.cpp
@@ -0,0 +1,744 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
+ *
+ * $Header$
+ *
+ */
+
+#include "backends/gp32/gp32_osys.h"
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+
+#include "common/rect.h"
+#include "common/savefile.h"
+#include "common/config-manager.h"
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{0, 0, 0}
+};
+
+OSystem_GP32::OSystem_GP32() :
+		_screenWidth(0), _screenHeight(0), _gameScreen(NULL), _hwScreen(NULL),
+		_overlayVisible(false), _forceFull(false), _adjustAspectRatio(false),
+		/*_paletteDirtyStart(0), _paletteDirtyEnd(0),*/ _mouseBuf(NULL) {
+	NP("OSys::OSystem_GP32()");
+	// allocate palette storage
+	memset(_currentPalette, 0, 256 * sizeof(uint16));
+
+	memset(&_km, 0, sizeof(_km));
+
+	// HACK: bring mouse cursor to center
+	_mouseX = 160;
+	_mouseY = 120;
+}
+
+OSystem_GP32::~OSystem_GP32() {
+	NP("OSys::~OSystem_GP32()");
+}
+
+bool OSystem_GP32::hasFeature(Feature f) {
+	NP("OSys::hasFeature()");
+	return false;
+}
+
+void OSystem_GP32::setFeatureState(Feature f, bool enable) {
+	NP("OSys::setFeatureState()");
+}
+
+bool OSystem_GP32::getFeatureState(Feature f) {
+	NP("OSys::getFeatureState()");
+	return false;
+}
+
+const OSystem::GraphicsMode* OSystem_GP32::getSupportedGraphicsModes() const {
+	NP("OSys::getSupportedGraphicsModes()");
+	return s_supportedGraphicsModes;
+}
+
+
+int OSystem_GP32::getDefaultGraphicsMode() const {
+	NP("OSys::getSupportedGraphicsModes()");
+	return -1;
+}
+
+bool OSystem_GP32::setGraphicsMode(int mode) {
+	NP("OSys::setGraphicsMode()");
+	return true;
+}
+
+bool OSystem_GP32::setGraphicsMode(const char *name) {
+	NP("OSys::setGraphicsMode()");
+	return true;
+}
+
+int OSystem_GP32::getGraphicsMode() const {
+	NP("OSys::getGraphicsMode()");
+	return -1;
+}
+
+void OSystem_GP32::initSize(uint width, uint height, int overlayScale) {
+	NP("OSys::initSize()");
+
+	if (width == _screenWidth && height == _screenHeight)
+		return;
+
+	_screenWidth = width;
+	_screenHeight = height;
+
+	if (height != 200)
+		_adjustAspectRatio = false;
+
+	_overlayWidth = width;
+	_overlayHeight = height;
+
+	// Create the surface that contains the 8 bit game data
+	_gameScreen = new uint8[_screenWidth * _screenHeight];
+
+	// Create the surface that contains the scaled graphics in 16 bit mode
+	_tmpScreen = frameBuffer2;
+
+	// Create the surface that is connected with hardware screen
+	_hwScreen = frameBuffer1;
+
+	_overlayBuffer = new OverlayColor[_overlayWidth * _overlayHeight];
+
+	_km.x_max = _screenWidth - 1;
+	_km.y_max = _screenHeight - 1;
+	_km.x = _mouseX;
+	_km.y = _mouseY;
+	_km.delay_time = 25;
+	_km.last_time = 0;
+
+	// Clear Screen
+	gp_fillRect(_hwScreen, 0, 0, 320, 240, 0xFFFF);
+}
+
+int16 OSystem_GP32::getHeight() {
+	NP("OSys::getHeight()");
+	return _screenHeight;
+}
+
+int16 OSystem_GP32::getWidth() {
+	NP("OSys::getWidth()");
+	return _screenWidth;
+}
+
+void OSystem_GP32::setPalette(const byte *colors, uint start, uint num) {
+	NP("OSys::setPalette()");
+	const byte *b = colors;
+	uint i;
+	uint16 *base = _currentPalette + start;
+	for (i = 0; i < num; i++) {
+		base[i] = gp_RGBTo16(b[0], b[1], b[2]);
+		b += 4;
+	}
+
+//	if (start < _paletteDirtyStart)
+//		_paletteDirtyStart = start;
+
+//	if (start + num > _paletteDirtyEnd)
+//		_paletteDirtyEnd = start + num;
+}
+
+void OSystem_GP32::grabPalette(byte *colors, uint start, uint num) {
+	NP("OSys::grabPalette()");
+}
+
+void OSystem_GP32::copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h) {
+	NP("OSys::copyRectToScreen()");
+	//Clip the coordinates
+	if (x < 0) {
+		w += x;
+		src -= x;
+		x = 0;
+	}
+
+	if (y < 0) {
+		h += y;
+		src -= y * pitch;
+		y = 0;
+	}
+
+	if (w > _screenWidth - x) {
+		w = _screenWidth - x;
+	}
+
+	if (h > _screenHeight - y) {
+		h = _screenHeight - y;
+	}
+
+	if (w <= 0 || h <= 0)
+		return;
+	
+	byte *dst = _gameScreen + y * _screenWidth + x;
+
+	if (_screenWidth == pitch && pitch == w) {
+		memcpy(dst, src, h * w);
+	} else {
+		do {
+			memcpy(dst, src, w);
+			src += pitch;
+			dst += _screenWidth;
+		} while (--h);
+	}
+}
+
+//TODO: Implement Dirty rect?
+void OSystem_GP32::updateScreen() {
+	uint16 *buffer;
+	//TODO: adjust shakePos
+
+	// draw gamescreen
+	buffer = &_tmpScreen[240 - _screenHeight];
+	for (int x = 0; x < _screenWidth; x++) {
+		for (int y = 0; y < _screenHeight; y++) {
+			*buffer++ = _currentPalette[_gameScreen[((_screenHeight - 1) - y) * _screenWidth + x]];
+		}
+		buffer += 240 - _screenHeight;
+	}
+	
+	// draw overlay
+	if (_overlayVisible) {
+		buffer = &_tmpScreen[240 - _overlayHeight];
+		for (int x = 0; x < _overlayWidth; x++) {
+			for (int y = 0; y < _overlayHeight; y++) {
+				*buffer++ = _overlayBuffer[((_overlayHeight - 1) - y) * _overlayWidth + x];
+			}
+			buffer += 240 - _overlayHeight;
+		}
+	}
+
+	// draw mouse
+	//adjust cursor position
+	int mX = _mouseX - _mouseHotspotX;
+	int mY = _mouseY - _mouseHotspotY;
+	//if (_overlayVisible)
+	//else
+	if (_mouseVisible)
+		for (int y = 0; y < _mouseHeight; y++) {
+			for (int x = 0; x < _mouseWidth; x++) {
+				if (mX + x < _screenWidth && mY + y < _screenHeight && mX + x >= 0 && mY + y >= 0)
+					if (_mouseBuf[y * _mouseWidth + x] != _mouseKeyColor)
+						gpd_drawPixel16(_tmpScreen, mX + x, mY + y, _currentPalette[_mouseBuf[y * _mouseWidth + x]]);
+			}
+		}
+		
+	//TODO: draw softkeyboard
+
+	gp_flipScreen();
+	_hwScreen = frameBuffer1;
+	_tmpScreen = frameBuffer2;
+	//memcpy(_hwScreen, _tmpScreen, LCD_WIDTH * LCD_HEIGHT * sizeof(uint16));
+}
+
+void OSystem_GP32::setShakePos(int shakeOffset) {
+	NP("OSys::setShakePos()");
+}
+
+void OSystem_GP32::showOverlay() {
+	_overlayVisible = true;
+	clearOverlay();
+}
+
+void OSystem_GP32::hideOverlay() {
+	_overlayVisible = false;
+	clearOverlay();
+	_forceFull = true;
+}
+
+// Clear overlay with game screen
+//TODO: Optimize?
+void OSystem_GP32::clearOverlay() {
+	NP("OSys::clearOverlay()");
+	if (!_overlayVisible)
+		return;
+
+	uint8 *s = _gameScreen;
+	OverlayColor *d = _overlayBuffer;
+	uint8 c;
+	for (int y = 0; y < _overlayHeight; y++) {
+		for (int x = 0; x < _overlayWidth; x++) {
+			c = *s;
+			*d++ = _currentPalette[c];
+			s++;
+		}
+	}
+
+	_forceFull = true;
+}
+
+void OSystem_GP32::grabOverlay(OverlayColor *buf, int pitch)
+{
+	NP("OSys::grabOverlay()");
+}
+
+void OSystem_GP32::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
+	OverlayColor *dst = (OverlayColor *)_overlayBuffer + y * _overlayWidth + x;
+	do {
+		memcpy(dst, buf, w * sizeof(uint16));
+		dst += _overlayWidth;
+		buf += pitch;
+	} while (--h);
+}
+
+int16 OSystem_GP32::getOverlayHeight() {
+	NP("OSys::getOverlayHeight()");
+	return getHeight();
+}
+
+int16 OSystem_GP32::getOverlayWidth() {
+	NP("OSys::getOverlayWidth()");
+	return getWidth();
+}
+
+OverlayColor OSystem_GP32::RGBToColor(uint8 r, uint8 g, uint8 b) {
+	return gp_RGBTo16(r, g, b);
+}
+
+void OSystem_GP32::colorToRGB(OverlayColor color, uint8 &r, uint8 &g, uint8 &b) {
+	gp_16ToRGB(color, &r, &g, &b);
+}
+
+bool OSystem_GP32::showMouse(bool visible) {
+	NP("OSys::showMouse()");
+	if (_mouseVisible == visible)
+		return visible;
+
+	bool last = _mouseVisible;
+	_mouseVisible = visible;
+
+	updateScreen();
+
+	return last;
+}
+
+void OSystem_GP32::warpMouse(int x, int y) {
+	NP("OSys::warpMouse()");
+	//assert(x > 0 && x < _screenWidth);
+	//assert(y > 0 && y < _screenHeight);
+	_mouseX = x;
+	_mouseY = y;
+}
+
+void OSystem_GP32::setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor, int cursorTargetScale) {
+	//NP("OSys::setMouseCursor()");
+	_mouseWidth = w;
+	_mouseHeight = h;
+
+	_mouseHotspotX = hotspotX;
+	_mouseHotspotY = hotspotY;
+
+	_mouseKeyColor = keycolor;
+
+	if (_mouseBuf)
+		free(_mouseBuf);
+
+	_mouseBuf = (byte *)malloc(w * h);
+	memcpy(_mouseBuf, buf, w * h);
+}
+
+void OSystem_GP32::handleKbdMouse() {
+	uint32 curTime = getMillis();
+	if (curTime >= _km.last_time + _km.delay_time) {
+		_km.last_time = curTime;
+		if (_km.x_down_count == 1) {
+			_km.x_down_time = curTime;
+			_km.x_down_count = 2;
+		}
+		if (_km.y_down_count == 1) {
+			_km.y_down_time = curTime;
+			_km.y_down_count = 2;
+		}
+
+		if (_km.x_vel || _km.y_vel) {
+			if (_km.x_down_count) {
+				if (curTime > _km.x_down_time + _km.delay_time * 12) {
+					if (_km.x_vel > 0)
+						_km.x_vel++;
+					else
+						_km.x_vel--;
+				} else if (curTime > _km.x_down_time + _km.delay_time * 8) {
+					if (_km.x_vel > 0)
+						_km.x_vel = 5;
+					else
+						_km.x_vel = -5;
+				}
+			}
+			if (_km.y_down_count) {
+				if (curTime > _km.y_down_time + _km.delay_time * 12) {
+					if (_km.y_vel > 0)
+						_km.y_vel++;
+					else
+						_km.y_vel--;
+				} else if (curTime > _km.y_down_time + _km.delay_time * 8) {
+					if (_km.y_vel > 0)
+						_km.y_vel = 5;
+					else
+						_km.y_vel = -5;
+				}
+			}
+
+			//GPDEBUG("%d %d - %d %d", _km.x, _km.y, _km.x_vel, _km.y_vel);
+			_km.x += _km.x_vel;
+			_km.y += _km.y_vel;
+
+			if (_km.x < 0) {
+				_km.x = 0;
+				_km.x_vel = -1;
+				_km.x_down_count = 1;
+			} else if (_km.x > _km.x_max) {
+				_km.x = _km.x_max;
+				_km.x_vel = 1;
+				_km.x_down_count = 1;
+			}
+
+			if (_km.y < 0) {
+				_km.y = 0;
+				_km.y_vel = -1;
+				_km.y_down_count = 1;
+			} else if (_km.y > _km.y_max) {
+				_km.y = _km.y_max;
+				_km.y_vel = 1;
+				_km.y_down_count = 1;
+			}
+
+			warpMouse(_km.x, _km.y);
+		}
+	}
+}
+
+void OSystem_GP32::fillMouseEvent(Event &event, int x, int y) {
+	event.mouse.x = x;
+	event.mouse.y = y;
+
+	// Update the "keyboard mouse" coords
+	_km.x = x;
+	_km.y = y;
+
+	// Optionally perform aspect ratio adjusting
+	//if (_adjustAspectRatio)
+	//	event.mouse.y = aspect2Real(event.mouse.y);
+}
+
+bool OSystem_GP32::pollEvent(Event &event) {
+	GP32BtnEvent ev;
+
+	handleKbdMouse();
+
+	if (!gp_pollButtonEvent(&ev))
+		return false;
+	
+	switch(ev.type) {
+	case BUTTON_DOWN:
+		if (ev.button == GPC_VK_LEFT) {
+			_km.x_vel = -1;
+			_km.x_down_count = 1;
+		}
+		if (ev.button == GPC_VK_RIGHT) {
+			_km.x_vel =  1;
+			_km.x_down_count = 1;
+		}
+		if (ev.button == GPC_VK_UP) {
+			_km.y_vel = -1;
+			_km.y_down_count = 1;
+		}
+		if (ev.button == GPC_VK_DOWN) {
+			_km.y_vel =  1;
+			_km.y_down_count = 1;
+		}
+		if (ev.button == GPC_VK_START) {	// START = menu/enter
+			event.type = EVENT_KEYDOWN;
+			if (_overlayVisible)
+				event.kbd.keycode = event.kbd.ascii = 13;
+			else
+				event.kbd.keycode = event.kbd.ascii = 319;
+			return true;
+		}
+		if (ev.button == GPC_VK_SELECT) {	// SELECT = pause
+			event.type = EVENT_KEYDOWN;
+			event.kbd.keycode = event.kbd.ascii = 32;
+			return true;
+		}
+		if (ev.button == GPC_VK_FR) { // R = ESC
+			event.type = EVENT_KEYDOWN;
+			event.kbd.keycode = event.kbd.ascii = 27;
+			return true;
+		}
+		if (ev.button == GPC_VK_FA) {
+			event.type = EVENT_LBUTTONDOWN;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+		if (ev.button == GPC_VK_FB) {
+			event.type = EVENT_RBUTTONDOWN;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+		break;
+	case BUTTON_UP:
+		if (ev.button == GPC_VK_LEFT) {
+			if (_km.x_vel < 0) {
+				_km.x_vel = 0;
+				_km.x_down_count = 0;
+			}
+			event.type = EVENT_MOUSEMOVE;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+		if (ev.button == GPC_VK_RIGHT) {
+			if (_km.x_vel > 0) {
+				_km.x_vel = 0;
+				_km.x_down_count = 0;
+			}
+			event.type = EVENT_MOUSEMOVE;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+		if (ev.button == GPC_VK_UP) {
+			if (_km.y_vel < 0) {
+				_km.y_vel = 0;
+				_km.y_down_count = 0;
+			}
+			event.type = EVENT_MOUSEMOVE;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+		if (ev.button == GPC_VK_DOWN) {
+			if (_km.y_vel > 0) {
+				_km.y_vel = 0;
+				_km.y_down_count = 0;
+			}
+			event.type = EVENT_MOUSEMOVE;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+
+		if (ev.button == GPC_VK_START) {
+			event.type = EVENT_KEYUP;
+			if (_overlayVisible)
+				event.kbd.keycode = event.kbd.ascii = 13;
+			else
+				event.kbd.keycode = event.kbd.ascii = 319;
+			return true;
+		}
+		if (ev.button == GPC_VK_SELECT) {
+			event.type = EVENT_KEYUP;
+			event.kbd.keycode = event.kbd.ascii = 32;
+			return true;
+		}
+		if (ev.button == GPC_VK_FR) {
+			event.type = EVENT_KEYUP;
+			event.kbd.keycode = event.kbd.ascii = 27;
+			return true;
+		}
+		if (ev.button == GPC_VK_FA) {
+			event.type = EVENT_LBUTTONUP;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+		if (ev.button == GPC_VK_FB) {
+			event.type = EVENT_RBUTTONUP;
+			fillMouseEvent(event, _km.x, _km.y);
+			return true;
+		}
+		break;
+	default:
+		error("Unknown Event!");
+	}
+
+	if (gp_getButtonPressed(GPC_VK_LEFT) ||
+		gp_getButtonPressed(GPC_VK_RIGHT) ||
+		gp_getButtonPressed(GPC_VK_UP) ||
+		gp_getButtonPressed(GPC_VK_DOWN)) {
+		event.type = EVENT_MOUSEMOVE;
+		fillMouseEvent(event, _km.x, _km.y);
+		return true;
+	}
+	return false;
+}
+
+uint32 OSystem_GP32::getMillis() {
+	return GpTickCountGet();
+}
+
+void OSystem_GP32::delayMillis(uint msecs) {
+	int startTime = GpTickCountGet();
+	while (GpTickCountGet() < startTime + msecs);
+}
+
+// Add a new callback timer
+//FIXME: Add to member
+int _timerInterval;
+int (*_timerCallback)(int);
+
+static void _timerCallbackVoid() {
+	//NP("timer running");
+	_timerCallback(_timerInterval);	//FIXME ?? (*_timercallback)(_timerinterval);
+}
+
+void OSystem_GP32::setTimerCallback(TimerProc callback, int interval) {
+	NP("OSys::setTimerCallback()");
+
+	int timerNo = 1;
+
+	if (callback == NULL) {
+		GpTimerKill(timerNo);
+		return;
+	}
+
+	if (GpTimerOptSet(timerNo, interval, 0, _timerCallbackVoid) == GPOS_ERR_ALREADY_USED) {
+		error("Timer slot is already used");
+	}
+
+	_timerInterval = interval;
+	_timerCallback = callback;
+
+	GpTimerSet(timerNo);
+}
+
+OSystem::MutexRef OSystem_GP32::createMutex() {
+	NP("OSys::createMutex()");
+	return NULL;
+}
+
+void OSystem_GP32::lockMutex(MutexRef mutex) {
+	NP("OSys::lockMutex()");
+}
+
+void OSystem_GP32::unlockMutex(MutexRef mutex) {
+	NP("OSys::unlockMutex()");
+}
+
+void OSystem_GP32::deleteMutex(MutexRef mutex) {
+	NP("OSys::deleteMutex()");
+}
+
+bool OSystem_GP32::setSoundCallback(SoundProc proc, void *param) {
+	NP("OSys::setSoundCallback()");
+
+	GPSOUNDBUF gpSoundBuf;
+	PCM_SR sampleFreq;
+
+	if (ConfMan.hasKey("output_rate"))
+		_samplesPerSec = ConfMan.getInt("output_rate");
+
+	if (_samplesPerSec <= 0)
+		_samplesPerSec = SAMPLES_PER_SEC;
+
+	// Originally, we always used 2048 samples. This loop will produce the
+	// same result at 22050 Hz, and should hopefully produce something
+	// sensible for other frequencies. Note that it must be a power of two.
+
+	uint32 samples = 0x8000;
+
+	for (;;) {
+		if ((1000 * samples) / _samplesPerSec < 100)
+			break;
+		samples >>= 1;
+	}
+
+	switch(_samplesPerSec) {
+		case 44100:
+			sampleFreq = PCM_S44;
+			break;
+		case 22050:
+			sampleFreq = PCM_S22;
+			break;
+		case 11025:
+			sampleFreq = PCM_S11;
+			break;
+		default:
+			_samplesPerSec = 22050;
+			sampleFreq = PCM_S22;
+	}
+
+	gpSoundBuf.freq = sampleFreq;
+	gpSoundBuf.format = PCM_16BIT;
+	gpSoundBuf.samples = samples;
+	gpSoundBuf.userdata = param;
+	gpSoundBuf.callback = proc;
+//	gpSoundBuf.pollfreq = 2 * (SAMPLES_PER_SEC / gpSoundBuf.samples);
+	gpSoundBuf.pollfreq = 2 * 4 * (SAMPLES_PER_SEC / gpSoundBuf.samples); // FIXME?
+	// Frequency of the timer interrupt which polls the playing position
+	// recommended value: 2*(playingfreq in Hz/GPSOUNDBUF.samples)
+	//s.samplesize;  // Size of one sample (8bit mono->1, 16bit stereo->4) - don't touch this
+
+	GpPcmInit(gpSoundBuf.freq, gpSoundBuf.format);
+	gp_soundBufStart(&gpSoundBuf);
+
+	// For Safety...
+	GPDEBUG("_samplesPerSec = %d, samples = %d", _samplesPerSec, samples);
+	gp_delay(1000);
+	return true;
+}
+
+void OSystem_GP32::clearSoundCallback() {
+	NP("OSys::clearSoundCallback()");
+	gp_soundBufStop();
+}
+
+int OSystem_GP32::getOutputSampleRate() const {
+	NP("OSys::getOutputSampleRate()");
+	return _samplesPerSec;
+}
+
+bool OSystem_GP32::openCD(int drive) {
+	NP("OSys::openCD()");
+	return true;
+}
+
+bool OSystem_GP32::pollCD() {
+	NP("OSys::pollCD()");
+	return true;
+}
+
+void OSystem_GP32::playCD(int track, int num_loops, int start_frame, int duration) {
+	NP("OSys::playCD()");
+}
+
+void OSystem_GP32::stopCD() {
+	NP("OSys::stopCD()");
+}
+
+void OSystem_GP32::updateCD() {
+	NP("OSys::updateCD()");
+}
+
+void OSystem_GP32::quit() {
+	NP("OSys::quit()");
+	clearSoundCallback();
+	setTimerCallback(0, 0);
+	exit(0);
+}
+
+void OSystem_GP32::setWindowCaption(const char *caption) {
+	NP("OSys::setWindowCaption(%s)", caption);
+}
+
+void OSystem_GP32::displayMessageOnOSD(const char *msg) {
+	NP("OSys::displayMessageOnOSD(%s)", msg);
+}
+
+OSystem *OSystem_GP32_create() {
+	NP("OSys::OSystem_GP32_create()");
+	return new OSystem_GP32();
+}
diff --git a/backends/gp32/gp32_osys.h b/backends/gp32/gp32_osys.h
new file mode 100644
index 0000000000..e00bdde556
--- /dev/null
+++ b/backends/gp32/gp32_osys.h
@@ -0,0 +1,158 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifndef GP32_OSYS_H
+#define GP32_OSYS_H
+
+//Standard ScummVM includes.
+#include "common/stdafx.h"
+#include "common/scummsys.h"
+#include "common/scaler.h"
+#include "common/system.h"
+#include "backends/intern.h"
+
+#include "base/engine.h"
+
+#include "backends/gp32/gp32std.h"
+#include "backends/gp32/gp32std_grap.h"
+#include "backends/gp32/gp32std_input.h"
+#include "backends/gp32/gp32std_sound.h"
+
+class OSystem_GP32 : public OSystem {
+public:
+	static OSystem *instance();
+
+protected:
+	uint16 _screenWidth, _screenHeight;
+	uint8 *_gameScreen;
+	uint16 *_tmpScreen, *_hwScreen;
+	OverlayColor *_overlayBuffer;
+
+	int _overlayWidth, _overlayHeight;
+	bool _overlayVisible;
+	uint32 _shakePos;
+
+	// Keyboard mouse emulation
+	struct KbdMouse {	
+		int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;
+		uint32 last_time, delay_time, x_down_time, y_down_time;
+	};
+
+	struct MousePos {
+		int16 x, y, w, h;
+	};
+
+	// mouse
+	KbdMouse _km;
+	bool _mouseVisible;
+	int	_mouseX, _mouseY;
+	int	_mouseWidth, _mouseHeight;
+	int	_mouseHotspotX, _mouseHotspotY;
+	byte _mouseKeyColor;
+	byte *_mouseBuf;
+
+	bool _adjustAspectRatio;
+	
+	/** Force full redraw on next updateScreen */
+	bool _forceFull;
+
+	uint16 _currentPalette[256];
+//	uint _paletteDirtyStart, _paletteDirtyEnd;
+
+	int32 _samplesPerSec;
+
+public:
+
+	OSystem_GP32();
+	virtual ~OSystem_GP32();
+
+	virtual bool hasFeature(Feature f);
+	virtual void setFeatureState(Feature f, bool enable);
+	virtual bool getFeatureState(Feature f);
+	virtual const GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual bool setGraphicsMode(int mode);
+	bool setGraphicsMode(const char *name);
+	virtual int getGraphicsMode() const;
+	virtual void initSize(uint width, uint height, int overlayScale);
+	virtual int16 getHeight();
+	virtual int16 getWidth();
+	virtual void setPalette(const byte *colors, uint start, uint num);
+	virtual void grabPalette(byte *colors, uint start, uint num);
+
+	virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h);
+	virtual void updateScreen();
+	virtual void setShakePos(int shakeOffset);
+
+	virtual void showOverlay();
+	virtual void hideOverlay();
+	virtual void clearOverlay();
+	virtual void grabOverlay(OverlayColor *buf, int pitch);
+	virtual void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
+	virtual int16 getOverlayHeight();
+	virtual int16 getOverlayWidth();
+
+	virtual OverlayColor RGBToColor(uint8 r, uint8 g, uint8 b);
+	virtual void colorToRGB(OverlayColor color, uint8 &r, uint8 &g, uint8 &b);
+
+	virtual bool showMouse(bool visible);
+
+	virtual void warpMouse(int x, int y);
+	virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor = 255, int cursorTargetScale = 1);
+
+	virtual bool pollEvent(Event &event);
+	virtual uint32 getMillis();
+	virtual void delayMillis(uint msecs);
+
+	virtual void setTimerCallback(TimerProc callback, int interval);
+
+	virtual MutexRef createMutex(void);
+	virtual void lockMutex(MutexRef mutex);
+	virtual void unlockMutex(MutexRef mutex);
+	virtual void deleteMutex(MutexRef mutex);
+
+	virtual bool setSoundCallback(SoundProc proc, void *param);
+	virtual void clearSoundCallback();
+	virtual int getOutputSampleRate() const;
+
+	virtual bool openCD(int drive);
+	virtual bool pollCD();
+
+	virtual void playCD(int track, int num_loops, int start_frame, int duration);
+	virtual void stopCD();
+	virtual void updateCD();
+
+	virtual void quit();
+
+	virtual void setWindowCaption(const char *caption);
+
+	virtual void displayMessageOnOSD(const char *msg);
+
+	void fillMouseEvent(Event &event, int x, int y);
+	void handleKbdMouse();
+};
+
+#else
+	#warning GP32_OSYS.H Called more then once.
+#endif /* GP32_H */
diff --git a/backends/gp32/gp32std.cpp b/backends/gp32/gp32std.cpp
new file mode 100644
index 0000000000..1a62cb13dc
--- /dev/null
+++ b/backends/gp32/gp32std.cpp
@@ -0,0 +1,564 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+#include "common/scaler.h"
+#include "common/system.h"
+#include "backends/intern.h"
+
+#include "base/engine.h"
+
+#include "backends/gp32/gp32std.h"
+#include "backends/gp32/gp32std_grap.h"
+
+FILE *gp_stderr = NULL;
+FILE *gp_stdout = NULL;
+FILE *gp_stdin = NULL;
+
+#define DEBUG_MAX 4
+char debline[DEBUG_MAX][256];
+static int debnext = 0;
+
+void _dprintf(const char *s, ...) {
+	int deba, deb;
+	char buf[1024];
+	va_list va;
+
+	va_start(va, s);
+	vsprintf(buf, s, va);
+	va_end(va);
+
+	strcpy(debline[debnext], buf);
+
+	gp_fillRect(frameBuffer1, 0, 200, 320, 40, 0);
+	
+	for (deb = debnext + 1, deba = 0; deb < DEBUG_MAX; deb++, deba++) {
+		gp_textOut(frameBuffer1, 0, 200 + 8 * deba, debline[deb], 0xFFFF);
+	}
+	for (deb = 0; deb <= debnext; deb++, deba++) {
+		gp_textOut(frameBuffer1, 0, 200 + 8 * deba, debline[deb], 0xFFFF);
+	}
+	debnext++;
+	if (debnext == DEBUG_MAX)
+		debnext = 0;
+}
+
+//////////////////
+//File functions
+// FOR LATER USE
+/*
+#define SM_PATH_SIZE		256
+
+const char smRootPath[] = "gp:\\";
+char smCurrentPath[SM_PATH_SIZE] = "gp:\\";		// must end with '\'
+
+int smMakePath(const char *path, char *smPath) {
+  // copy root or current directory
+  {
+    const char *p;
+    if ((*path == '/') || (*path == '\\'))
+    {
+      path++;
+      p = smRootPath;
+    }
+    else
+      p = smCurrentPath;
+    while (*p) *smPath++ = *p++;
+  }
+
+  // add filenames/directories. remove "." & ".."
+  do
+  {
+    switch (*path)
+    {
+    case 0:
+    case '/':
+    case '\\':
+      if (*(smPath-1) == '\\')
+      {
+        // already ends with '\'
+      }
+      else if ((*(smPath-1) == '.') && (*(smPath-2) == '\\'))
+      {
+        smPath--;	// remove '.' and end with '\'
+      }
+      else if ((*(smPath-1) == '.') && (*(smPath-2) == '.') && (*(smPath-3) == '\\'))
+      {
+        smPath -= 3;	// remove "\.."
+        if (*(smPath-1) == ':') *smPath++ = '\\';	// "dev0:" -> "dev0:\"
+        else while (*(smPath-1) != '\\') smPath--;	// remove one directory and end with '\'
+      }
+      else
+      {
+        *smPath++ = '\\';	// just add '\'
+      }
+      break;
+
+    default:
+      *smPath++ = *path;
+      break;
+    }
+  }
+  while (*path++);
+  
+  *smPath = '\\';
+
+//  *--smPath = 0;	// remove last '\' and null-terminate
+  *smPath = 0;	// remove last '\' and null-terminate
+
+  return 0;
+}
+*/
+GPFILE *gp_fopen(const char *fileName, const char *openMode) {
+	//FIXME: allocation, mode, malloc -> new
+	uint32 mode;
+	GPFILE *file;
+	ERR_CODE err;
+	char s[256];
+
+	if (!strchr(fileName, '.')) {
+		sprintf(s, "%s.", fileName);
+		fileName = s;
+	}
+
+	file = (GPFILE *)malloc(sizeof(GPFILE));
+
+//	NP("%s(\"%s\", \"%s\")", __FUNCTION__, fileName, openMode);
+
+	// FIXME add binary/text support
+	if (tolower(openMode[0]) == 'r') {
+		mode = OPEN_R;
+		GpFileGetSize(fileName, &file->size);
+		err = GpFileOpen(fileName, mode, &file->handle);
+	} else if (tolower(openMode[0]) == 'w') {
+		//printf("open if as W");
+		file->size = 0;	// FIXME? new file has no size?
+		file->cachePos = 0;
+		mode = OPEN_W;
+		err = GpFileCreate(fileName, ALWAYS_CREATE, &file->handle);
+	} else {
+		error("wrong file mode");
+	}
+
+	if (!file) {
+		error("%s: cannot create FILE structure", __FUNCTION__);
+	}
+	if (err) {
+//		BP("%s: IO error %d", __FUNCTION__, err);
+		free(file);
+		return NULL;
+	}
+
+	return file;
+}
+
+int gp_fclose(GPFILE *stream) {
+	if (!stream) {
+		//warning("closing null file");
+		return 1;
+	}
+
+/*	if (*(uint32 *)((char *)stream - sizeof(uint32)) == 0x4321) {
+		debug(0, "Double closing", __FUNCTION__);
+		return 1;
+	}			// return 1 ??
+*/
+
+	if (stream->cachePos) {
+		GpFileWrite(stream->handle, (char *)stream->cacheData, stream->cachePos); // flush cache
+		stream->cachePos = 0;
+	}
+
+	ERR_CODE err = GpFileClose(stream->handle);
+	free(stream);
+
+	return err;
+}
+
+int gp_fseek(GPFILE *stream, long offset, int whence) {
+	ulong dummy;
+
+	switch (whence) {
+	case SEEK_SET:
+		whence = FROM_BEGIN;
+		break;
+	case SEEK_CUR:
+		whence = FROM_CURRENT;
+		break;
+	case SEEK_END:
+		whence = FROM_END;
+		break;
+	}
+	return GpFileSeek(stream->handle, whence, offset, (long *)&dummy);
+}
+
+size_t gp_fread(void *ptr, size_t size, size_t n, GPFILE *stream) {
+	ulong readcount = 0;
+	ERR_CODE err = GpFileRead(stream->handle, ptr, size * n, &readcount); //fixme? size*n
+	return readcount / size;	//FIXME?
+}
+
+size_t gp_fwrite(const void *ptr, size_t size, size_t n, GPFILE *stream) {
+	int len = size * n;
+
+	if (!stream) {
+		//warning("writing to null file");
+		return 0;
+	}
+
+	if (stream->cachePos + len < FCACHE_SIZE) {
+		memcpy(stream->cacheData + stream->cachePos, ptr, len);
+		stream->cachePos += len;
+	} else {
+		if (stream->cachePos) {
+			GpFileWrite(stream->handle, stream->cacheData, stream->cachePos);	// flush cache
+			stream->cachePos = 0;
+		}
+
+		ERR_CODE err = GpFileWrite(stream->handle, ptr, len);
+		if (!err)
+			return n;
+		else
+			return -err;
+	}
+	return 0;
+}
+
+//FIXME? use standard func
+long gp_ftell(GPFILE *stream) {
+	ulong pos = 0;
+	ERR_CODE err = GpFileSeek(stream->handle, FROM_CURRENT, 0, (long*)&pos);
+	return pos;
+}
+
+void gp_clearerr(GPFILE *stream)
+{
+}
+
+//FIXME!
+int gp_feof(GPFILE *stream) {
+	return gp_ftell(stream) >= stream->size;
+}
+
+char gp_fgetc(GPFILE *stream) {
+	char c[1];
+
+	gp_fread(&c[0], 1, 1, stream);
+	return c[0];
+}
+
+char *gp_fgets(char *s, int n, GPFILE *stream) {
+	int i = 0;
+
+	while (!gp_feof(stream) && i < n) {
+		gp_fread(&s[i], 1, 1, stream);
+		if (s[i] == '\n') {
+			s[i + 1] = 0;
+			return s;
+		}
+		i++;
+	}
+	if (gp_feof(stream))
+		return NULL;
+	else
+		return s;
+}
+
+int gp_fprintf(GPFILE *stream, const char *fmt, ...) {
+	char s[256];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 256, fmt, marker);
+	va_end(marker);
+
+	return gp_fwrite(s, 1, strlen(s), stream);
+}
+
+int gp_fflush(GPFILE *stream) {
+	return 0;
+}
+
+int gp_ferror(GPFILE *stream) {
+	return 0;
+}
+
+/////////////////////
+//Memory management
+#undef memcpy
+#undef memset
+void *gp_memcpy(void *dst, const void *src, size_t count) {
+	return memcpy(dst, src, count);
+}
+
+void *gp_memset(void *dst, int val, size_t count) {
+	return memset(dst, val, count);
+}
+
+void *gp_malloc(size_t size) {
+	uint32 np;
+	uint32 *up;
+
+	np = (uint32) gm_malloc(size + sizeof(uint32));
+
+	if (np) {
+		up = (uint32 *) np;
+		*up = 0x1234;
+		return (void *)(np + sizeof(uint32));
+	}
+
+	return NULL;
+}
+
+void *gp_calloc(size_t nitems, size_t size) {
+	void *p = gp_malloc(nitems * size);	//gpcalloc doesnt clear?
+
+	gp_memset(p, 0, nitems * size);
+
+//	if (*(uint8 *)p != 0)
+//		warning("%s: calloc doesn't clear!", __FUNCTION__);	//fixme: was error
+
+	return p;
+}
+
+void gp_free(void *block) {
+	uint32 np;
+	uint32 *up;
+
+	if (!block) {
+		return;
+	}
+
+	np = ((uint32) block) - sizeof(uint32);
+	up = (uint32 *) np;
+	if (*up == 0x4321) {
+		warning("%s: double deallocation!", __FUNCTION__);
+		return;
+	}
+
+	if (*up != 0x1234) {
+		warning("%s: corrupt block!", __FUNCTION__);
+		return;
+	}
+	*up = 0x4321;
+
+	gm_free(up);
+}
+
+//////////////////////////////////////////////////
+// GP32 stuff
+//////////////////////////////////////////////////
+void *operator new(size_t size) {
+//	printf("BP:operator new(%d)", size);
+	return memset(malloc(size), 0xE7, size);
+}
+
+void operator delete(void *ptr) {
+//	printf("operator delete(%x)", ptr);
+	free(ptr);
+}
+
+////////////////////
+//String functions
+char *gp_strcpy(char *dst, const char *src) {
+	char *pDst = dst;
+
+	while (*pDst++ = *src++)
+		;
+
+	return dst;
+}
+
+char *gp_strncpy(char *dst, const char *src, size_t count) {
+	char *start = dst;
+
+	while (count && (*dst++ = *src++))
+		count--;
+
+	if (count)
+		while (--count)
+			*dst++ = '\0';
+
+	return start;
+}
+
+char *gp_strcat(char *dst, const char *src) {
+	char *pDst = dst;
+
+	while (*pDst)
+		pDst++;
+
+	while (*pDst++ = *src++)
+		;
+
+	return dst;
+
+}
+
+char *gp_strdup(const char *str) {
+        char *memory;
+
+        if (!str)
+                return NULL;
+
+        if (memory = (char *)malloc(strlen(str) + 1))
+                return gp_strcpy(memory, str);
+
+        return NULL;
+}
+
+int gp_strcasecmp(const char *dst, const char *src) {
+	int f, l;
+	do {
+		f = tolower((unsigned char)(*(dst++)));
+		l = tolower((unsigned char)(*(src++)));
+	} while (f && (f == l));
+
+	return f - l;
+}
+
+int gp_strncasecmp(const char *dst, const char *src, size_t count) {
+	int f,l;
+
+	if (count) {
+		do {
+			f = tolower((unsigned char)(*(dst++)));
+			l = tolower((unsigned char)(*(src++)));
+		} while (--count && f && (f == l));
+		return f - l;
+	}
+
+	return 0;
+}
+
+//FIXME: Handle LONG string
+void gp_sprintf(char *str, const char *fmt, ...) {
+	char s[512];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 512, fmt, marker);
+	va_end(marker);
+
+	gp_strcpy(str, s);
+}
+
+int gp_printf(const char *fmt, ...) {
+	char s[256];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 256, fmt, marker);
+	va_end(marker);
+
+	_dprintf("%s", s);
+	//gp_delay(100);
+	return 0;
+}
+
+void gp_delay(uint32 msecs) {
+	int startTime = GpTickCountGet();
+	while (GpTickCountGet() < startTime + msecs);
+}
+
+void gp_exit(int code) {
+	if (!code) {
+		printf("  ----------------------------------------");
+		printf("       Your GP32 is now restarting...     ");
+		printf("  ----------------------------------------");
+		printf("");
+
+		gp_delay(3000);
+
+		GpAppExit();
+	} else {
+		printf("Exit Code %d", code);
+		while (1);
+	}
+}
+
+// Debug functions
+void GPDEBUG(const char *fmt, ...) {
+	char s[256];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 256, fmt, marker);
+	va_end(marker);
+
+	_dprintf("%s", s);
+}
+
+void NP(const char *fmt, ...) {
+	return;
+	char s[256];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 256, fmt, marker);
+	va_end(marker);
+
+	_dprintf("NP:%s", s);
+	//gp_delay(50);
+}
+
+void LP(const char *fmt, ...) {
+	return;
+	char s[256];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 256, fmt, marker);
+	va_end(marker);
+
+	_dprintf("LP:%s", s);
+	//gp_delay(300);
+}
+
+void SP(const char *fmt, ...) {
+	return;
+	char s[256];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 256, fmt, marker);
+	va_end(marker);
+
+	_dprintf("SP:%s", s);
+	//gp_delay(50);
+}
+
+void BP(const char *fmt, ...) {
+	return;
+	char s[256];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsnprintf(s, 256, fmt, marker);
+	va_end(marker);
+
+	_dprintf("BP:%s", s);
+	//gp_delay(2000);
+}
diff --git a/backends/gp32/gp32std.h b/backends/gp32/gp32std.h
new file mode 100644
index 0000000000..8be7abf1bb
--- /dev/null
+++ b/backends/gp32/gp32std.h
@@ -0,0 +1,92 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifndef __GP32STD_H
+#define __GP32STD_H
+
+#include <gpfont.h>
+#include <gpfont_port.h>
+#include <gpgraphic.h>
+#include <gpmm.h>
+#include <gpmem.h>
+#include <gpos_def.h>
+#include <gpstdio.h>
+#include <gpstdlib.h>
+#include <gpdef.h>
+
+#define LCD_WIDTH 320
+#define LCD_HEIGHT 240
+
+#define FCACHE_SIZE 8 * 1024	// speed up writes
+
+typedef struct {
+	F_HANDLE handle;
+	unsigned long size;
+	unsigned long cachePos;		//cache position
+	unsigned char cacheData[FCACHE_SIZE];
+} GPFILE;
+
+extern GPFILE *gp_stderr;
+extern GPFILE *gp_stdout;
+extern GPFILE *gp_stdin;
+
+extern GPFILE *	gp_fopen(const char *filename, const char *mode);
+extern int		gp_fclose(GPFILE *stream);
+extern int		gp_fseek(GPFILE *stream, long offset, int whence);
+extern size_t	gp_fread(void *ptr, size_t size, size_t n, GPFILE *stream);
+extern size_t	gp_fwrite(const void *ptr, size_t size, size_t n, GPFILE *stream);
+extern long		gp_ftell(GPFILE *stream);
+extern void		gp_clearerr(GPFILE *stream);
+extern int		gp_feof(GPFILE *stream);
+extern char		gp_fgetc(GPFILE *stream);
+extern char *	gp_fgets(char *s, int n, GPFILE *stream);
+extern int		gp_fflush(GPFILE *stream);
+extern int		gp_ferror(GPFILE *stream);
+extern int		gp_fprintf(GPFILE *stream, const char *fmt, ...);
+
+extern char *	gp_strcpy(char *dst, const char *src);
+extern char *	gp_strncpy(char *dst, const char *src, size_t count);
+extern char *	gp_strcat(char *dst, const char *src);
+extern char *	gp_strdup(const char *str);
+extern int		gp_strcasecmp(const char *dst, const char *src);
+extern int		gp_strncasecmp(const char *dst, const char *src, size_t count);
+extern void		gp_sprintf(char *str, const char *fmt, ...);
+
+extern void *	gp_memcpy(void *dst, const void *src, size_t count);
+extern void *	gp_memset(void *dst, int val, size_t count);
+extern void *	gp_malloc(size_t size);
+extern void *	gp_calloc(size_t nitems, size_t size);
+extern void 	gp_free(void *block);
+
+extern int		gp_printf(const char *fmt, ...);
+extern void		gp_delay(unsigned long msecs);
+extern void		gp_exit(int code);
+
+extern void GPDEBUG(const char *fmt, ...);
+extern void LP(const char *fmt, ...);
+extern void NP(const char *fmt, ...);
+extern void SP(const char *fmt, ...);
+extern void BP(const char *fmt, ...);
+
+#endif
diff --git a/backends/gp32/gp32std_grap.cpp b/backends/gp32/gp32std_grap.cpp
new file mode 100644
index 0000000000..63eb3862d1
--- /dev/null
+++ b/backends/gp32/gp32std_grap.cpp
@@ -0,0 +1,133 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "backends/intern.h"
+
+#include "backends/gp32/gp32std.h"
+#include "backends/gp32/gp32std_grap.h"
+
+#include "backends/gp32/gp32_launcher.h"
+
+GPDRAWSURFACE lcdSurface[2];
+
+uint8 flipIndex = 1;
+
+uint16 *frameBuffer1;
+uint16 *frameBuffer2;
+
+extern const unsigned char fontresEng1[];
+extern const unsigned char fontresKor1[];
+
+void gp_putBitmap8x16(uint16 *frameBuffer, int x, int y, byte *lpBitmap, uint16 wColor) {
+	byte *pBitmap  = lpBitmap;
+	for (int nRow = 0; nRow < 12; nRow ++) {
+		byte data = *pBitmap++;
+		for (int nCol = 0; nCol < 7; nCol ++) {
+			if (data & 0x80)
+				gpd_drawPixel16(frameBuffer, x + nCol, y + nRow, wColor);
+
+			data <<= 1;
+		}
+	}
+}
+
+void gp_putEngFont(uint16 *frameBuffer, int x, int y, char c, uint16 wColor) {
+	byte *pBitmap = (byte *) &fontresEng1[c * 16];
+	gp_putBitmap8x16(frameBuffer, x, y, pBitmap, wColor);
+}
+
+void gp_textOut(uint16 *frameBuffer, int x, int y, char* lpszText, uint16 wColor) {
+	// TODO: Handle korean font
+	int nPos = x;
+	char* pszText = lpszText;
+
+	while (*pszText != '\0') {
+		if (*pszText == '\n') {
+			nPos = x;
+			y += 8;
+		} else {
+			gp_putEngFont(frameBuffer, nPos, y, *pszText, wColor);
+			nPos += 7;
+		}
+
+		pszText++;
+	}
+}
+
+void gp_fillRect(uint16 *frameBuffer, int16 x, int16 y, int16 w, int16 h, uint16 color) {
+	uint16 *buffer = &frameBuffer[(240 - (y + h)) + (240 * x)];
+	for (int i = 0; i < w; i++) {
+		for (int j = 0; j < h; j++) {
+			*buffer++ = color;
+		}
+		buffer += 240 - h;
+	}
+}
+
+uint16 gp_RGBTo16(uint16 r, uint16 g, uint16 b) {
+	// GP32 16bit color 5551
+	if(g_gammaRamp != 100) {
+		r *= ((float)g_gammaRamp / 100);
+		g *= ((float)g_gammaRamp / 100);
+		b *= ((float)g_gammaRamp / 100);
+		r = r >= 255 ? 255 : r;
+		g = g >= 255 ? 255 : g;
+		b = b >= 255 ? 255 : b;
+	}
+	return (((r >> 3) & 0x1F) << 11) | (((g >> 3) & 0x1F) << 6) | ((b >> 3) & 0x1F) << 1;
+}
+
+void gp_16ToRGB(uint16 color, uint8 *r, uint8 *g, uint8 *b) {
+	*r = ((((color) >> 11) & 0x1F) << 3);
+	*g = ((((color) >> 6) & 0x1F) << 3);	//(((color>>5)&0x3F) << 2);
+	*b = ((((color) >> 1) & 0x1F) << 3);	//((color&0x1F) << 3);
+
+	if(g_gammaRamp != 100) {
+		*r /= ((float)g_gammaRamp / 100);
+		*g /= ((float)g_gammaRamp / 100);
+		*b /= ((float)g_gammaRamp / 100);
+	}
+}
+
+void gp_flipScreen() {
+	uint16 *frameBuffer1_old = frameBuffer1;
+	uint16 *frameBuffer2_old = frameBuffer2;
+
+	GpSurfaceFlip(&lcdSurface[flipIndex]);
+	flipIndex = 1 - flipIndex;
+	frameBuffer1 = frameBuffer2_old;
+	frameBuffer2 = frameBuffer1_old;
+}
+
+void gp_initFrameBuffer() {
+	GpLcdSurfaceGet(&lcdSurface[0], 0);
+	GpLcdSurfaceGet(&lcdSurface[1], 1);
+	GpSurfaceSet(&lcdSurface[0]);
+	frameBuffer1 = (uint16 *)lcdSurface[0].ptbuffer;
+	frameBuffer2 = (uint16 *)lcdSurface[1].ptbuffer;
+
+	memset(frameBuffer1, 0xFF, LCD_WIDTH * LCD_HEIGHT * sizeof(uint16));
+	memset(frameBuffer2, 0xFF, LCD_WIDTH * LCD_HEIGHT * sizeof(uint16));
+}
diff --git a/backends/gp32/startup.h b/backends/gp32/gp32std_grap.h
index bea53a0233..cf42cebcf3 100644
--- a/backends/gp32/startup.h
+++ b/backends/gp32/gp32std_grap.h
@@ -1,8 +1,8 @@
 /* ScummVM - Scumm Interpreter
- * Copyright (C) 2001  Ludvig Strigeus
- * Copyright (C) 2001/2004 The ScummVM project
+ * Copyright (C) 2001-2005 The ScummVM project
  * Copyright (C) 2002 Ph0x - GP32 Backend
  * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -22,28 +22,24 @@
  *
  */
 
-#ifndef STARTUP_H
-#define STARTUP_H
+#ifndef __GP32STD_GRAP_H
+#define __GP32STD_GRAP_H
 
-/////////////////////////////////////////////////////////////////////////////
-//
-// ScummVM/GP32 - GP32 start-up header.
-//                Not part of ScummVM backend as such.
-//
-/////////////////////////////////////////////////////////////////////////////
+extern GPDRAWSURFACE lcdSurface[2];
+extern uint8 flipIndex;
 
-//	GP32 SDK Includes.
-#include <gpdef.h>
-#include <gpstdlib.h>
-#include <gpfont.h>
-#include <gpfont_port.h>
-#include <gpfontres.dat>
-#include <initval_port.h>
+extern uint16 *frameBuffer1;
+extern uint16 *frameBuffer2;
 
-//	GP32 System startup.
+extern void gp_fillRect(uint16 *frameBuffer, int16 x, int16 y, int16 w, int16 h, uint16 color);
+extern uint16 gp_RGBTo16(uint16 r, uint16 g, uint16 b);
+extern void gp_16ToRGB(uint16 color, uint8 *r, uint8 *g, uint8 *b);
 
-unsigned int HEAPSTART;
-unsigned int HEAPEND;
-void InitializeFont (void);
+extern void gp_textOut(uint16 *frameBuffer, int x, int y, char* lpszText, uint16 wColor);
 
-#endif /* STARTUP_H */
+extern void gp_initFrameBuffer();
+extern void gp_flipScreen();
+
+#define gpd_drawPixel16(dst,x,y,color) (dst)[(239 - (y)) + (240 * (x))] = (color)
+
+#endif
diff --git a/backends/gp32/gp32std_input.cpp b/backends/gp32/gp32std_input.cpp
new file mode 100644
index 0000000000..5a1ffcc0f9
--- /dev/null
+++ b/backends/gp32/gp32std_input.cpp
@@ -0,0 +1,210 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+
+#include "backends/gp32/gp32std.h"
+#include "backends/gp32/gp32std_input.h"
+
+static uint32 buttonState = 0;
+static uint16 buttonPressState = 0;
+
+#define GET_BUTTON_PRESSED(a) (buttonPressState & (a))
+#define ON_BUTTON_PRESSED(a)  (buttonPressState |= (a))
+#define OFF_BUTTON_PRESSED(a) (buttonPressState &= ~(a))
+
+#define GET_BUTTON_DOWN(a) (buttonState & (a) << 12)
+#define ON_BUTTON_DOWN(a)  buttonState |= ((a) << 12)
+#define OFF_BUTTON_DOWN(a) buttonState &= ~((a) << 12)
+
+#define GET_BUTTON_UP(a)   (buttonState & (a))
+#define ON_BUTTON_UP(a)    buttonState |= (a)
+#define OFF_BUTTON_UP(a)   buttonState &= ~(a)
+
+#define rKEY_A          0x4000
+#define rKEY_B          0x2000
+#define rKEY_L          0x1000
+#define rKEY_R          0x8000
+#define rKEY_UP         0x0800
+#define rKEY_DOWN       0x0200
+#define rKEY_LEFT       0x0100
+#define rKEY_RIGHT      0x0400
+#define rKEY_START      0x0040
+#define rKEY_SELECT     0x0080
+#define rPBDAT          (*(volatile unsigned *)0x1560000c)
+#define rPEDAT          (*(volatile unsigned *)0x15600030)
+
+/****************************************************************
+    GP32 Input mappings - Returns Button Pressed.
+****************************************************************/
+int gp_trapKey() {
+	int value = 0;
+
+	unsigned long gpb = rPBDAT;	// 0x156
+	unsigned long gpe = rPEDAT;
+
+	if ((gpb & rKEY_LEFT) == 0)
+		value |= GPC_VK_LEFT;
+	if ((gpb & rKEY_RIGHT) == 0)
+		value |= GPC_VK_RIGHT;
+	if ((gpb & rKEY_UP) == 0)
+		value |= GPC_VK_UP;
+	if ((gpb & rKEY_DOWN) == 0)
+		value |= GPC_VK_DOWN;
+	if ((gpb & rKEY_A) == 0)
+		value |= GPC_VK_FA;
+	if ((gpb & rKEY_B) == 0)
+		value |= GPC_VK_FB;
+	if ((gpb & rKEY_L) == 0)
+		value |= GPC_VK_FL;
+	if ((gpb & rKEY_R) == 0)
+		value |= GPC_VK_FR;
+	if ((gpe & rKEY_SELECT) == 0)
+		value |= GPC_VK_SELECT;
+	if ((gpe & rKEY_START) == 0)
+		value |= GPC_VK_START;
+
+	return value;
+}
+
+bool gp_getButtonEvent(uint32 *nKeyUD, uint16 *nKeyP) {
+//	int nKey = GpKeyGet();
+	int nKey = gp_trapKey();
+
+	const int keyBitMask[10] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200};
+
+	for (int i = 0; i < 10; i++) {
+		OFF_BUTTON_DOWN(keyBitMask[i]);
+		OFF_BUTTON_UP(keyBitMask[i]);
+		if (nKey & keyBitMask[i]) {
+			if (!GET_BUTTON_PRESSED(keyBitMask[i])) {
+//				GPDEBUG("DOWN %d", i);
+				ON_BUTTON_PRESSED(keyBitMask[i]);
+				ON_BUTTON_DOWN(keyBitMask[i]);
+			}
+		} else {
+			if (GET_BUTTON_PRESSED(keyBitMask[i])) {
+//				GPDEBUG("UP %d", i);
+				OFF_BUTTON_PRESSED(keyBitMask[i]);
+				ON_BUTTON_UP(keyBitMask[i]);
+			}
+		}
+	}
+
+//	GPDEBUG("%08x %04x", buttonState, buttonPressState);
+	*nKeyUD = buttonState;
+	*nKeyP = buttonPressState;
+	return true;
+}
+
+#define MAX_EVENTS 32
+
+struct EventQueue {
+protected:
+	int front, rear;
+	int numElement;
+	GP32BtnEvent event[MAX_EVENTS];
+
+public:
+	void push(GP32BtnEvent *ev) {
+		if ((rear + 1) % MAX_EVENTS == front) {
+			GPDEBUG("Queue Overflow!");
+			return;
+		}
+		numElement++;
+
+		event[rear].type = ev->type;
+		event[rear].button = ev->button;
+		rear = (rear + 1) % MAX_EVENTS;
+	}
+
+	bool isEmpty() {
+		return (numElement == 0);
+	}
+
+	bool isFull() {
+		return (numElement == MAX_EVENTS);
+	}
+
+	bool get(GP32BtnEvent *ev) { 
+		if (front == rear) {
+			return false;
+		}
+		numElement--;
+		ev->type = event[front].type;
+		ev->button = event[front].button;
+		front = (front + 1) % MAX_EVENTS;
+		return true;
+	}
+};
+
+EventQueue eventQueue;
+
+bool gp_pumpButtonEvent() {
+	int nKey = gp_trapKey();
+	GP32BtnEvent ev;
+
+	const int keyBitMask[10] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200};
+
+	for (int i = 0; i < 10; i++) {
+		if (nKey & keyBitMask[i]) {
+			if (!GET_BUTTON_PRESSED(keyBitMask[i])) {
+				ON_BUTTON_PRESSED(keyBitMask[i]);
+				ev.type = BUTTON_DOWN;
+				ev.button = keyBitMask[i];
+				eventQueue.push(&ev);
+				//ON_BUTTON_DOWN(keyBitMask[i]);
+			}
+		} else {
+			if (GET_BUTTON_PRESSED(keyBitMask[i])) {
+				OFF_BUTTON_PRESSED(keyBitMask[i]);
+				ev.type = BUTTON_UP;
+				ev.button = keyBitMask[i];
+				eventQueue.push(&ev);
+				//ON_BUTTON_UP(keyBitMask[i]);
+			}
+		}
+	}
+
+	return true;
+}
+
+bool gp_pollButtonEvent(GP32BtnEvent *ev) {
+	gp_pumpButtonEvent();
+
+	if(eventQueue.isEmpty()) {
+		return false;
+	}
+
+	eventQueue.get(ev);
+//	GPDEBUG("Event poll %d %d", ev->type, ev->button);
+
+	return true;
+}
+
+bool gp_getButtonPressed(uint16 button)
+{
+	return buttonPressState & button;
+}
diff --git a/backends/gp32/gp32std_input.h b/backends/gp32/gp32std_input.h
new file mode 100644
index 0000000000..4aa300af3d
--- /dev/null
+++ b/backends/gp32/gp32std_input.h
@@ -0,0 +1,51 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifndef __GP32STD_INPUT_H
+#define __GP32STD_INPUT_H
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+
+#define BUTTON_DOWN 1
+#define BUTTON_UP 2
+
+struct GP32BtnEvent {
+	uint16 type;
+	uint16 button;
+};
+
+extern int gp_trapKey();
+
+extern bool gp_getButtonEvent(uint32 *nKeyUD, uint16 *nKeyP);
+
+#define gpd_getEventDown(a) (((a) >> 12) & 0x0fff)
+#define gpd_getEventUp(a) ((a) & 0x0fff)
+#define gpd_getEventPressed(a) ((a) & 0x0fff)
+#define gpd_getButtonDown(a,button) ((a) & (button) << 12)
+#define gpd_getButtonUp(a,button)   ((a) & (button))
+#define gpd_getButtonPressed(a,button)   ((a) & (button))
+
+extern bool gp_pollButtonEvent(GP32BtnEvent *ev);
+extern bool gp_getButtonPressed(uint16 button);
+
+#endif
diff --git a/backends/gp32/gp32std_sound.cpp b/backends/gp32/gp32std_sound.cpp
new file mode 100644
index 0000000000..2bef7aac3a
--- /dev/null
+++ b/backends/gp32/gp32std_sound.cpp
@@ -0,0 +1,107 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+
+#include "gp32std.h"
+#include "gp32std_sound.h"
+
+#define GP32_TIMER_AUDIO_IDX 0
+
+// Global variables
+static volatile unsigned int frame = 0;
+static volatile unsigned int *soundPos = 0;
+static volatile int idx_buf;
+static volatile unsigned int shiftVal = 0;
+static void *buffer;
+static GPSOUNDBUF soundBuf;
+
+// This routine gets called by the timer interrupt and
+// polls the current playing position within the buffer.
+
+static void soundTimer() {
+	unsigned int t = (((unsigned int)(*soundPos) - (unsigned int)buffer) >> shiftVal) >= soundBuf.samples ? 1 : 0;
+	if (t != frame) {
+		unsigned int offs = ((frame == 1) ? (soundBuf.samples << shiftVal) : 0);
+		soundBuf.callback(soundBuf.userdata, (uint8 *)((unsigned int)buffer + offs), soundBuf.samples << shiftVal);
+		frame = t;
+	}
+}
+
+int gp_soundBufStart(GPSOUNDBUF *sb) {
+	int bufferSize = 0;
+	frame = 0;
+
+	// Copy the structure
+	memcpy(&soundBuf, sb, sizeof(GPSOUNDBUF));
+
+	// Calculate size of a single sample in bytes
+	// and a corresponding shift value
+	shiftVal = 0;
+	switch (soundBuf.freq) {
+	case PCM_S11:
+		break;
+	case PCM_S22:
+		break;
+	case PCM_S44:
+		shiftVal++;
+		break;
+	case PCM_M11:
+		break;
+	case PCM_M22:
+		break;
+	case PCM_M44:
+		shiftVal++;
+		break;
+	}
+	if (soundBuf.format == PCM_16BIT)
+		shiftVal++;
+	soundBuf.samplesize = 1 << shiftVal;
+
+	// Allocate memory for the playing buffer
+	bufferSize = soundBuf.samplesize * soundBuf.samples * 2;
+	buffer = malloc(bufferSize);
+	memset(buffer, 0, bufferSize);
+
+	// Set timer interrupt
+	if (GpTimerOptSet(GP32_TIMER_AUDIO_IDX, soundBuf.pollfreq, 0, soundTimer) == GPOS_ERR_ALREADY_USED) {
+		NP(" Timer is already used... kill timer");
+		GpTimerKill(GP32_TIMER_AUDIO_IDX);
+	}
+	GpTimerSet(GP32_TIMER_AUDIO_IDX);
+	// Start playing
+    GpPcmInit(soundBuf.freq, soundBuf.format);
+	GpPcmPlay((unsigned short *)buffer, bufferSize, 1);
+	GpPcmLock((unsigned short *)buffer, (int *)&idx_buf, (unsigned int *)&soundPos);
+
+	return 0;
+}
+
+void gp_soundBufStop() {
+	GpPcmStop();
+	GpPcmRemove((unsigned short *)buffer);
+	GpTimerKill(GP32_TIMER_AUDIO_IDX);
+	free(buffer);
+}
diff --git a/backends/gp32/gp32std_sound.h b/backends/gp32/gp32std_sound.h
new file mode 100644
index 0000000000..90613029a2
--- /dev/null
+++ b/backends/gp32/gp32std_sound.h
@@ -0,0 +1,45 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2002 Ph0x - GP32 Backend
+ * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifndef __GP32STD_SOUND_H
+#define __GP32STD_SOUND_H
+
+// GPSOUNDBUF.userdata / Pointer to the buffer which needs to be refilled / Length of the buffer in bytes
+typedef void SoundProc(void *param, byte *buf, int len);
+
+typedef struct TGPSOUNDBUF {
+    PCM_SR freq;              // Taken from gpmm.h
+    PCM_BIT format;           // Taken from gpmm.h
+    unsigned int samples;     // Buffer length (in samples)
+    void *userdata;           // Userdata which gets passed to the callback function
+    SoundProc *callback;      // Callback function (just like in SDL)
+    unsigned int pollfreq;    // Frequency of the timer interrupt which polls the playing position
+                              // recommended value: 2*(playingfreq in Hz/GPSOUNDBUF.samples)
+    unsigned int samplesize;  // Size of one sample (8bit mono->1, 16bit stereo->4) - don't touch this
+} GPSOUNDBUF;
+
+int gp_soundBufStart(GPSOUNDBUF *sb);
+void gp_soundBufStop();
+
+#endif
diff --git a/backends/gp32/gp_asmlib.s b/backends/gp32/gp_asmlib.s
new file mode 100644
index 0000000000..f00f39a573
--- /dev/null
+++ b/backends/gp32/gp_asmlib.s
@@ -0,0 +1,393 @@
+	.ALIGN
+@	.ARM
+
+	.GLOBAL		cpu_speed
+	.GLOBAL		mmu_change
+
+cpu_speed:
+	stmdb	r13!, {r0-r12,lr}
+	stmdb	sp!, {r0, r1, r2}
+	mov		r0, sp
+	swi		#0x0d
+	add		sp, sp, #12
+	ldmia	r13!, {r0-r12,lr}
+	bx		lr
+	nop
+
+mmu_change:
+        stmdb   r13!, {r0-r12,lr}
+        swi             #0x02
+        ldmia   r13!, {r0-r12,lr}
+        bx              lr
+        nop
+
+@ ******** ASMFastSolidBlit(unsigned char *src4, unsigned char *dst4, int nbx, int nby, int height2, int trans, int coul) ********
+
+	.ALIGN
+	.GLOBAL ASMFastSolidBlit
+	.TYPE   ASMFastSolidBlit, function
+	.CODE 32
+
+@r0 = src4
+@r1 = dst4
+@r2 = nbx
+@r3 = nby
+
+@r4 = height2
+@r5 = trans
+@r6 = coul
+@r7 = tmp
+@r8 = tmpnby
+@r9 = tmp2
+
+_bx7:
+	ldrb		r8,[r0,+r3]		@lecture 1er pixel
+	subs		r7,r3,#1
+	bmi		_sauty2
+
+_sauty2:					@ecriture r8
+	TEQ		r8,r5
+	STRNEB	r8,[r1,+r7]
+	SUB		r0,r0,r4
+	SUB		r1,r1,#240
+	SUBS		r2,r2,#1
+	BPL		_bx7
+
+        ldmfd		r13!,{r4-r8}
+	add		sp,sp,#8
+	bx		lr
+
+ASMFastSolidBlit:
+
+	sub		sp,sp,#12
+        stmfd		r13!,{r4-r9}
+        ldr		r4,[r13,#36]
+        ldr		r5,[r13,#40]
+        ldr		r6,[r13,#44]
+
+_bx8:
+	ldrb		r9,[r0,+r3]		@lecture 1er pixel
+	subs		r8,r3,#1
+	bmi		_sauty2
+
+_by8:
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3
+	LDRB		r7,[r0,+r8]
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+	BMI		_sauty3b
+	LDRB		r9,[r0,+r8]
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUBS		r8,r8,#1
+
+	BPL		_by8
+
+_sauty3:					@ecriture pour r9
+	TEQ		r9,r5
+	STRNEB	r6,[r1,+r8]
+	SUB		r0,r0,r4
+	SUB		r1,r1,#240
+	SUBS		r2,r2,#1
+	BPL		_bx8
+
+        ldmfd		r13!,{r4-r9}
+	add		sp,sp,#12
+	bx		lr
+
+_sauty3b:					@ecriture pour r7
+	TEQ		r7,r5
+	STRNEB	r6,[r1,+r8]
+	SUB		r0,r0,r4
+	SUB		r1,r1,#240
+	SUBS		r2,r2,#1
+	BPL		_bx8
+
+        ldmfd		r13!,{r4-r9}
+	add		sp,sp,#12
+	bx		lr
+
+
+@ ******** ASMSaveBitmap(unsigned char *src4, unsigned char *dst, int nbx, int nby, int height2) ********
+
+	.ALIGN
+	.GLOBAL ASMSaveBitmap
+	.TYPE   ASMSaveBitmap, function
+	.CODE 32
+
+@r0 = src4
+@r1 = dst + 1
+@r2 = nbx
+@r3 = nby
+
+@r7 = height2
+@r8 = tmp
+@r9 = tmpnby
+@r10 = dst4
+
+ASMSaveBitmap:
+
+	sub		sp,sp,#4
+        stmfd		r13!,{r7-r10}
+        LDR		r7,[r13,#20]
+
+_bx6:
+	MLA		r10,r2,r7,r1
+	MOV		r9,r3
+
+_by6:
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+	BMI		_fincol6
+	LDRB		r8,[r0,+r9]
+	SUBS		r9,r9,#1
+	STRB		r8,[r10,+r9]
+
+	BPL		_by6
+
+_fincol6:
+	SUB		r0,r0,#240
+	SUBS		r2,r2,#1
+	BPL		_bx6
+
+        ldmfd		r13!,{r7-r10}
+	add		sp,sp,#4
+	bx		lr
+
+
+	.ALIGN
+	.GLOBAL gp_clearFramebuffer
+	.TYPE   gp_clearFramebuffer, function
+	.CODE 32
+gp_clearFramebuffer:
+        @ r0 = framebuffer
+        @ r1 = color
+        orr r1,r1,r1,lsl #16   @hi halfword = lo halfword  
+        mov r2,#38400
+clear:  str  r1,[r0],#4
+        subs r2,r2,#1
+        bne clear
+        bx lr
+
+
+@ ******** ASMFastClear(unsigned char *dst4, int nbx, int nby) ********
+
+	.ALIGN
+	.GLOBAL ASMFastClear
+	.TYPE   ASMFastClear, function
+	.CODE 32
+
+@r0 = dst4
+@r1 = nbx
+@r2 = nby
+
+@r3 = #0
+@r4 = tmpnby
+
+@optimis?pour h=20
+
+ASMFastClear:
+
+	str		r4,[sp,#-4]!
+	MOV		r3,#0
+
+_bx9:
+	MOV		r4,r2
+
+_by9:
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+	BMI		_sauty4
+	STRB		r3,[r0,+r4]
+	SUBS		r4,r4,#1
+
+	BPL		_by9
+
+_sauty4:
+	SUB		r0,r0,#240
+	SUBS		r1,r1,#1
+	BPL		_bx9
+
+	ldr		r4,[sp],#4
+	bx		lr
diff --git a/backends/gp32/gp_clipped.c b/backends/gp32/gp_clipped.c
new file mode 100644
index 0000000000..d3e161c470
--- /dev/null
+++ b/backends/gp32/gp_clipped.c
@@ -0,0 +1,100 @@
+/* ScummVM - Scumm Interpreter
+ * GP32 Blitting library
+ * Copyright (C) 2001-2005 The ScummVM project
+ * Copyright (C) 2003,2004,2005  CARTIER Matthieu
+ * Copyright (C) 2005 Won Star - GP32 Backend
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $Header$
+ *
+ */
+
+//Some global variables and macros
+
+#define	screen_width	320
+#define	screen_height	240
+
+void gp_FastSolidBlit(void *framebuffer, int dx, const int dy, const int width, const int height, const unsigned char *src, const int trans, const int coul) {
+	int xmin, ymin, xmax, ymax;
+	int height2 = ( (height + 3) >> 2) << 2;
+
+	if(dx < 0) {
+		xmin = -dx;
+	} else xmin = 0;
+	if( (dx++ + width) > screen_width) {
+		xmax = screen_width - dx;
+	} else xmax = width - 1;
+	if(dy < 0) {
+		ymax = height + dy - 1;
+	} else ymax = height - 1;
+	if( (dy + height) > screen_height) {
+		ymin = dy + height - screen_height;
+	} else ymin = 0;
+	if( (xmin > xmax) || (ymin > ymax) ) return;
+
+	unsigned char *dst4 = framebuffer + (dx + xmax) * screen_height - height - dy + 1 + ymin;
+	src += (xmax * height2 + ymin);
+	ASMFastSolidBlit(src, dst4, xmax - xmin, ymax - ymin, height2, trans, coul);
+}
+
+//Copy from framebuffer to dest
+void gp_SaveBitmap(void *framebuffer, int dx, const int dy, const int width, const int height, const unsigned char *dest) { //Sur l'icran
+	int xmin, ymin, xmax, ymax;
+	int height2 = ( (height + 3) >> 2) << 2;
+
+	if(dx < 0) {
+		xmin = -dx;
+	} else xmin = 0;
+	if( (dx++ + width) > screen_width) {
+		xmax = screen_width - dx;
+	} else xmax = width - 1;
+	if(dy < 0) {
+		ymax = height + dy - 1;
+	} else ymax = height - 1;
+	if( (dy + height) > screen_height) {
+		ymin = dy + height - screen_height;
+	} else ymin = 0;
+	if( (xmin > xmax) || (ymin > ymax) ) return;
+
+	unsigned char *src4 = framebuffer + (dx + xmax) * screen_height - height - dy + ymin;
+	dest += (xmin * height2 + ymin + 1);
+	ASMSaveBitmap(src4, dest, xmax - xmin, ymax - ymin, height2);
+}
+
+//Clears area with color #0, should not trigger clicky noise
+
+void gp_FastClear(void *framebuffer, int dx, int dy, int width, int height) {
+	int xmin, ymin, xmax, ymax;
+
+	if(dx < 0) {
+		xmin = -dx;
+	} else xmin = 0;
+	if( (dx++ + width) > screen_width) {
+		xmax = screen_width - dx;
+	} else xmax = width - 1;
+	if(dy < 0) {
+		ymax = height + dy - 1;
+	} else ymax = height - 1;
+	if( (dy + height) > screen_height) {
+		ymin = dy + height - screen_height;
+	} else ymin = 0;
+	if( (xmin > xmax) || (ymin > ymax) ) return;
+
+	int decaly = screen_height - height - dy;
+
+	unsigned char *dst4 = framebuffer + (dx + xmax) * screen_height - height - dy + ymin;
+	ASMFastClear(dst4, xmax - xmin, ymax - ymin);
+}
diff --git a/backends/gp32/graphics.h b/backends/gp32/graphics.h
deleted file mode 100644
index 6a6ef5c9ac..0000000000
--- a/backends/gp32/graphics.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/* ScummVM - Scumm Interpreter
- * Copyright (C) 2001  Ludvig Strigeus
- * Copyright (C) 2001/2004 The ScummVM project
- * Copyright (C) 2002 Ph0x - GP32 Backend
- * Copyright (C) 2003/2004 DJWillis - GP32 Backend
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $Header$
- *
- */
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// GP32 Graphics structure header
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef GRAPHICS_H
-#define GRAPHICS_H
-
-#define Sint16 s16
-#define Uint16 u16
-#define Uint32 u32
-#define Uint8 u8
-
-typedef struct {
-	Sint16 x, y;
-	Uint16 w, h;
-} gpRect;
-
-typedef struct {
-	Uint8 r;
-	Uint8 g;
-	Uint8 b;
-	Uint8 unused;
-} gpColor;
-
-typedef struct {
-	int       ncolors;
-	gpColor *colors;
-} gpPalette;
-
-/* Everything in the pixel format structure is read-only */
-typedef struct gpPixelFormat {
-	gpPalette *palette;
-	Uint8  BitsPerPixel;
-	Uint8  BytesPerPixel;
-	Uint8  Rloss;
-	Uint8  Gloss;
-	Uint8  Bloss;
-	Uint8  Aloss;
-	Uint8  Rshift;
-	Uint8  Gshift;
-	Uint8  Bshift;
-	Uint8  Ashift;
-	Uint32 Rmask;
-	Uint32 Gmask;
-	Uint32 Bmask;
-	Uint32 Amask;
-
-	/* RGB color key information */
-	Uint32 colorkey;
-	/* Alpha value information (per-surface alpha) */
-	Uint8  alpha;
-} gpPixelFormat;
-
-typedef struct gpSurface {
-	Uint32 flags;				/* Read-only */
-	gpPixelFormat *format;		/* Read-only */
-	int w, h;				/* Read-only */
-	Uint16 pitch;				/* Read-only */
-	void *pixels;				/* Read-write */
-	int offset;				/* Private */
-
-	/* Hardware-specific surface info */
-	struct private_hwdata *hwdata;
-
-	/* clipping information */
-	gpRect clip_rect;			/* Read-only */
-	Uint32 unused1;				/* for binary compatibility */
-
-	/* Allow recursive locks */
-	Uint32 locked;				/* Private */
-
-	/* info for fast blit mapping to other surfaces */
-	//	struct gpBlitMap *map;		/* Private */
-
-	/* format version, bumped at every change to invalidate blit maps */
-	unsigned int format_version;		/* Private */
-
-	/* Reference count -- used when freeing surface */
-	int refcount;				/* Read-mostly */
-} gpSurface;
-
-#define gpSWSurface		0x00000000
-#define gpHWSurface		0x00000001
-#define gpFullScreen	0x80000000
-
-#endif /* GRAPHICS_H */
diff --git a/backends/gp32/memcpy.S b/backends/gp32/memcpy.S
new file mode 100644
index 0000000000..1572831179
--- /dev/null
+++ b/backends/gp32/memcpy.S
@@ -0,0 +1,498 @@
+/* $NetBSD: memcpy.S,v 1.3 1997/11/22 03:27:12 mark Exp $ */
+
+/*-
+* Copyright (c) 1997 The NetBSD Foundation, Inc.
+* All rights reserved.
+*
+* This code is derived from software contributed to The NetBSD Foundation
+* by Neil A. Carson and Mark Brinicombe
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+* 1. Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright
+*    notice, this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. All advertising materials mentioning features or use of this software
+*    must display the following acknowledgement:
+* This product includes software developed by the NetBSD
+* Foundation, Inc. and its contributors.
+* 4. Neither the name of The NetBSD Foundation nor the names of its
+*    contributors may be used to endorse or promote products derived
+*    from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+* ``AS IS\'\' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+* POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* This was modified by Jay Monkman <jmonkman@smoothsmoothie.com> to
+*   save and restore r12. This is necessary for RTEMS.
+*/
+/* #include <machine/asm.h>*/
+
+#define ENTRY(_LABEL) \
+ .global _LABEL; _LABEL:
+/*
+.globl memcpy
+memcpy:
+*/
+ENTRY(memcpy)
+stmfd sp!, {r0, r12, lr}
+bl _memcpy
+ldmfd sp!, {r0, r12, pc}
+
+
+/*
+.globl memove
+memmove:
+*/
+ENTRY(memmove)
+stmfd sp!, {r0, r12, lr}
+bl _memcpy
+ldmfd sp!, {r0, r12, pc}
+
+
+
+/*
+* This is one fun bit of code ...
+* Some easy listening music is suggested while trying to understand this
+* code e.g. Iron Maiden
+*
+* For anyone attempting to understand it :
+*
+* The core code is implemented here with simple stubs for memcpy()
+* memmove() and bcopy().
+*
+* All local labels are prefixed with Lmemcpy_
+* Following the prefix a label starting f is used in the forward copy code
+* while a label using b is used in the backwards copy code
+* The source and destination addresses determine whether a forward or
+* backward copy is performed.
+* Separate bits of code are used to deal with the following situations
+* for both the forward and backwards copy.
+* unaligned source address
+* unaligned destination address
+* Separate copy routines are used to produce an optimised result for each
+* of these cases.
+* The copy code will use LDM/STM instructions to copy up to 32 bytes at
+* a time where possible.
+*
+* Note: r12 (aka ip) can be trashed during the function along with
+* r0-r3 although r0-r2 have defined uses i.e. src, dest, len through out.
+* Additional registers are preserved prior to use i.e. r4, r5 & lr
+*
+* Apologies for the state of the comments;-)
+*/
+
+
+/*
+_memcpy:
+*/
+ENTRY(_memcpy)
+/* Determine copy direction */
+cmp r1, r0
+bcc Lmemcpy_backwards
+
+moveq r0, #0   /* Quick abort for len=0 */
+moveq pc, lr
+
+stmdb sp!, {r0, lr}  /* memcpy() returns dest addr */
+subs r2, r2, #4
+blt Lmemcpy_fl4  /* less than 4 bytes */
+ands r12, r0, #3
+bne Lmemcpy_fdestul  /* oh unaligned destination addr */
+ands r12, r1, #3
+bne Lmemcpy_fsrcul  /* oh unaligned source addr */
+
+Lmemcpy_ft8:
+/* We have aligned source and destination */
+subs r2, r2, #8
+blt Lmemcpy_fl12  /* less than 12 bytes (4 from above) */
+subs r2, r2, #0x14        
+blt Lmemcpy_fl32  /* less than 32 bytes (12 from above) */
+stmdb sp!, {r4}  /* borrow r4 */
+
+/* blat 32 bytes at a time */
+/* XXX for really big copies perhaps we should use more registers */
+Lmemcpy_floop32:
+ldmia r1!, {r3, r4, r12, lr}
+stmia r0!, {r3, r4, r12, lr}
+ldmia r1!, {r3, r4, r12, lr}
+stmia r0!, {r3, r4, r12, lr}
+subs r2, r2, #0x20        
+bge Lmemcpy_floop32
+
+cmn r2, #0x10
+ldmgeia r1!, {r3, r4, r12, lr} /* blat a remaining 16 bytes */
+stmgeia r0!, {r3, r4, r12, lr}
+subge r2, r2, #0x10        
+ldmia sp!, {r4}  /* return r4 */
+
+Lmemcpy_fl32:
+adds r2, r2, #0x14        
+
+/* blat 12 bytes at a time */
+Lmemcpy_floop12:
+ldmgeia r1!, {r3, r12, lr}
+stmgeia r0!, {r3, r12, lr}
+subges r2, r2, #0x0c        
+bge Lmemcpy_floop12
+
+Lmemcpy_fl12:
+adds r2, r2, #8
+blt Lmemcpy_fl4
+
+subs r2, r2, #4
+ldrlt r3, [r1], #4
+strlt r3, [r0], #4
+ldmgeia r1!, {r3, r12}
+stmgeia r0!, {r3, r12}
+subge r2, r2, #4
+
+Lmemcpy_fl4:
+/* less than 4 bytes to go */
+adds r2, r2, #4
+ldmeqia sp!, {r0, pc}  /* done */
+
+/* copy the crud byte at a time */
+cmp r2, #2
+ldrb r3, [r1], #1
+strb r3, [r0], #1
+ldrgeb r3, [r1], #1
+strgeb r3, [r0], #1
+ldrgtb r3, [r1], #1
+strgtb r3, [r0], #1
+ldmia sp!, {r0, pc}
+
+/* erg - unaligned destination */
+Lmemcpy_fdestul:
+rsb r12, r12, #4
+cmp r12, #2
+
+/* align destination with byte copies */
+ldrb r3, [r1], #1
+strb r3, [r0], #1
+ldrgeb r3, [r1], #1
+strgeb r3, [r0], #1
+ldrgtb r3, [r1], #1
+strgtb r3, [r0], #1
+subs r2, r2, r12
+blt Lmemcpy_fl4  /* less the 4 bytes */
+
+ands r12, r1, #3
+beq Lmemcpy_ft8  /* we have an aligned source */
+
+/* erg - unaligned source */
+/* This is where it gets nasty ... */
+Lmemcpy_fsrcul:
+bic r1, r1, #3
+ldr lr, [r1], #4
+cmp r12, #2
+bgt Lmemcpy_fsrcul3
+beq Lmemcpy_fsrcul2
+cmp r2, #0x0c            
+blt Lmemcpy_fsrcul1loop4
+sub r2, r2, #0x0c        
+stmdb sp!, {r4, r5}
+
+Lmemcpy_fsrcul1loop16:
+mov r3, lr, lsr #8
+ldmia r1!, {r4, r5, r12, lr}
+orr r3, r3, r4, lsl #24
+mov r4, r4, lsr #8
+orr r4, r4, r5, lsl #24
+mov r5, r5, lsr #8
+orr r5, r5, r12, lsl #24
+mov r12, r12, lsr #8
+orr r12, r12, lr, lsl #24
+stmia r0!, {r3-r5, r12}
+subs r2, r2, #0x10        
+bge Lmemcpy_fsrcul1loop16
+ldmia sp!, {r4, r5}
+adds r2, r2, #0x0c        
+blt Lmemcpy_fsrcul1l4
+
+Lmemcpy_fsrcul1loop4:
+mov r12, lr, lsr #8
+ldr lr, [r1], #4
+orr r12, r12, lr, lsl #24
+str r12, [r0], #4
+subs r2, r2, #4
+bge Lmemcpy_fsrcul1loop4
+
+Lmemcpy_fsrcul1l4:
+sub r1, r1, #3
+b Lmemcpy_fl4
+
+Lmemcpy_fsrcul2:
+cmp r2, #0x0c            
+blt Lmemcpy_fsrcul2loop4
+sub r2, r2, #0x0c        
+stmdb sp!, {r4, r5}
+
+Lmemcpy_fsrcul2loop16:
+mov r3, lr, lsr #16
+ldmia r1!, {r4, r5, r12, lr}
+orr r3, r3, r4, lsl #16
+mov r4, r4, lsr #16
+orr r4, r4, r5, lsl #16
+mov r5, r5, lsr #16
+orr r5, r5, r12, lsl #16
+mov r12, r12, lsr #16
+orr r12, r12, lr, lsl #16
+stmia r0!, {r3-r5, r12}
+subs r2, r2, #0x10        
+bge Lmemcpy_fsrcul2loop16
+ldmia sp!, {r4, r5}
+adds r2, r2, #0x0c        
+blt Lmemcpy_fsrcul2l4
+
+Lmemcpy_fsrcul2loop4:
+mov r12, lr, lsr #16
+ldr lr, [r1], #4
+orr r12, r12, lr, lsl #16
+str r12, [r0], #4
+subs r2, r2, #4
+bge Lmemcpy_fsrcul2loop4
+
+Lmemcpy_fsrcul2l4:
+sub r1, r1, #2
+b Lmemcpy_fl4
+
+Lmemcpy_fsrcul3:
+cmp r2, #0x0c            
+blt Lmemcpy_fsrcul3loop4
+sub r2, r2, #0x0c        
+stmdb sp!, {r4, r5}
+
+Lmemcpy_fsrcul3loop16:
+mov r3, lr, lsr #24
+ldmia r1!, {r4, r5, r12, lr}
+orr r3, r3, r4, lsl #8
+mov r4, r4, lsr #24
+orr r4, r4, r5, lsl #8
+mov r5, r5, lsr #24
+orr r5, r5, r12, lsl #8
+mov r12, r12, lsr #24
+orr r12, r12, lr, lsl #8
+stmia r0!, {r3-r5, r12}
+subs r2, r2, #0x10        
+bge Lmemcpy_fsrcul3loop16
+ldmia sp!, {r4, r5}
+adds r2, r2, #0x0c        
+blt Lmemcpy_fsrcul3l4
+
+Lmemcpy_fsrcul3loop4:
+mov r12, lr, lsr #24
+ldr lr, [r1], #4
+orr r12, r12, lr, lsl #8
+str r12, [r0], #4
+subs r2, r2, #4
+bge Lmemcpy_fsrcul3loop4
+
+Lmemcpy_fsrcul3l4:
+sub r1, r1, #1
+b Lmemcpy_fl4
+
+Lmemcpy_backwards:
+add r1, r1, r2
+add r0, r0, r2
+subs r2, r2, #4
+blt Lmemcpy_bl4  /* less than 4 bytes */
+ands r12, r0, #3
+bne Lmemcpy_bdestul  /* oh unaligned destination addr */
+ands r12, r1, #3
+bne Lmemcpy_bsrcul  /* oh unaligned source addr */
+
+Lmemcpy_bt8:
+/* We have aligned source and destination */
+subs r2, r2, #8
+blt Lmemcpy_bl12  /* less than 12 bytes (4 from above) */
+stmdb sp!, {r4, lr}
+subs r2, r2, #0x14  /* less than 32 bytes (12 from above) */
+blt Lmemcpy_bl32
+
+/* blat 32 bytes at a time */
+/* XXX for really big copies perhaps we should use more registers */
+Lmemcpy_bloop32:
+ldmdb r1!, {r3, r4, r12, lr}
+stmdb r0!, {r3, r4, r12, lr}
+ldmdb r1!, {r3, r4, r12, lr}
+stmdb r0!, {r3, r4, r12, lr}
+subs r2, r2, #0x20        
+bge Lmemcpy_bloop32
+
+Lmemcpy_bl32:
+cmn r2, #0x10            
+ldmgedb r1!, {r3, r4, r12, lr} /* blat a remaining 16 bytes */
+stmgedb r0!, {r3, r4, r12, lr}
+subge r2, r2, #0x10        
+adds r2, r2, #0x14        
+ldmgedb r1!, {r3, r12, lr} /* blat a remaining 12 bytes */
+stmgedb r0!, {r3, r12, lr}
+subge r2, r2, #0x0c        
+ldmia sp!, {r4, lr}
+
+Lmemcpy_bl12:
+adds r2, r2, #8
+blt Lmemcpy_bl4
+subs r2, r2, #4
+ldrlt r3, [r1, #-4]!
+strlt r3, [r0, #-4]!
+ldmgedb r1!, {r3, r12}
+stmgedb r0!, {r3, r12}
+subge r2, r2, #4
+
+Lmemcpy_bl4:
+/* less than 4 bytes to go */
+adds r2, r2, #4
+moveq pc, lr   /* done */
+
+/* copy the crud byte at a time */
+cmp r2, #2
+ldrb r3, [r1, #-1]!
+strb r3, [r0, #-1]!
+ldrgeb r3, [r1, #-1]!
+strgeb r3, [r0, #-1]!
+ldrgtb r3, [r1, #-1]!
+strgtb r3, [r0, #-1]!
+mov pc, lr
+
+/* erg - unaligned destination */
+Lmemcpy_bdestul:
+cmp r12, #2
+
+/* align destination with byte copies */
+ldrb r3, [r1, #-1]!
+strb r3, [r0, #-1]!
+ldrgeb r3, [r1, #-1]!
+strgeb r3, [r0, #-1]!
+ldrgtb r3, [r1, #-1]!
+strgtb r3, [r0, #-1]!
+subs r2, r2, r12
+blt Lmemcpy_bl4  /* less than 4 bytes to go */
+ands r12, r1, #3
+beq Lmemcpy_bt8  /* we have an aligned source */
+
+/* erg - unaligned source */
+/* This is where it gets nasty ... */
+Lmemcpy_bsrcul:
+bic r1, r1, #3
+ldr r3, [r1, #0]
+cmp r12, #2
+blt Lmemcpy_bsrcul1
+beq Lmemcpy_bsrcul2
+cmp r2, #0x0c            
+blt Lmemcpy_bsrcul3loop4
+sub r2, r2, #0x0c        
+stmdb sp!, {r4, r5, lr}
+
+Lmemcpy_bsrcul3loop16:
+mov lr, r3, lsl #8
+ldmdb r1!, {r3-r5, r12}
+orr lr, lr, r12, lsr #24
+mov r12, r12, lsl #8
+orr r12, r12, r5, lsr #24
+mov r5, r5, lsl #8
+orr r5, r5, r4, lsr #24
+mov r4, r4, lsl #8
+orr r4, r4, r3, lsr #24
+stmdb r0!, {r4, r5, r12, lr}
+subs r2, r2, #0x10        
+bge Lmemcpy_bsrcul3loop16
+ldmia sp!, {r4, r5, lr}
+adds r2, r2, #0x0c        
+blt Lmemcpy_bsrcul3l4
+
+Lmemcpy_bsrcul3loop4:
+mov r12, r3, lsl #8
+ldr r3, [r1, #-4]!
+orr r12, r12, r3, lsr #24
+str r12, [r0, #-4]!
+subs r2, r2, #4
+bge Lmemcpy_bsrcul3loop4
+
+Lmemcpy_bsrcul3l4:
+add r1, r1, #3
+b Lmemcpy_bl4
+
+Lmemcpy_bsrcul2:
+cmp r2, #0x0c            
+blt Lmemcpy_bsrcul2loop4
+sub r2, r2, #0x0c        
+stmdb sp!, {r4, r5, lr}
+
+Lmemcpy_bsrcul2loop16:
+mov lr, r3, lsl #16
+ldmdb r1!, {r3-r5, r12}
+orr lr, lr, r12, lsr #16
+mov r12, r12, lsl #16
+orr r12, r12, r5, lsr #16
+mov r5, r5, lsl #16
+orr r5, r5, r4, lsr #16
+mov r4, r4, lsl #16
+orr r4, r4, r3, lsr #16
+stmdb r0!, {r4, r5, r12, lr}
+subs r2, r2, #0x10        
+bge Lmemcpy_bsrcul2loop16
+ldmia sp!, {r4, r5, lr}
+adds r2, r2, #0x0c        
+blt Lmemcpy_bsrcul2l4
+
+Lmemcpy_bsrcul2loop4:
+mov r12, r3, lsl #16
+ldr r3, [r1, #-4]!
+orr r12, r12, r3, lsr #16
+str r12, [r0, #-4]!
+subs r2, r2, #4
+bge Lmemcpy_bsrcul2loop4
+
+Lmemcpy_bsrcul2l4:
+add r1, r1, #2
+b Lmemcpy_bl4
+
+Lmemcpy_bsrcul1:
+cmp r2, #0x0c            
+blt Lmemcpy_bsrcul1loop4
+sub r2, r2, #0x0c        
+stmdb sp!, {r4, r5, lr}
+
+Lmemcpy_bsrcul1loop32:
+mov lr, r3, lsl #24
+ldmdb r1!, {r3-r5, r12}
+orr lr, lr, r12, lsr #8
+mov r12, r12, lsl #24
+orr r12, r12, r5, lsr #8
+mov r5, r5, lsl #24
+orr r5, r5, r4, lsr #8
+mov r4, r4, lsl #24
+orr r4, r4, r3, lsr #8
+stmdb r0!, {r4, r5, r12, lr}
+subs r2, r2, #0x10        
+bge Lmemcpy_bsrcul1loop32
+ldmia sp!, {r4, r5, lr}
+adds r2, r2, #0x0c        
+blt Lmemcpy_bsrcul1l4
+
+Lmemcpy_bsrcul1loop4:
+mov r12, r3, lsl #24
+ldr r3, [r1, #-4]!
+orr r12, r12, r3, lsr #8
+str r12, [r0, #-4]!
+subs r2, r2, #4
+bge Lmemcpy_bsrcul1loop4
+
+Lmemcpy_bsrcul1l4:
+add r1, r1, #1
+b Lmemcpy_bl4
diff --git a/backends/gp32/portdefs.h b/backends/gp32/portdefs.h
index ecb918dea4..0408c56690 100644
--- a/backends/gp32/portdefs.h
+++ b/backends/gp32/portdefs.h
@@ -1,8 +1,8 @@
 /* ScummVM - Scumm Interpreter
- * Copyright (C) 2001  Ludvig Strigeus
- * Copyright (C) 2001/2004 The ScummVM project
+ * Copyright (C) 2001-2005 The ScummVM project
  * Copyright (C) 2002 Ph0x - GP32 Backend
  * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -25,11 +25,6 @@
 #ifndef PORTDEFS_H
 #define PORTDEFS_H
 
-// Prevents error trying to call main() twice from within the program ;-).
-#ifndef REAL_MAIN
-	#define main scummvm_main
-#endif /* REAL_MAIN */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -38,28 +33,10 @@
 #include <time.h>
 #include <cctype>
 
-//??
-//#include <math.h>
-//#include <time.h>
-
-// GP32 SDK Includes
-#include <gpfont.h>
-#include <gpfont16.h>
-#include <gpfont_port.h>
-#include <gpgraphic.h>
-#include <gpgraphic16.h>
-#include <gpmm.h>
-#include <gpmem.h>
-#include <gpos_def.h>
-#include <gpstdio.h>
-#include <gpstdlib.h>
-#include <gpdef.h>
-
-#define size_t long unsigned int // SDK hack
-
-// Undefine SDK defs.
+#include "gp32std.h"
 
 #undef byte
+
 #undef malloc
 #undef calloc
 #undef free
@@ -68,106 +45,70 @@
 #undef stdout
 #undef stdin
 
-// Redefine SDK defs.
-typedef unsigned char u8;
-typedef signed char s8;
-typedef unsigned short u16;
-typedef short s16;
-typedef unsigned int u32;
-typedef int s32;
-typedef int time_t;
-
-extern int gpprintf(const char *fmt, ...);
-#define printf gpprintf
-
-extern void *gpmalloc(size_t size);
-extern void *gpcalloc(size_t nitems, size_t size);
-extern void gpfree(void *block);
-extern char *gpstrdup(const char *s);
-
-#define malloc gpmalloc
-#define calloc gpcalloc //gm_calloc
-//#define calloc gm_calloc
-#define free gpfree
-
-//	#define memset gm_memset
-//	#define memcopy gm_memcopy
-//
-//	#define strcpy gm_strcpy	// uncomment?
-//	#define strncpy gm_strncpy
-//	#define strcat gm_strcat
-//	#define sprintf gm_sprintf
-
-#define strdup gpstrdup
+#undef fopen
+#undef fread
+#undef fwrite
+#undef fclose
+#undef ftell
+#undef rewind
+#undef fseek
 
-#define assert(e) ((e) ? 0 : (printf("!AS: " #e " (%s, %d)\n", __FILE__, __LINE__)))
-#define ASSERT assert
+#undef ferror
+#undef clearerr 
 
-#define ENDLESSLOOP while (1)
+#undef feof	
+#undef getc
+
+#define FILE GPFILE
+
+#define stderr	gp_stderr
+#define stdout	gp_stdout
+#define stdin	gp_stdin
+
+#define fopen	gp_fopen
+#define fread	gp_fread
+#define fwrite	gp_fwrite
+#define fclose	gp_fclose
+#define fseek	gp_fseek
+#define ftell	gp_ftell
+#define ferror	gp_ferror
+#define clearerr gp_clearerr
+
+#define feof	gp_feof
+#define fgets	gp_fgets
+#define fgetc	gp_fgetc
+#define getc	gp_fgetc
+
+#define fprintf	gp_fprintf
+#define fflush	gp_fflush
+
+#define printf	gp_printf
+
+#define exit	gp_exit
+
+#define strcpy	gp_strcpy
+#define strncpy	gp_strncpy
+#define strcat	gp_strcat
+#define strdup	gp_strdup
+#define sprintf	gp_sprintf
+#define strcasecmp	gp_strcasecmp
+#define strncasecmp gp_strncasecmp
+
+#define memcpy	gp_memcpy
+#define memset	gp_memset
+#define malloc	gp_malloc
+#define calloc	gp_calloc //gm_calloc
+#define free	gp_free
+
+#define FUNCTION GPDEBUG("FUNC: %s", __FUNCTION__);
+
+#define DELAY gp_delay(500);
 
-#define FILE F_HANDLE
-extern FILE *fstderr;
-extern FILE *fstdout;
-extern FILE *fstdin;
-
-#define stderr fstderr
-#define stdout fstdout
-#define stdin fstdin
-
-extern FILE *gpfopen(const char *filename, const char *mode);
-extern int gpfclose(FILE *stream);
-extern int gpfseek(FILE *stream, long offset, int whence);
-extern size_t gpfread(void *ptr, size_t size, size_t n, FILE *stream);
-extern size_t gpfwrite(const void *ptr, size_t size, size_t n, FILE*stream);
-extern long gpftell(FILE *stream);
-extern void gpclearerr(FILE *stream);
-extern int gpfeof(FILE *stream);
-extern char *gpfgets(char *s, int n, FILE *stream);
-extern int gpfflush(FILE *stream);
-extern char gpfgetc(FILE *stream);
-
-#define fopen gpfopen
-#define fclose gpfclose
-#define fseek gpfseek
-#define fread gpfread
-#define fwrite gpfwrite
-#define ftell gpftell
-
-#undef clearerr
-#define clearerr gpclearerr
-
-#undef feof
-#define feof gpfeof
-#define fgets gpfgets
-#define fgetc gpfgetc
-#define getc gpfgetc
-
-extern int gpfprintf(FILE *stream, const char *fmt, ...);
-#define fprintf gpfprintf
-#define fflush gpfflush
-
-extern void gpexit(int code);
-#define exit gpexit
-//#define error printf
-
-//extern time_t gptime(time_t *timer);
-//#define time gptime
-
-// MARK Debug Point.
 #define MARK printf("MARK: %s, %s, %d", __FILE__, __FUNCTION__, __LINE__);
 
-extern void *gpmemset (void *s, int c, size_t n);
-extern void *gpmemcpy (void *dest, const void *src, size_t n);
-//#define memset gpmemset
-//#define memcpy gpmemcpy
+#define assert(e) ((e) ? 0 : (printf("!AS: " #e " (%s, %d)\n", __FILE__, __LINE__)))
+#define ASSERT assert
 
-// Missing stuff
-int stricmp(const char *string1, const char *string2);
-int strnicmp(const char *string1, const char *string2, int len);
-inline float sin(float) { return 0; }
-inline float cos(float) { return 0; }
-inline float sqrt(float) { return 0; }
-inline float atan2(float, float) { return 0; }
+#define ENDLESSLOOP while (1)
 
-// EOF
 #endif /* PORTDEFS_H */
diff --git a/backends/gp32/setup.h b/backends/gp32/setup.h
deleted file mode 100644
index 66da45b91e..0000000000
--- a/backends/gp32/setup.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/* ScummVM - Scumm Interpreter
- * Copyright (C) 2001  Ludvig Strigeus
- * Copyright (C) 2001/2004 The ScummVM project
- * Copyright (C) 2002 Ph0x - GP32 Backend
- * Copyright (C) 2003/2004 DJWillis - GP32 Backend
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $Header$
- *
- */
-
-#ifndef SETUP_H
-#define SETUP_H
-
-#ifndef NULL
-	#define NULL 0
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// ScummVM/GP32 - Configuration front-end launcher and splash-screen stuff.
-//				  Also contains GP32 start-up code.
-//                Not part of ScummVM backend as such.
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#define MENU_MUSICDRV	0
-#define MENU_SCREENPOS	1
-#define MENU_CPUSPEED	2
-
-// OLD CONFIG
-// NULL marks end (FIXME)
-typedef struct {
-	const char *option;
-	const char **submenu;
-	int index;
-} tmenu;
-
-const char *sautorun[] = {
-"NOT IMPLEMENTED",
-/*
-"Off",
-"On",
-*/
-//NULL
-};
-
-const char *ssounddrv[] = {
-"-eadlib",
-"-enull",
-NULL
-};
-
-const char *sscreenpos[] = {
-"Top",
-"Center",
-NULL
-};
-
-const char *scpuspeed[] = {
-"66",
-"100",
-"120",
-"132",
-"156",
-"166",
-"180",
-"200",
-NULL
-};
-
-const char *sbrightness[] = {
-"Normal",
-"Lighter",
-"Lightest",
-"Darker",
-"Darkest",
-NULL
-};
-
-tmenu menu[] = {
-{"Music Driver", ssounddrv, 0},
-{"Screen Position", sscreenpos, 1},
-{"CPU Speed (MHz)", scpuspeed, 3},
-};
-
-#else
-	#warning GP32 LAUNCHER.H Called more then once.
-#endif /* SETUP_H */
diff --git a/backends/gp32/startup.c b/backends/gp32/startup.c
index b7f7e22862..86f69d7ba8 100644
--- a/backends/gp32/startup.c
+++ b/backends/gp32/startup.c
@@ -1,8 +1,8 @@
 /* ScummVM - Scumm Interpreter
- * Copyright (C) 2001  Ludvig Strigeus
- * Copyright (C) 2001/2004 The ScummVM project
+ * Copyright (C) 2001-2005 The ScummVM project
  * Copyright (C) 2002 Ph0x - GP32 Backend
  * Copyright (C) 2003/2004 DJWillis - GP32 Backend
+ * Copyright (C) 2005 Won Star - GP32 Backend
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -16,7 +16,7 @@
 
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  *
  * $Header$
  *
@@ -34,10 +34,6 @@
 	#include <gpmem.h>
 #endif
 
-//#ifdef GP32_GDB
-//	#include <gdb-stub.h>
-//#endif /*GP32_GDB*/
-
 unsigned int HEAPSTART;
 unsigned int HEAPEND;
 
@@ -45,11 +41,6 @@ void InitializeFont (void);
 extern void GpKeyPollingTimeSet (int loop_cnt);
 extern void GpMain(void *arg);
 
-//extern int OpenUSB ();
-//extern void InstallISR ();
-
-
-
 int main (int arg_len, char * arg_v)
    {
 	GM_HEAP_DEF gm_heap_def;