//Sid Spanners 2: The Slackening (v1.0)
//
//by Digital Prawn 
//
//This release: 2nd January 2011
//
//All code and graphics in the Public Domain and may be freely re-used
//

//General Info
//All sprites are 16x16 Pixels
//All levels consist of 32x16 tiles
//All tiles are "character code" based 8x8 cells
//SP1 sprite library only needs to manage uppermost 32x16 character area of the screen
//
// Memory map
//
// 23755 Start of ZX BASIC loader, overwritten by 1796-byte malloc() heap during initialisation
// 25551 Start of compiled C code and data
// 53168 First unused location after end of compiled C code (Approx 80 spare bytes)
// 53248 ($D000) 257-byte IM2 vector table
// 53505 Lowest possible area used by stack (allocated size=208 bytes)
// 53711 Highest (address-wise) word on the stack (stack base set to 53713)
// 53713 ($D1D1) 2-byte RETI instruction (ISR does nothing)

//Compiling this game

//Must compile with -zorg=25551

//Within the below comment is the Makefile that was used to build the game
//Either copy and paste this into a file called "Makefile" and build with "make"
//Or just compile with zcc directly using all options shown below
//zcc v2.57 was originally used to build the game
/*
sidspan2.tap: sidspan2.c
	zcc +zx -osidspan2.bin -lndos -lmalloc -lim2 -lsp1 sidspan2.c -zorg=25551 -create-app
*/

#include <sprites/sp1.h>
#include <malloc.h>
#include <spectrum.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <input.h>
#include <sound.h>
#include <im2.h>
#include <zxlowgfx.h>

//Pre-processor directives, definitions and macros	
#define SGN(x) ((x)<0?-1:((x)?1:0))
#define ABS(x) ((x)<0?-(x):(x))
#define WAIT_KEY while(!in_Inkey())
					 
#pragma output STACKPTR=53713	// Set stack at 208-byte gap between IM2 vector table and ISR entry point 
#define MAX_SPRITES 5
#define NUM_LEVELS 54
#define START_LEVEL 1			//for debugging and playtesting
#define LEVEL_SIZE 512  		//Size of an uncompressed level in bytes
#define HEAP_ADDR 23755         //Heap in low RAM (slow)
#define HEAP_SIZE 1796 			//Exact heap size needed for 5 16x16 maskless sprites 
								//(plus 512 bytes needed for uncompressed map of current level)

//Game parameters, time limit and number of lives								
#define TIME_LIMIT 200
#define NUM_LIVES 27

//Typedefs
typedef unsigned char byte;
typedef unsigned int word;

//My sprite data structure
struct sprentry
	{
	struct sp1_ss *s;
	char dx;
	char dy;
	byte frame;
	//pixel position of sprite on screen (used for collision detection and bounding)
    byte px;
	byte py;
	//start positions (player and guardians)
	byte startcol;
	byte startrow;
	//end positions (guardians only)
	byte endcol;
	byte endrow;
	//direction: 1=travelling towards end, 255 (-1)=travelling back to start
	byte direction;
	};

//Globals (Many variables moved from main() into the global space to save stack space)
long heap;                                      //malloc's heap pointer
struct in_UDK keys;								//structure for keyboard input
void *getjoy; 									//function pointer for input routine - has to be declared as "void *"
	      										//because function pointer declarations not currently supported in Z88DK
struct sprentry sprtbl[MAX_SPRITES];            //Sprite table. The zeroth sprite is the player sprite.

char *current_map;                              //pointer to map data of current level
byte airborne; 									//set to 1 if the player character is in the air
byte facing_left; 								//set to 1 if facing left else 0 for facing right 
byte frame_tick,jump_tick,						//timers for in-game events
	guardian_flip,guardian_tick;
byte sprite_colour[MAX_SPRITES];				//holds the colours of each sprite (varies according to level)
byte colour; 									//needed as a global because cannot be passed as
												//parameter into add_sprite_colour() hook
byte global_n; 									//generic global byte used instead of a function parameter
												//when "hook functions" are called by SP1

//For the intro/game over/game won screens
byte mono_sprite0[10]={8,8,0,0,0,0,0,0,0,0};

//Compressed level data format follows - one nybble per map square
//Tiles
//a=brick
//b=nut
//c=door (top left of)
//f=empty space

//0=player sprite (all sprite positions denote top-left corner of sprite)
//2,4,6,8 startpoints of guardian sprites 1-4
//3,5,7,9 endpoints of guardian sprites 1-4
//guardians can be horizontal or vertical

//unused (reserved nybble (0x01))
//The nybble '1' should never occur in this data - it is reserved for possible
//expansions/additions in any possible future sequels

//Optional further compression to save space
//Simple run length encoding
//bytes 0xd<n> indicate <n> bytes of 0xaa (2 spaces of wall)
//0xe<n> indicate <n> bytes of 0xff (2 empty spaces)
//if <n>==0 then it is taken to mean 16
//<n>=1 should never occur in compressed data as the nybble '1' is reserved for other uses

/* Level data Nybble vaues in table format

	0 Start position of player sprite
	1 Reserved for possible future games
	2 Start position of guardian number 1
	3 End position of guardan number 1
	4 Start position of guardian number 2 
	5 End position of guardian number 2
	6 Start position of guardian number 3
	7 End position of guardian number 3
	8 Start position of guardian number 4
	9 End position of guardian number 4
	a Wall
	b Nut
	c Exit door
	d followed by nybble <n> Indicates compressed sequence of (2*n) wall blocks
	e followed by nybble <n> Indicates compressed sequence of (2*n) empty spaces
	f Empty space
	
	(If <n>==0 then <n> indicates the value 16, 
		<n>=1 is never used (saves no space and is reserved))
*/

char level1_data[]=
	{
	 0xd0,
	 0xac, 0xe5, 0x6f, 0xe8, 0xba,
	 0xaf, 0xe3, 0xfb, 0xe4, 0xbf, 0xe5, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xe3, 0xd6, 0xff, 0xfa,
	 0xaf, 0xbf, 0xe9, 0x2b, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xea, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xd2, 0xaf, 0xfb, 0xff, 0xfa, 0xd2, 0xe2, 0xaa, 0xaf, 0xfa,
	 0xaf, 0xe5, 0x7f, 0xe2, 0xf8, 0xff, 0x3f, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe5, 0xfb, 0xe5, 0xfa,
	 0xaf, 0xe4, 0xd4, 0xaf, 0xff, 0xd3, 0xaf, 0xfa,
	 0xa5, 0xff, 0xbf, 0xff, 0xfb, 0xe9, 0xb4, 0xfa,
	 0xaf, 0xe7, 0xfb, 0xe6, 0xfa,
	 0xaf, 0xfa, 0xd7, 0xe3, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xbf, 0xe7, 0xf9, 0xe2, 0x0f, 0xff, 0xfb, 0xfa,
	 0xaf, 0xe6, 0xbf, 0xe7, 0xfa,
	 0xd0,
	};

byte level2_data[] =
	{
	 0xd0,
	 0xab, 0xe4, 0xbf, 0xe2, 0x2f, 0xff, 0x5f, 0xff, 0x6f, 0xe2, 0xba,
	 0xaf, 0xea, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xff, 0xfa, 0xe4, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa,
	 0xa9, 0xff, 0xfb, 0xe4, 0xfb, 0xff, 0xfb, 0xe3, 0xfb, 0xf8, 0xfa,
     	 0xaf, 0xea, 0xfb, 0xff, 0xfb, 0xff, 0xfa,
	 0xd6, 0xbf, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa,
	 0xac, 0xe2, 0xfb, 0xe3, 0xfa, 0xff, 0xfa, 0xfb, 0xfa, 0xff, 0xfa, 0xff, 0xfa,
	 0xaf, 0xea, 0xfb, 0xe3, 0xfa,
	 0xab, 0xe6, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe3, 0xfb, 0xff, 0xfb, 0xe3, 0xfb, 0xff, 0xfa,
	 0xaf, 0xfa, 0xd2, 0xe3, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfa, 0xe2, 0xfb, 0xe6, 0xfb, 0xff, 0xfa,
	 0xa0, 0xfa, 0xff, 0xfa, 0xe3, 0xfa, 0x3f, 0xfa, 0x4f, 0xfa, 0x7f, 0xfa, 0xff, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfa, 0xe3, 0xfb, 0xe3, 0xfb, 0xff, 0xfb, 0xff, 0xfa,
	 0xd0,
	};
	
byte level3_data[] =
	{
	 0xd0,
	 0xaf, 0xe3, 0xbf, 0xea, 0xfa,
	 0xaf, 0xfa, 0x4f, 0xe3, 0xbf, 0xe2, 0xbf, 0xe3, 0x5f, 0xaf, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xaa, 0xaf, 0xea, 0xfa, 0xaa, 0xfa,
	 0xa2, 0xff, 0xfa, 0xaf, 0xf6, 0xe5, 0xf7, 0xff, 0xfa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfa, 0xaf, 0xe2, 0xfb, 0xe3, 0xfa, 0xaf, 0xff, 0xaf, 0xfa,
	 0xaf, 0xe2, 0xfc, 0xfa, 0xd6, 0xaf, 0xe3, 0xba,
	 0xab, 0xfa, 0xe3, 0x8f, 0xe8, 0xaf, 0xfa,
	 0xaf, 0xe3, 0xfb, 0xe5, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfa, 0xaa, 0xe2, 0xfb, 0xe2, 0xfa, 0xaa, 0xe2, 0xaf, 0xfa,
	 0xaf, 0xe6, 0xfa, 0xe6, 0xbf, 0xfa,
	 0xaf, 0xfa, 0xe4, 0xbf, 0xe2, 0xbf, 0xe4, 0xaf, 0xfa,
	 0xa3, 0xe4, 0x9f, 0xe5, 0xf0, 0xe3, 0xfa,
	 0xaf, 0xfa, 0xec, 0xaf, 0xfa,
	 0xd0,
	};

byte level4_data[] =
	{
	 0xd0,
	 0xa6, 0xeb, 0xf7, 0xf4, 0xff, 0xfa,
	 0xaf, 0xf8, 0xe2, 0xbf, 0xe2, 0xfb, 0xe7, 0xfa,
	 0xab, 0xe3, 0xd4, 0xe3, 0xfb, 0xe3, 0xba,
	 0xaa, 0xe3, 0xfa, 0xff, 0xf2, 0xff, 0xaf, 0xe6, 0xfa,
	 0xaf, 0xe4, 0xcf, 0xe5, 0x0f, 0xe3, 0xfa,
	 0xaf, 0xfb, 0xe2, 0xfa, 0xff, 0xfb, 0xff, 0xaf, 0xe6, 0xfa,
	 0xab, 0xe4, 0xaf, 0xe2, 0xfa, 0xff, 0xfa, 0xd2, 0xe2, 0xd2, //one compressed wall block wraps onto next row
	 0xe9, 0xfb, 0xff, 0xfb, 0xe2, 0xba,
	 0xaf, 0xe4, 0xaf, 0xe2, 0xfa, 0xe6, 0xfa,
	 0xaf, 0xfb, 0xed, 0xfa,
	 0xab, 0xe4, 0xaf, 0xe2, 0xfa, 0xe6, 0xaa,
	 0xaa, 0xe4, 0xfa, 0xff, 0xbf, 0xff, 0xaf, 0xe2, 0xbf, 0xe2, 0xba,
	 0xaf, 0xf9, 0xff, 0xfb, 0xff, 0xfb, 0xf3, 0xe2, 0xbf, 0xe3, 0xf5, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xe3, 0xaf, 0xe5, 0xfa,
	 0xd0,
	};

byte level5_data[] =
	{
	 0xd0,
	 0xab, 0xe6, 0xbf, 0xe7, 0xba,
	 0xa9, 0xe3, 0x8f, 0xaf, 0xff, 0xaf, 0xfa, 0xe6, 0xfa,
	 0xaf, 0xe4, 0xf2, 0xff, 0xbf, 0xf5, 0xe3, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xaf, 0xe2, 0xaf, 0xff, 0xfa, 0x6f, 0xe3, 0xf7, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xe2, 0xfb, 0xe5, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xe3, 0xaf, 0xe2, 0xfa, 0xe4, 0xfa,
	 0xaf, 0xfb, 0xe5, 0xbf, 0xe4, 0xfb, 0xff, 0xfa, 0xaa,
	 0xaf, 0xe2, 0xaf, 0xe3, 0xaf, 0xe2, 0xfa, 0xe4, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xeb, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xff, 0xf3, 0xff, 0xaf, 0x4f, 0xff, 0xfa, 0xff, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xfa, 0xe1, 0xaf, 0xfa, 0xff, 0xaf, 0xba, 0xe4, 0xfa,
	 0xaf, 0xe6, 0xcf, 0xe6, 0xf0, 0xfa,
	 0xab, 0xe5, 0xbf, 0xe8, 0xfa,
	 0xd0,
	};

byte level6_data[] =
	{
	 0xd0,
	 0xab, 0xe6, 0x3f, 0xbf, 0x4f, 0xe4, 0xfb, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaa, 0xd6, 0xbf, 0xaa, 0xfb, 0xd6,
	 0xaf, 0xe2, 0xf6, 0xeb, 0xfa,
	 0xaf, 0xbf, 0xe6, 0xbf, 0xe5, 0xfb, 0xfa,
	 0xaf, 0xe7, 0xaf, 0xe6, 0xfa,
	 0xd3, 0xab, 0xfa, 0xd2, 0xbf, 0xaa, 0xfb, 0xd6,
	 0xaf, 0xee, 0xfa,
	 0xab, 0xe6, 0x2f, 0xbf, 0x5f, 0xff, 0xbf, 0xe2, 0xbf, 0xfa,
	 0xaa, 0xee, 0xfa,
	 0xaa, 0xd2, 0xab, 0xfa, 0xdb,
	 0xaf, 0xf8, 0xe6, 0xbf, 0xe4, 0x9f, 0xff, 0xfa,
	 0xac, 0xe2, 0xf7, 0xbf, 0xe9, 0x0f, 0xfa,
	 0xaf, 0xfb, 0xe9, 0xbf, 0xff, 0xaa, 0xff, 0xfa,
	 0xd0,
	};

byte level7_data[] =
	{
	 0xd0,
	 0xaf, 0xff, 0xf2, 0xe2, 0xf5, 0xe2, 0xf6, 0xe4, 0x8f, 0xff, 0xfa,
	 0xab, 0xe8, 0xfb, 0xe5, 0xfa,
	 0xaa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe2, 0xfb, 0xe4, 0xbf, 0xe4, 0xfa,
	 0xaa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xab, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe2, 0xcf, 0xe2, 0xbf, 0xe2, 0xfb, 0xff, 0xfa,
	 0xaa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xe5, 0xaf, 0xfa, 0xff, 0xaf, 0xfa,
	 0xaf, 0xff, 0xfb, 0xec, 0xfa,
	 0xaa, 0xff, 0xaf, 0xfa, 0xe7, 0x0f, 0xfa, 0xff, 0xaf, 0xfa,
	 0xaf, 0xe5, 0xbf, 0xe2, 0xbf, 0xe5, 0xfa,
	 0xaa, 0xff, 0xaf, 0xe2, 0xf4, 0xe2, 0xf7, 0xe2, 0xaf, 0xe2, 0xaf, 0xfa,
	 0xaf, 0xe9, 0xfa, 0xe4, 0xfa,
	 0xaa, 0xff, 0xf3, 0xff, 0xbf, 0xe4, 0xfb, 0xe3, 0x9f, 0xbf, 0xfa,
	 0xab, 0xe6, 0xbf, 0xe7, 0xfa,
	 0xd0,
	};

byte level8_data[] =
	{
	 0xd0,
	 0xac, 0xe5, 0x6f, 0xff, 0xb9, 0xe6, 0xfa,
	 0xaf, 0xe6, 0xfa, 0xaf, 0xe6, 0xba,
	 0xa5, 0xe2, 0xbf, 0xe8, 0xbf, 0xff, 0xf4, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xfb, 0xe3, 0xfa, 0xff, 0xfa, 0xaf, 0xff, 0xaf, 0xe2, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xe3, 0xfa, 0xaf, 0xe2, 0xaf, 0xff, 0xf0, 0xff, 0xfa,
	 0xaf, 0xe6, 0xfb, 0xe7, 0xfa,
	 0xaf, 0xfa, 0xff, 0xbf, 0xff, 0xfa, 0xff, 0xfa, 0xaf, 0xff, 0xaf, 0xe2, 0xfa, 0xff, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xe3, 0xfa, 0xaf, 0xe2, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xe5, 0x7f, 0xff, 0xf8, 0xe4, 0xfb, 0xff, 0xfa,
	 0xaf, 0xfa, 0xe5, 0xfa, 0xaf, 0xe4, 0xfa, 0xff, 0xfa,
	 0xa2, 0xe6, 0xfb, 0xe2, 0xbf, 0xe3, 0xf3, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xeb, 0xfa,
	 0xd0,
	};

byte level9_data[] =
	{
	 0xd0,
	 0xaf, 0xe2, 0xbf, 0xf2, 0xe3, 0xf9, 0xff, 0xbf, 0xff, 0x6f, 0xff, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xaa, 0xe3, 0x0f, 0xe2, 0xaa, 0xe4, 0xfa,
	 0xaf, 0xff, 0xfa, 0xfb, 0xaf, 0xe4, 0xfa, 0xbf, 0xaf, 0xff, 0xfa, 0xaf, 0xfa,
	 0xaf, 0xff, 0xfa, 0xff, 0xaf, 0xe2, 0xaa, 0xff, 0xfa, 0xff, 0xaf, 0xff, 0xaf, 0xba, 0xfa,
	 0xaf, 0xe2, 0xaa, 0xe2, 0xfa, 0xbf, 0xaf, 0xff, 0xaa, 0xe2, 0xaf, 0xfa, 0xfa,
	 0xaf, 0xe5, 0xfa, 0xff, 0xaf, 0xe2, 0xfb, 0xff, 0xfa, 0xaf, 0xfa,
	 0xa4, 0xfb, 0xe4, 0x5f, 0xaa, 0xfc, 0xe6, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xe4, 0xfa, 0xaf, 0xe2, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xaa, 0xe6, 0xaf, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xff, 0xfa, 0xff, 0xaf, 0xff, 0xfa, 0xaf, 0xe2, 0xaf, 0xba, 0x7f, 0xe2, 0xfa,
	 0xaf, 0xff, 0xfa, 0xfb, 0xaf, 0xff, 0xab, 0xfa, 0xe2, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xfa,
	 0xaf, 0xe2, 0xaa, 0xe2, 0xaf, 0xfa, 0xe5, 0xaf, 0xfa, 0xfa,
	 0xaf, 0xfb, 0xe2, 0xf3, 0xff, 0xfa, 0xaf, 0xf8, 0xff, 0xbf, 0xe2, 0xab, 0xfa, 0xfa,
	 0xaf, 0xec, 0xfa, 0xab, 0xfa,
	 0xd0
	};
	
byte level10_data[] =
	{
	 0xd0,
	 0xaf, 0xff, 0xf8, 0xfb, 0xe7, 0xf0, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xaf, 0xab, 0xaf, 0xaf, 0xab, 0xaf, 0xaf, 0xe3, 0xfa,
	 0xab, 0xe2, 0xfa, 0xd8, 0xe3, 0xba,
	 0xaf, 0xe2, 0xfa, 0x4f, 0xe2, 0xfb, 0xe2, 0xf5, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xfc, 0xff, 0xfa, 0xff, 0xaa, 0xa2, 0xfa, 0xfa, 0xaa, 0xff, 0xfa, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xfb, 0xab, 0xff, 0xfa, 0xfa, 0xfb, 0xaf, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xba, 0xff, 0xaa, 0xaf, 0xfa, 0xfa, 0xff, 0xaf, 0xfa, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xe2, 0xaf, 0xfa, 0xfa, 0xff, 0xaf, 0xfa, 0xe3, 0xba,
	 0xab, 0xe2, 0xfa, 0xff, 0xaa, 0xa3, 0xfa, 0xfa, 0xaa, 0xff, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xbf, 0xe2, 0xfb, 0xe2, 0xfb, 0xfa, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xf9, 0xfa, 0xd8, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xaf, 0xaf, 0xaf, 0xab, 0xaf, 0xaf, 0xaf, 0xaf, 0xe3, 0xfa,
	 0xa6, 0xe2, 0xbf, 0xea, 0xf7, 0xfa,
	 0xaf, 0xe9, 0xbf, 0xe4, 0xfa,
	 0xd0,
	};

byte level11_data[] =
	{
	 0xd0,
	 0xaf, 0xe7, 0xbf, 0xe4, 0xf2, 0xff, 0xfa,
	 0xab, 0xe2, 0xbf, 0xe4, 0xaa, 0xe6, 0xfa,
	 0xa4, 0xe5, 0xf5, 0xfa, 0xbf, 0xaf, 0xff, 0xbf, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe3, 0xfa, 0xd2, 0xe5, 0xfa,
	 0xaf, 0xff, 0xfa, 0xda, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xf6, 0xe2, 0xfa, 0xff, 0xfa, 0x8f, 0xe3, 0xf9, 0xe2, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xfb, 0xfa, 0xe6, 0xbf, 0xfa,
	 0xaf, 0xbf, 0xe4, 0xaf, 0xaf, 0xe2, 0xbf, 0xe4, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xff, 0xfa, 0xe8, 0xfa,
	 0xaf, 0xe5, 0xaf, 0xaf, 0xe7, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xff, 0xfa, 0xbf, 0xe2, 0xfb, 0xe3, 0xaa,
	 0xaf, 0xbf, 0xe3, 0xaf, 0xe2, 0xaf, 0xe6, 0xfa,
	 0xaf, 0xff, 0xf7, 0xff, 0xfa, 0xff, 0xfc, 0xff, 0xfa, 0xe4, 0xf3, 0xf0, 0xfa,
	 0xab, 0xe3, 0xfa, 0xe3, 0xfa, 0xe4, 0xaf, 0xff, 0xfa,
	 0xd0,
	};

byte level12_data[] =
	{
	 0xaa, 0xaf, 0xe2, 0xfa, 0xd6, 0xaf, 0xe2, 0xfa, 0xaa,
	 0xa8, 0xe2, 0xbf, 0xea, 0xf9, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe5, 0xbf, 0xe2, 0xfb, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xaa, 0xff, 0xaa, 0xbf, 0xe5, 0xaa, 0xff, 0xaa, 0xff, 0xfa,
	 0xa7, 0xff, 0xb5, 0xe9, 0xf2, 0xff, 0xf6, 0xfa,
	 0xaf, 0xe8, 0xbf, 0xe5, 0xfa,
	 0xaf, 0xe6, 0xd2, 0xe6, 0xfa,
	 0xaf, 0xe6, 0xbf, 0xe7, 0xba,
	 0xab, 0xe2, 0xfb, 0xe3, 0xfc, 0xe2, 0xbf, 0xe4, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xaf, 0xe7, 0xaf, 0xe2, 0xfa,
	 0xab, 0xe7, 0xbf, 0xe6, 0xba,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe5, 0x0f, 0xe3, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xff, 0xf4, 0xe9, 0xf3, 0xe2, 0xfa,
	 0xd2, 0xe2, 0xd8, 0xbf, 0xff, 0xd2,
	};

byte level13_data[] =
	{
	 0xd0,
	 0xa4, 0xe2, 0xfb, 0xe3, 0xfc, 0xe3, 0xfb, 0xe2, 0xf7, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe6, 0xfb, 0xe7, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe2, 0xd4, 0xe2, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xe4, 0xfa, 0x8f, 0xe2, 0x9f, 0xaf, 0xe4, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe2, 0xaf, 0xff, 0xfb, 0xe2, 0xfa, 0xe2, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xdc, 0xff, 0xfa,
	 0xaf, 0xbf, 0xfa, 0xf2, 0xe7, 0xf3, 0xff, 0xaf, 0xfb, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xe8, 0xfa, 0xe2, 0xfa,
	 0xaf, 0xe2, 0xba, 0xd2, 0xaf, 0xff, 0xbf, 0xfa, 0xd2, 0xab, 0xe2, 0xfa,
	 0xaf, 0xe4, 0xbf, 0xfa, 0xd2, 0xaf, 0xe5, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe3, 0xbf, 0xff, 0xfa, 0xe5, 0xfa,
	 0xa5, 0xe4, 0x0f, 0xe3, 0xfb, 0xaf, 0xe3, 0xf6, 0xfa,
	 0xaf, 0xe9, 0xfa, 0xe4, 0xfa,
	 0xd0,
	};

byte level14_data[] =
	{
	 0xd0,
	 0xac, 0xf4, 0xe7, 0xfb, 0xe4, 0xf5, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe4, 0xbf, 0xe9, 0xfa,
	 0xab, 0xff, 0xfa, 0xda, 0xaf, 0xfb, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xbf, 0xe4, 0xfb, 0xe2, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaf, 0xe3, 0xd2, 0xe4, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xba, 0xaf, 0xff, 0xbf, 0xff, 0xa3, 0xba, 0xe4, 0xaf, 0xfb, 0xfa,
	 0xaf, 0xd5, 0xff, 0xaf, 0xfa, 0xff, 0xd5, 0xfa,
	 0xa7, 0xff, 0xfa, 0xaf, 0xff, 0xfa, 0xaa, 0xaf, 0xfa, 0xaa, 0xaf, 0xe2, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xa9, 0xe3, 0xf2, 0xe4, 0x8f, 0xaf, 0xbf, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaf, 0xfb, 0xe5, 0xfb, 0xe2, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xda, 0xaf, 0xff, 0xfa,
	 0xa6, 0xe4, 0xfb, 0xe8, 0xf0, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe6, 0xbf, 0xe5, 0xfa,
	 0xd0,
	};

byte level15_data[] =
	{
	 0xd0,
	 0xaf, 0xbf, 0x2f, 0xe2, 0x8f, 0xe6, 0x9f, 0x7f, 0xfb, 0xfa,
	 0xaf, 0xe3, 0xaa, 0xe3, 0xbf, 0xe6, 0xfa,
	 0xaa, 0xe3, 0xbf, 0xe6, 0xfb, 0xe3, 0xaa,
	 0xaf, 0xed, 0xfb, 0xfa,
	 0xaf, 0xe6, 0xbf, 0xe7, 0xfa,
	 0xaa, 0xee, 0xaa,
	 0xaf, 0xe2, 0xfb, 0xe3, 0xfc, 0xe3, 0xfb, 0xe2, 0xfb, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaa, 0xee, 0xaa,
	 0xaf, 0xbf, 0xec, 0xfb, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaa, 0xee, 0xaa,
	 0xa0, 0xff, 0x3f, 0x4f, 0xe8, 0x5f, 0x6f, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe5, 0xfb, 0xe4, 0xfb, 0xfa,
	 0xd0,
	};

byte level16_data[] =
	{
	 0xd0,
	 0xa4, 0xe4, 0xfb, 0xe8, 0xf5, 0xfa,
	 0xaf, 0xe9, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xfa, 0xaa, 0xaf, 0xe9, 0xfb, 0xff, 0xfa,
	 0xaf, 0xaf, 0xff, 0xfa, 0xff, 0xba, 0xaa, 0xaf, 0xe2, 0xfc, 0xe4, 0xfa,
	 0xaa, 0x8f, 0xe2, 0xaa, 0xaf, 0xff, 0xfa, 0xe7, 0xfa,
	 0xaf, 0xff, 0xaf, 0xe2, 0xfb, 0xe2, 0xaf, 0xe4, 0xd2, 0xfa,
	 0xaf, 0xff, 0xa6, 0xe3, 0x7f, 0xd8, 0xfa,
	 0xaf, 0xff, 0xaf, 0xe4, 0xd8, 0xba,
	 0xaf, 0x9f, 0xaf, 0xe3, 0xbf, 0xff, 0xaf, 0xf0, 0xe3, 0xd2, 0xfa,
	 0xaa, 0xe3, 0xaa, 0xaf, 0xff, 0xfa, 0xe7, 0xfa,
	 0xab, 0xaf, 0xff, 0xfa, 0xff, 0xfa, 0xaa, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xaa, 0xaf, 0xe9, 0xfa, 0xaf, 0xfa,
	 0xa2, 0xe6, 0xfb, 0xe3, 0xfb, 0xe2, 0xf3, 0xfa,
	 0xaf, 0xff, 0xfb, 0xec, 0xba,
	 0xd0,
	};

byte level17_data[] =
	{
	 0xd0,
	 0xab, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xfa, 0xfb, 0xaf, 0xfa, 0xff, 0xaf, 0xba, 0xe2, 0xba,
	 0xaf, 0xfa, 0xdb, 0xaf, 0xfa, 0xfa,
	 0xa3, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xf2, 0xfa,
	 0xaf, 0xbf, 0xaf, 0xfa, 0xff, 0xab, 0xfa, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xfa, 0xe2, 0xfa,
	 0xaf, 0xdc, 0xaf, 0xf8, 0xfa,
	 0xa7, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe9, 0xbf, 0xe2, 0xfa,
	 0xa6, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xfa, 0xff, 0xf9, 0xfa,
	 0xaf, 0xfa, 0xdb, 0xaf, 0xff, 0xfa,
	 0xa4, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xab, 0xfa, 0xff, 0xab, 0xfa, 0xff, 0xf5, 0xfa,
	 0xaf, 0xff, 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xfb, 0xff, 0xfa,
	 0xaf, 0xba, 0xdc, 0xff, 0xfa,
	 0xa0, 0xff, 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xcf, 0xff, 0xfa,
	 0xaf, 0xe5, 0xbf, 0xe8, 0xba,
	 0xd0,
	};
	
byte level18_data[] =
	{
	 0xd0,
	 0xa6, 0xe3, 0xfb, 0xe6, 0xbf, 0xf8, 0xe2, 0xfa,
	 0xaf, 0xff, 0xd2, 0xff, 0xfa, 0xff, 0xfb, 0xaf, 0xff, 0xfa, 0xaa, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xfb, 0xff, 0xaf, 0xfa, 0xff, 0xfa, 0xaf, 0xff, 0xfa, 0xbf, 0xaf, 0xff, 0xbf, 0xfa,
	 0xaf, 0xfa, 0xe3, 0xfa, 0xbf, 0xaf, 0xaf, 0xbf, 0xfa, 0xff, 0xa9, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xe2, 0xbf, 0xfa, 0xfa, 0xff, 0xaf, 0xff, 0xaf, 0xfb, 0xaf, 0xe2, 0xfa,
	 0xa7, 0xfa, 0xfb, 0xff, 0xaf, 0xfa, 0xaf, 0xfb, 0xaf, 0xfa, 0xd3, 0xe2, 0xfa,
	 0xaf, 0xff, 0xd2, 0xff, 0xfa, 0xe2, 0xaf, 0xfa, 0xe2, 0xfa, 0xe2, 0xba,
	 0xa5, 0xea, 0xbf, 0xe2, 0xf4, 0xfa,
	 0xaf, 0xe3, 0xfb, 0xea, 0xfa,
	 0xaf, 0xba, 0xde,
	 0xa2, 0xe7, 0xbf, 0xe4, 0xf3, 0xfc, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaa, 0xaf, 0xe2, 0xbf, 0xe7, 0xfb, 0xff, 0xf0, 0xfa,
	 0xab, 0xee, 0xfa,
	 0xd0,
	};

byte level19_data[] =
	{
	 0xd0,
	 0xa4, 0xf8, 0xe4, 0xfb, 0xe4, 0xf7, 0xf9, 0xff, 0xfc, 0xfa,
	 0xaf, 0xfb, 0xe3, 0xbf, 0xe2, 0xfb, 0xe6, 0xfa,
	 0xaf, 0xff, 0xd9, 0xaf, 0xe2, 0xfb, 0xfa,
	 0xaf, 0xff, 0xd9, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xff, 0xaa, 0xaf, 0xff, 0xd3, 0xaf, 0xff, 0xaa, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xff, 0xaa, 0xff, 0xfb, 0xd3, 0xaf, 0xff, 0xfa, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xfb, 0xaf, 0xe2, 0xd3, 0xaf, 0xbf, 0xff, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xff, 0xaf, 0xfb, 0xff, 0xd3, 0xaf, 0xe2, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xff, 0xaa, 0xe2, 0xd3, 0xaf, 0xff, 0xba, 0xaf, 0xe3, 0xfa,
	 0xa5, 0xff, 0xaa, 0xaf, 0xff, 0xd3, 0xaf, 0xff, 0xaa, 0xaf, 0xe2, 0xfb, 0xfa,
	 0xaf, 0xff, 0xd9, 0xa6, 0xe3, 0xfa,
	 0xaf, 0xff, 0xd9, 0xaf, 0xe3, 0xfa,
	 0xa3, 0xe3, 0xfb, 0xe3, 0xbf, 0xe4, 0xf2, 0xf0, 0xfa,
	 0xab, 0xe5, 0xbf, 0xe8, 0xfa,
	 0xd0,
	};
	
byte level20_data[] =
	{ 
	 0xa9, 0xe3, 0xba, 0xff, 0xfa, 0xd2, 0xff, 0xaf, 0xbf, 0xff, 0x5f, 0xff, 0xfa,
	 0xaf, 0xe3, 0xaa, 0xff, 0xfa, 0xaf, 0xaa, 0xff, 0xaa, 0xe4, 0xba,
	 0xaf, 0xe2, 0xfa, 0xfa, 0xff, 0xba, 0xaf, 0xaa, 0xff, 0xaf, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xfa, 0xff, 0xfa, 0xaf, 0xaa, 0xff, 0xab, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xfa, 0xff, 0xfa, 0xaf, 0xaa, 0xff, 0xaf, 0xab, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xe4, 0xf2, 0xe2, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xbf, 0xe2, 0xcf, 0xe2, 0xbf, 0xe3, 0xfb, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xe3, 0xf3, 0xe2, 0xaf, 0xe3, 0xfa,
	 0xa8, 0xe3, 0xaa, 0xff, 0xfb, 0xe3, 0xfa, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xaf, 0xaf, 0xfa, 0xd2, 0xff, 0xaf, 0xab, 0xe3, 0xfa,
	 0xaf, 0xfb, 0xe2, 0xaf, 0xaf, 0xfa, 0xaf, 0xaa, 0xff, 0xaf, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xaf, 0xba, 0xaf, 0xaa, 0xff, 0xaf, 0xaf, 0xe3, 0xaa,
	 0xaa, 0xe4, 0xaf, 0xfa, 0xaf, 0xaa, 0xff, 0xaf, 0xbf, 0xe3, 0xba,
	 0xa6, 0xfb, 0xe3, 0xf7, 0xfa, 0xaf, 0xaa, 0xe4, 0x4f, 0xf0, 0xfa,
	 0xaf, 0xe8, 0xfb, 0xe5, 0xfa,
	 0xd0,
	};
	
byte level21_data[] =
	{
	 0xd0,
	 0xa0, 0xff, 0x2f, 0xff, 0xbf, 0xe4, 0xbf, 0xf7, 0xe3, 0xf6, 0xfa,
	 0xaf, 0xe7, 0xd2, 0xaf, 0xe3, 0xbf, 0xfa,
	 0xd2, 0xe4, 0xfa, 0xd2, 0x5f, 0xfa, 0xaa, 0xe3, 0xfa,
	 0xac, 0xe4, 0xba, 0xd3, 0xe3, 0xaa, 0xe2, 0xfa,
	 0xaf, 0xe4, 0xd4, 0xfb, 0xe3, 0xaf, 0xff, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xd4, 0xe2, 0xfb, 0xff, 0xfa, 0xff, 0xfa,
	 0xaf, 0xe3, 0xba, 0xd4, 0xe4, 0xfa, 0xff, 0xfa,
	 0xab, 0xe3, 0xd5, 0xff, 0xbf, 0xe3, 0xaf, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xd4, 0xe4, 0xfa, 0x8b, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xd4, 0xe2, 0xfb, 0xff, 0xfa, 0xff, 0xfa,
	 0xaf, 0xe4, 0xd4, 0xe4, 0xab, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xd3, 0x4f, 0xe2, 0xaa, 0xe2, 0xfa,
	 0xaf, 0xff, 0x3f, 0xe2, 0xbf, 0xfa, 0xd2, 0xff, 0xfa, 0xaa, 0xe2, 0x9f, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe5, 0xd2, 0xab, 0xff, 0xfb, 0xe2, 0xfa,
	 0xd0,
	};
	
byte level22_data[] =
	{
	 0xd0,
	 0xab, 0xff, 0x6f, 0xe6, 0xf5, 0xe3, 0x0f, 0xf8, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xaa, 0xaf, 0xe5, 0xd2, 0xe2, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xfa, 0xaa, 0xe5, 0xab, 0xaa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xff, 0xcf, 0xff, 0xff, 0xbf, 0xe2, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xe7, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xff, 0x7f, 0xfa, 0xff, 0xfb, 0xe3, 0xf4, 0xff, 0xaf, 0xfb, 0xff, 0xf9, 0xba,
	 0xaf, 0xe2, 0xba, 0xe5, 0xbf, 0xff, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xff, 0xde,
	 0xaf, 0xbf, 0xaf, 0xfa, 0xfb, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xfb, 0xaf, 0xfa,
	 0xaf, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xba,
	 0xaf, 0xff, 0xaf, 0xba, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa,
	 0xaf, 0xff, 0xde,
	 0xa2, 0xe6, 0xbf, 0xe6, 0xf3, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe7, 0xbf, 0xe4, 0xfa,
	 0xd0,
	};
	
byte level23_data[] =
	{
	 0xd0,
	 0xa2, 0xfa, 0xaf, 0x6f, 0xe3, 0xbf, 0xe2, 0xf7, 0xff, 0xfb, 0xff, 0xf5, 0xfa,
	 0xaf, 0xff, 0xaa, 0xe8, 0xfa, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfc, 0xe3, 0x0f, 0xff, 0xaa, 0xe3, 0xfa,
	 0xaf, 0xe2, 0xaa, 0xe6, 0xfa, 0xaf, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xd2, 0xff, 0xd9, 0xff, 0xfa,
	 0xaf, 0xff, 0xba, 0xe4, 0xbf, 0xe4, 0xaf, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xd6, 0xff, 0xd5, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xaa, 0xaf, 0x8f, 0xe2, 0xd2, 0xe4, 0xfa,
	 0xaf, 0xff, 0xbf, 0xfa, 0xaa, 0xaf, 0xe3, 0xd2, 0xe4, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xaa, 0xaf, 0xe3, 0xd2, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xff, 0xbf, 0xfa, 0xaa, 0xaf, 0xe3, 0xd2, 0xe4, 0xba,
	 0xaf, 0xe2, 0xfa, 0xaa, 0xaf, 0xe3, 0xd2, 0xe4, 0xfa,
	 0xa3, 0xe2, 0xfa, 0xaa, 0xaf, 0x9f, 0xe2, 0xd2, 0xe3, 0xf4, 0xfa,
	 0xab, 0xe2, 0xfa, 0xaa, 0xaf, 0xe2, 0xbf, 0xd2, 0xe2, 0xbf, 0xff, 0xfa,
	 0xd0,
	};
	
byte level24_data[] =
	{
	 0xd0,
	 0xaf, 0xf0, 0xe4, 0xf6, 0xff, 0xbf, 0xe5, 0xfc, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe3, 0xaf, 0xe2, 0xbf, 0xff, 0xbf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xfb, 0xff, 0xaf, 0xff, 0xbf, 0xe2, 0xfb, 0xff, 0xaf, 0xff, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xff, 0xbf, 0xff, 0xaf, 0xbf, 0xff, 0xfa, 0xe2, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xe2, 0xaf, 0xe4, 0xaf, 0xe2, 0xfa,
	 0xa4, 0xe7, 0xbf, 0xbf, 0xe3, 0xbf, 0xf5, 0xfa,
	 0xaf, 0xff, 0x9f, 0xbf, 0xfb, 0xff, 0xbf, 0xff, 0xaf, 0xaf, 0xff, 0x2f, 0xff, 0xaf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xfa, 0xff, 0xaf, 0xbf, 0xe2, 0xbf, 0xe2, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xbf, 0xe2, 0xaf, 0xff, 0xbf, 0xaf, 0xe2, 0xfa, 0xfb, 0xfa,
	 0xaf, 0xff, 0xaf, 0xff, 0xaf, 0xbf, 0xff, 0xbf, 0xff, 0xaf, 0xe2, 0xbf, 0xff, 0xfa, 0xfa,
	 0xaf, 0xe4, 0xaf, 0xff, 0xaf, 0xe2, 0xbf, 0xff, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xbf, 0xff, 0xfb, 0xe4, 0xbf, 0xff, 0xaf, 0xe3, 0xbf, 0xfa,
	 0xaf, 0xaf, 0x8f, 0xfa, 0xff, 0xbf, 0xf7, 0xff, 0xaf, 0xe2, 0x3f, 0xbf, 0xff, 0xaf, 0xfa,
	 0xaf, 0xe4, 0xaf, 0xe6, 0xaf, 0xe2, 0xfa,
	 0xd0,
	}; 
	
byte level25_data[] =
	{
	 0xd0,
	 0xa6, 0xe4, 0xbf, 0xe3, 0xfb, 0xe3, 0xbf, 0xf7, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe4, 0xbf, 0xe7, 0xfa,
	 0xaf, 0xfa, 0xd6, 0xaf, 0xe6, 0xfa,
	 0xaf, 0xfa, 0xd7, 0xaf, 0xff, 0xbf, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xf2, 0xff, 0xda, 0xe2, 0xfa,
	 0xaf, 0xe3, 0xd8, 0xe3, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xfb, 0xd4, 0xa8, 0xff, 0xfb, 0xe2, 0xf9, 0xfa,
	 0xaf, 0xe4, 0xd4, 0xbf, 0xe5, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xd4, 0xaf, 0xe5, 0xfa,
	 0xaf, 0xe2, 0x0f, 0xd6, 0xff, 0xcf, 0xe3, 0xfa,
	 0xaf, 0xe3, 0xd6, 0xaf, 0xe2, 0xfb, 0xff, 0xfa,
	 0xaf, 0xfa, 0xda, 0xe3, 0xfa,
	 0xa5, 0xf3, 0xe4, 0xfb, 0xe3, 0xfb, 0xe3, 0xf4, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe9, 0xfb, 0xff, 0xfa,
	 0xd0,
	};
	
byte level26_data[] =
	{
	 0xd2, 0x2f, 0xd2, 0x4f, 0xd2, 0x6f, 0xd2, 0x8f, 0xd4,
	 0xab, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xff, 0xf0, 0xfa,
	 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xff, 0xfa, 0xaa,
	 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xbf, 0xab, 0xe2, 0xba,
	 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xe2, 0xaa,
	 0xaf, 0xff, 0x3f, 0xff, 0xfa, 0xfb, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xfa, 0xff, 0xaf, 0xfa, 0xbf, 0xaf, 0xfa, 0xff, 0xaf, 0xff, 0xfb, 0xfa,
	 0xaf, 0xfa, 0xaa, 0xaf, 0xff, 0x5f, 0xff, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xab, 0xff, 0xfa, 0xaa,
	 0xaf, 0xe4, 0xbf, 0xff, 0xfa, 0xff, 0xaf, 0xfa, 0xfb, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xbf, 0xe2, 0xfa, 0xaa, 0xaf, 0xff, 0x7f, 0xff, 0xfa, 0xff, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xe8, 0xbf, 0xfa, 0xff, 0xab, 0xe2, 0xaa,
	 0xac, 0xe5, 0xfb, 0xfa, 0xaa, 0xaf, 0xff, 0x9f, 0xe3, 0xfa,
	 0xaf, 0xff, 0xfb, 0xeb, 0xbf, 0xfa,
	 0xd0,
	};

	
byte level27_data[] =
	{
	 0xd0,
	 0xa2, 0xe7, 0xbf, 0xe5, 0xf3, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xbf, 0xe6, 0xbf, 0xe3, 0xfa,
	 0xa6, 0xe2, 0xfa, 0xa4, 0xe5, 0xf5, 0xfa, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xe2, 0xba, 0xaf, 0xe4, 0xfb, 0xff, 0xfa, 0xaf, 0xe2, 0xba,
	 0xaf, 0xff, 0xfa, 0xaa, 0xa0, 0xe6, 0xfa, 0xaa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xba, 0xaa, 0xaf, 0xff, 0xfb, 0xe2, 0xfb, 0xff, 0xfa, 0xaa, 0xab, 0xff, 0xfa,
	 0xab, 0xfa, 0xdc, 0xaf, 0xfa,
	 0xaf, 0xfa, 0xdc, 0xaf, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaa, 0xaf, 0xe2, 0xbf, 0xe2, 0xfc, 0xfa, 0xaa, 0xab, 0xff, 0xfa,
	 0xaf, 0xfb, 0xfa, 0xaa, 0xaf, 0xe5, 0xff, 0xfa, 0xaa, 0xaf, 0xff, 0xfa,
	 0xab, 0xe2, 0xfa, 0xa8, 0xe5, 0xf9, 0xfa, 0xaf, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xaf, 0xfb, 0xe2, 0xfb, 0xe2, 0xfa, 0xaf, 0xe2, 0xfa,
	 0xa7, 0xe2, 0xbf, 0xe8, 0xbf, 0xff, 0xfb, 0xfa,
	 0xaf, 0xe6, 0xbf, 0xe2, 0xbf, 0xe3, 0xfa, 0xaa,
	 0xd0,
	};

	
byte level28_data[] =
	{
	 0xd0,
	 0xaf, 0xff, 0xf6, 0xe3, 0xbf, 0xff, 0xf5, 0xe4, 0xf2, 0xff, 0xfa,
	 0xa8, 0xe9, 0xfb, 0xff, 0xaa, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfa, 0xaf, 0xaa, 0xff, 0xbf, 0xff, 0xfa, 0xaf, 0xfa, 0xaa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xaa, 0xe3, 0xfa, 0xaf, 0xfa, 0xaa, 0xaf, 0xff, 0xfa,
	 0xab, 0xfa, 0xaf, 0xba, 0xaf, 0xaa, 0xe3, 0xfa, 0xaf, 0xff, 0xaa, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xff, 0xbf, 0xfa, 0xaf, 0xe2, 0xfb, 0xff, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xe2, 0xfa, 0xaf, 0xbf, 0xe3, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfa, 0xaf, 0xfa, 0xaf, 0xff, 0xff, 0xfa, 0xaf, 0xff, 0xfa, 0xe2, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xaf, 0xff, 0xaa, 0xff, 0xbf, 0xfa, 0xaf, 0xff, 0xaa, 0xff, 0xfb, 0xfa,
	 0xaf, 0xff, 0xbf, 0xfa, 0xaf, 0xff, 0xaa, 0xe2, 0xfa, 0xaf, 0xff, 0xaa, 0xe2, 0xfa,
	 0xa9, 0xe2, 0xfa, 0xaf, 0xff, 0xaa, 0xe2, 0xfa, 0xaf, 0xff, 0xaa, 0xff, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xaf, 0xbf, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xaa, 0xe2, 0xfa,
	 0xac, 0xff, 0xf7, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xf4, 0xfa, 0xaf, 0xbf, 0xfa, 0xf3, 0xf0, 0xfa,
	 0xaf, 0xfb, 0xff, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xe4, 0xfa,
	 0xd0,
	};
	
byte level29_data[] =
	{
	 0xd0,
	 0xa2, 0xe8, 0x9f, 0xe4, 0xf3, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xff, 0xbf, 0xe5, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xff, 0xd4, 0xaf, 0xe8, 0xfa,
	 0xab, 0xe2, 0xfb, 0xe2, 0xfb, 0xe4, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xe4, 0xd3, 0xaf, 0x8f, 0xfa, 0xd3, 0xab, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe3, 0xf6, 0xe5, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xd4, 0xaf, 0xff, 0xfa, 0xd2, 0xaf, 0xe3, 0xfa,
	 0xa5, 0xe8, 0xbf, 0xe4, 0xf4, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe2, 0xbf, 0xe6, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xd4, 0xf7, 0xe4, 0xd2, 0xaf, 0xff, 0xfa,
	 0xab, 0xe2, 0xfb, 0xe5, 0xfb, 0xff, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xe4, 0xd9, 0xff, 0xfa,
	 0xa0, 0xe8, 0xbf, 0xe4, 0xfc, 0xfa,
	 0xaf, 0xe3, 0xfb, 0xea, 0xfa,
	 0xd0,
	};
	
byte level30_data[] =
	{
	 0xd0,
	 0xa6, 0xf4, 0xe2, 0xbf, 0xe5, 0xfb, 0xe3, 0xf5, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe2, 0xfb, 0xe2, 0xaf, 0xe3, 0xaf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xaf, 0x8f, 0xe3, 0xfa, 0xaa, 0xe2, 0xfa, 0xaa, 0xff, 0xfa,
	 0xaf, 0xfb, 0xfa, 0xaa, 0xe3, 0xbf, 0xff, 0xaf, 0xff, 0xfb, 0xff, 0xaf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xe2, 0xaf, 0xff, 0xfa, 0xfa, 0xe2, 0xfa, 0xfa, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xfa, 0xff, 0xfa, 0xaa, 0xfb, 0xe3, 0xbf, 0xe3, 0xfa,
	 0xaf, 0xfb, 0xe4, 0xaf, 0xff, 0xfa, 0xe4, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xff, 0xfa, 0xfa, 0xff, 0xaa, 0xaf, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe5, 0xfa, 0xe3, 0xaf, 0xff, 0xbf, 0xfa,
	 0xaf, 0xe5, 0xaf, 0xff, 0xaf, 0xaf, 0xff, 0xfa, 0xaa, 0xe2, 0xfa,
	 0xa7, 0xe2, 0xaf, 0xff, 0xfa, 0xaa, 0xbf, 0xe4, 0xaf, 0xbf, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaa, 0xe2, 0xaf, 0xe3, 0xbf, 0xfa, 0xfa, 0xe2, 0xfa,
	 0xa0, 0xe2, 0xaf, 0x9f, 0xfa, 0xfa, 0x2f, 0xbf, 0xe4, 0xf3, 0xfc, 0xfa,
	 0xaf, 0xff, 0xfa, 0xfa, 0xe7, 0xfb, 0xe3, 0xfa,
	 0xd0,
	};

byte level31_data[] =
	{
	 0xd0,
	 0xa8, 0xe5, 0xbf, 0xe8, 0xfa,
	 0xaf, 0xfb, 0xff, 0xfa, 0xd8, 0xaf, 0xff, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xaa, 0x6f, 0xe7, 0xaa, 0xe2, 0xfa,
	 0xaf, 0xff, 0xfa, 0xfa, 0xe2, 0xfa, 0xaa, 0xaf, 0xff, 0xfb, 0xff, 0xaf, 0xaf, 0xff, 0xfa,
	 0xa9, 0xff, 0xaf, 0xba, 0xe2, 0xfa, 0xff, 0xaf, 0xe3, 0xaf, 0xfa, 0xfb, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfa, 0x7b, 0xff, 0xfa, 0xff, 0xaf, 0xff, 0x0f, 0xff, 0xaf, 0xff, 0xaf, 0xfa,
	 0xaf, 0xaf, 0xfa, 0xfa, 0xe2, 0xfa, 0xbf, 0xaf, 0xe3, 0xaf, 0xff, 0xfa, 0xfa,
	 0xaa, 0xff, 0xaa, 0xfa, 0xd8, 0xaf, 0xbf, 0xff, 0xaa,
	 0xaf, 0xfa, 0xfa, 0xa5, 0xe7, 0xf4, 0xfa, 0xe2, 0xfa,
	 0xab, 0xfa, 0xba, 0xe5, 0xfb, 0xe4, 0xaf, 0xfb, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xff, 0xfb, 0xe2, 0xcf, 0xe2, 0xfb, 0xe2, 0xfa, 0xff, 0xfa,
	 0xaf, 0xfa, 0xec, 0xaf, 0xfa,
	 0xaf, 0xa2, 0xe2, 0xbf, 0xe5, 0xbf, 0xe2, 0xf3, 0xfa, 0xfa,
	 0xaa, 0xe6, 0xbf, 0xe7, 0xaa,
	 0xd0,
	};

byte level32_data[] =
	{
	 0xd0,
	 0xa9, 0xe6, 0xbf, 0xe6, 0xf8, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe6, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xfa, 0xd7, 0xaf, 0xe3, 0xbf, 0xff, 0xfa,
	 0xaf, 0xff, 0xaf, 0xe5, 0xf2, 0xfa, 0xe5, 0xfa,
	 0xaf, 0xff, 0xfa, 0xe2, 0xbf, 0xe4, 0xaf, 0xe4, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xe4, 0xbf, 0xff, 0xfa, 0xf0, 0xe2, 0xbf, 0xfa,
	 0xaf, 0xbf, 0xff, 0xfa, 0xf4, 0xe2, 0xbf, 0xe2, 0x5f, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xe6, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xe7, 0xaf, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xcf, 0xe2, 0xaf, 0xff, 0xbf, 0xf3, 0xff, 0xfb, 0xff, 0xfa, 0xe2, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xe7, 0xaf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe2, 0xd8, 0xff, 0xfa,
	 0xa6, 0xe4, 0xfb, 0xe2, 0xfb, 0xe5, 0xf7, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe8, 0xfb, 0xe3, 0xfa,
	 0xd0,
	};

byte level33_data[] =
	{
	 0xd0,
	 0xa4, 0xe6, 0xbf, 0xe6, 0xf5, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xbf, 0xe6, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xe5, 0xd3, 0xaf, 0xe4, 0xf2, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xd6, 0xaf, 0xff, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xbf, 0xfa, 0xaa, 0xba, 0xd6, 0xe4, 0xfa,
	 0xaf, 0xff, 0xd9, 0xaf, 0xe2, 0xbf, 0xfa,
	 0xaf, 0xff, 0xdc, 0xaf, 0xfa,
	 0xaf, 0xff, 0xdb, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xd8, 0xfa, 0xaf, 0xff, 0xbf, 0xfa,
	 0xaf, 0xe3, 0xd6, 0xff, 0xfa, 0xaa, 0xaf, 0xf3, 0xfa,
	 0xa9, 0xff, 0xbf, 0xe2, 0x8f, 0xd3, 0xff, 0xfb, 0xff, 0xaa, 0xaf, 0xff, 0xba,
	 0xaf, 0xe3, 0xbf, 0xea, 0xaa,
	 0xac, 0xf6, 0xe5, 0xbf, 0xe2, 0xfb, 0xe2, 0xf7, 0xf0, 0xfa,
	 0xaf, 0xe3, 0xfb, 0xe3, 0xfb, 0xe6, 0xfa,
	 0xd0,
	};

byte level34_data[] =
	{
	 0xd0,
	 0xa8, 0xe2, 0x3f, 0xe8, 0xf6, 0xe2, 0xfa,
	 0xaf, 0xe7, 0xfb, 0xe6, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xd4, 0xe5, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xbf, 0xe6, 0xbf, 0xe3, 0xfa,
	 0xaf, 0xff, 0xfa, 0xd2, 0xaf, 0xe4, 0xd2, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe8, 0xfb, 0xe5, 0xba,
	 0xaf, 0xee, 0xaa,
	 0xa4, 0xed, 0xf5, 0xfa,
	 0xab, 0xe4, 0xbf, 0xe9, 0xfa,
	 0xa9, 0xee, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xa0, 0xe2, 0x2f, 0xe8, 0xf7, 0xff, 0xfc, 0xfa,
	 0xaf, 0xeb, 0xbf, 0xe2, 0xfa,
	 0xd4, 0xe8, 0xd4,
	};

byte level35_data[] =
	{
	 0xd0,
	 0xac, 0xe4, 0xfb, 0x8f, 0xe6, 0xfb, 0xf9, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe2, 0xaa, 0xe3, 0xfb, 0xe5, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xfa, 0xaf, 0xe7, 0xf6, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xfa, 0xfa, 0xaf, 0xe5, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xfa, 0xfa, 0xfb, 0xe3, 0xfa, 0xaa, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xff, 0xfa, 0xfa, 0xe2, 0xfb, 0xe2, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaa, 0xff, 0xfa, 0x2f, 0xaf, 0xe7, 0xaa,
	 0xab, 0xfa, 0xa5, 0xfa, 0xfb, 0xfa, 0xff, 0xaf, 0xe5, 0xfb, 0xff, 0xfa,
	 0xaa, 0xaf, 0xff, 0xfa, 0xff, 0xfa, 0xff, 0xfa, 0xfb, 0xe5, 0xbf, 0xfa,
	 0xaf, 0xaf, 0xff, 0xfa, 0xff, 0xfa, 0xe2, 0xaf, 0xe2, 0xfb, 0xff, 0xaa, 0xff, 0xfa,
	 0xaf, 0xaf, 0xff, 0xfa, 0xfb, 0xfa, 0xff, 0xbf, 0xaa, 0xe6, 0xfa,
	 0xaf, 0xaf, 0xff, 0xfa, 0xff, 0xfa, 0xe2, 0xaf, 0xaf, 0xe5, 0xfa,
	 0xab, 0xaf, 0xf4, 0xfa, 0xff, 0xfa, 0x3f, 0xff, 0xa0, 0xfa, 0xaf, 0xe3, 0xf7, 0xfa,
	 0xaf, 0xaf, 0xbf, 0xfa, 0xff, 0xfa, 0xe2, 0xaf, 0xff, 0xfa, 0xaa, 0xe3, 0xfa,
	 0xd0,
	};

byte level36_data[] =
	{
	 0xd0,
	 0xaf, 0xe4, 0xbf, 0xf8, 0xfc, 0xf2, 0xff, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe2, 0xf0, 0xe3, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xee, 0xfa,
	 0xaf, 0xe6, 0xfa, 0xaf, 0xe6, 0xfa,
	 0xaf, 0xe3, 0xfb, 0xe2, 0xfa, 0xaf, 0xe2, 0xbf, 0xe3, 0xfa,
	 0xaf, 0xe6, 0xfa, 0xaf, 0xe6, 0xfa,
	 0xaf, 0xe6, 0xfa, 0xaf, 0xe6, 0xfa,
	 0xa4, 0xe5, 0xb5, 0xfa, 0xa7, 0xfb, 0xe4, 0xf6, 0xfa,
	 0xaf, 0xbf, 0xe5, 0xfa, 0xaf, 0xe5, 0xfb, 0xfa,
	 0xaf, 0xe6, 0xfa, 0xaf, 0xe6, 0xfa,
	 0xaf, 0xe6, 0xfa, 0xaf, 0xe6, 0xfa,
	 0xaf, 0xfb, 0xe4, 0xf9, 0xfa, 0xa3, 0xe5, 0xbf, 0xfa,
	 0xaf, 0xe5, 0xbf, 0xfa, 0xaf, 0xfb, 0xe5, 0xfa,
	 0xd0,
	};

byte level37_data[] =
	{
	 0xd0,
	 0xaa, 0xff, 0xf4, 0xe8, 0xbf, 0xff, 0xf5, 0xf6, 0xfa,
	 0xaf, 0xaa, 0xe4, 0xaa, 0xaf, 0xfb, 0xe6, 0xfa,
	 0xa2, 0xff, 0xaa, 0xe2, 0xaa, 0xff, 0xfa, 0xe7, 0xfa,
	 0xaf, 0xe2, 0xaa, 0xaf, 0xff, 0xbf, 0xfa, 0xe3, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xff, 0xbf, 0xff, 0xaa, 0xe2, 0xfa, 0xe5, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xff, 0xaa, 0xff, 0xaf, 0xff, 0xbf, 0xe5, 0xfa,
	 0xaf, 0xfb, 0xff, 0xaf, 0xfb, 0xff, 0xaa, 0xe4, 0xaa, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xe2, 0xaa, 0xff, 0xfa, 0xff, 0xaa, 0xe2, 0xaa, 0xff, 0xfa, 0xe2, 0xfa,
	 0xaf, 0xe3, 0xaa, 0xaf, 0xe2, 0xaa, 0xaf, 0xff, 0xfb, 0xfa, 0xe2, 0xba,
	 0xaf, 0xe5, 0xbf, 0xe2, 0xaa, 0xe2, 0xfa, 0xe2, 0xfa,
	 0xaf, 0xfb, 0xe2, 0xbf, 0xe3, 0xfa, 0xff, 0xaa, 0xff, 0xaf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xaf, 0xe5, 0xaf, 0xfb, 0xff, 0xaa, 0xe3, 0xfa,
	 0xa3, 0xf8, 0xe2, 0xcf, 0xe2, 0x9f, 0xaa, 0xff, 0xfa, 0x0f, 0xaa, 0xff, 0xf7, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xe3, 0xaa, 0xaf, 0xe2, 0xaa, 0xff, 0xfa,
	 0xd0,
	};

byte level38_data[] =
	{
	 0xd0,
	 0xa3, 0xe2, 0xbf, 0xe2, 0x8f, 0xff, 0xcf, 0xff, 0xbf, 0xe4, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaf, 0xe8, 0xaa, 0xff, 0xfb, 0xfa,
	 0xaf, 0xff, 0xd2, 0xe3, 0xfb, 0xe3, 0xfa, 0xaa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xd2, 0xaf, 0xe6, 0xd3, 0xff, 0xfa,
	 0xaf, 0xfa, 0xd2, 0xaf, 0xfb, 0xe4, 0xbf, 0xd3, 0xff, 0xfa,
	 0xaf, 0xfa, 0xd4, 0xe3, 0xfa, 0xd4, 0xff, 0xfa,
	 0xaf, 0xfa, 0xd4, 0xff, 0xaa, 0xff, 0xfa, 0xd4, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xfa, 0xaa, 0xaf, 0xe2, 0x4f, 0xe3, 0xfa,
	 0xaf, 0xe5, 0xd3, 0xe5, 0xf0, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe3, 0xd3, 0xe6, 0xfa,
	 0xa2, 0xe3, 0xfa, 0xd4, 0xe2, 0xfb, 0xe2, 0xfa, 0xaa,
	 0xaf, 0xe3, 0xfa, 0xd4, 0xe4, 0xbf, 0xff, 0xfa,
	 0xa6, 0xff, 0xfb, 0xe3, 0x9f, 0xe4, 0x5f, 0xe2, 0xf7, 0xfa,
	 0xaf, 0xe6, 0xfb, 0xe7, 0xba,
	 0xd0,
	};

byte level39_data[] =
	{
	 0xd0,
	 0xa9, 0xbf, 0xe5, 0xbf, 0xe5, 0xbf, 0xf8, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe6, 0xbf, 0xe3, 0xfa,
	 0xaf, 0xba, 0xd5, 0xaf, 0xfa, 0xd5, 0xaf, 0xfa,
	 0xaf, 0xfa, 0xd5, 0xaf, 0xba, 0xd5, 0xaf, 0xba,
	 0xab, 0xfa, 0xa2, 0xe2, 0xbf, 0xe5, 0xfb, 0xf3, 0xfa, 0xaf, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xff, 0xbf, 0xe2, 0xbf, 0xff, 0xfb, 0xe3, 0xfa, 0xaf, 0xfa,
	 0xaf, 0xb0, 0xff, 0xfa, 0xd8, 0xaf, 0xfc, 0xfb, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xd8, 0xaf, 0xe2, 0xfa,
	 0xab, 0xfa, 0xa5, 0xff, 0xfb, 0xe4, 0xfb, 0xe2, 0xf4, 0xfa, 0xaf, 0xfa,
	 0xaf, 0xfa, 0xab, 0xe3, 0xfb, 0xe4, 0xfb, 0xff, 0xfa, 0xaf, 0xba,
	 0xaf, 0xba, 0xd5, 0xaf, 0xfa, 0xd5, 0xaf, 0xfa,
	 0xaf, 0xfa, 0xd5, 0xaf, 0xfa, 0xd5, 0xaf, 0xfa,
	 0xa6, 0xe3, 0xfb, 0xe5, 0xfb, 0xe3, 0xf7, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe4, 0xfb, 0xe5, 0xbf, 0xff, 0xfa,
	 0xd0,
	};

byte level40_data[] =
	{
	 0xd0,
	 0xa2, 0xe4, 0xfb, 0xe4, 0xbf, 0xff, 0x4f, 0xfb, 0xf3, 0xfa,
	 0xaf, 0xff, 0xfb, 0xec, 0xfa,
	 0xaf, 0xfa, 0xaa, 0xa8, 0xff, 0xe3, 0x9f, 0xd3, 0xe3, 0xfa,
	 0xaf, 0xfa, 0xaa, 0xaf, 0xff, 0xe2, 0xbf, 0xff, 0xd3, 0xe2, 0xbf, 0xfa,
	 0xaf, 0xff, 0xfa, 0xa6, 0xe7, 0xaa, 0xe3, 0xfa,
	 0xaf, 0xbf, 0xfa, 0xaf, 0xe4, 0xcf, 0xe2, 0xaa, 0xff, 0xaa, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xbf, 0xe7, 0xaa, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xbf, 0xff, 0x0f, 0xff, 0xbf, 0xaa, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xaf, 0xe6, 0xaa, 0xff, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe2, 0xfa, 0xaa, 0xaf, 0xff, 0xd2, 0xe2, 0xaa, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xaa, 0xaf, 0xff, 0xd2, 0xfb, 0xff, 0xaa, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xaf, 0xbf, 0xff, 0xd2, 0xe2, 0xaa, 0xff, 0xfa,
	 0xaf, 0xbf, 0xff, 0xf7, 0xff, 0xfa, 0xaf, 0xe2, 0xd2, 0xff, 0x5f, 0xaa, 0xfb, 0xfa,
	 0xaf, 0xe8, 0xbf, 0xe5, 0xfa,
	 0xd0,
	};

byte level41_data[] =
	{
	 0xd0,
	 0xa6, 0xe6, 0xfb, 0xe2, 0xfb, 0xe3, 0xf2, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe2, 0xd2, 0xe2, 0xfa, 0xe2, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfb, 0xe3, 0xfa, 0xd2, 0xaf, 0x8f, 0xe4, 0xf9, 0xfa,
	 0xaf, 0xe4, 0xd4, 0xe6, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xaa, 0xaf, 0xd2, 0xfa, 0xaf, 0xe2, 0xbf, 0xfb, 0xff, 0xfa,
	 0xab, 0xe2, 0xfa, 0xaa, 0xfb, 0xaa, 0xaf, 0xba, 0xaa, 0xe5, 0xfa,
	 0xaf, 0xe2, 0xd6, 0xa4, 0xe4, 0xf5, 0xfa,
	 0xaf, 0xff, 0xfa, 0xd6, 0xe2, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xff, 0xfa, 0xd6, 0xfb, 0xe5, 0xba,
	 0xa7, 0xff, 0xfb, 0xd6, 0xaf, 0xe3, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xd7, 0xff, 0xbf, 0xe3, 0xfa,
	 0xde, 0xaf, 0xfa,
	 0xaf, 0x0f, 0xcf, 0xe4, 0xfb, 0xe5, 0xbf, 0xf3, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe6, 0xfb, 0xe4, 0xfa,
	 0xd0,
	};

byte level42_data[] =
	{
	 0xd0,
	 0xa4, 0xe2, 0xbf, 0xe3, 0xbf, 0xe4, 0xbf, 0xff, 0xf5, 0xfa,
	 0xaf, 0xfb, 0xe3, 0xbf, 0xe4, 0xbf, 0xe4, 0xfa,
	 0xaf, 0xfa, 0xde,
	 0xab, 0xe6, 0x6f, 0xe5, 0x8f, 0xff, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe4, 0xbf, 0xe2, 0xfb, 0xe3, 0xfa,
	 0xaa, 0xe3, 0xfb, 0xe4, 0xfb, 0xe3, 0xfb, 0xff, 0xfa,
	 0xaf, 0xff, 0xfa, 0xd3, 0xaf, 0xff, 0xfa, 0xd3, 0xaf, 0xff, 0xfa, 0xaa,
	 0xab, 0xff, 0xfa, 0xd3, 0xaf, 0xff, 0xfa, 0xd3, 0xaf, 0xff, 0xfa, 0xaa,
	 0xaf, 0xe3, 0xbf, 0xe3, 0xfb, 0xe2, 0xfb, 0xe2, 0xfb, 0xfa,
	 0xaa, 0xe6, 0x7f, 0xe5, 0x9f, 0xff, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe2, 0xfb, 0xe4, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xfa, 0xdc, 0xaf, 0xfa,
	 0xa0, 0xf3, 0xfb, 0xe5, 0xbf, 0xe4, 0xfc, 0xf2, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xe5, 0xbf, 0xe3, 0xfa,
	 0xd0,
	};

byte level43_data[] =
	{
	 0xd0,
	 0xa8, 0xe6, 0xfb, 0xe5, 0xfb, 0xf9, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xea, 0xfa,
	 0xab, 0xfa, 0xd8, 0xe5, 0xfa,
	 0xaf, 0xfa, 0xff, 0xf6, 0xe2, 0x5f, 0xff, 0xf2, 0xfa, 0xe5, 0xba,
	 0xaf, 0xfa, 0xbf, 0xe6, 0xfa, 0xff, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xfa, 0xaa, 0xaf, 0xe3, 0xbf, 0xff, 0xfa, 0xe5, 0xfa,
	 0xaf, 0xfa, 0xe7, 0xfa, 0xe3, 0xbf, 0xff, 0xfa,
	 0xaf, 0xba, 0xbf, 0xfb, 0xe4, 0xfb, 0xe3, 0xfa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xaa, 0xaf, 0xeb, 0xfa,
	 0xaf, 0xfa, 0xfb, 0xf7, 0xff, 0xbf, 0x4f, 0xbf, 0xf3, 0xfa, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xfa, 0xff, 0xfb, 0xe2, 0xbf, 0xe2, 0xfa, 0xaf, 0xe3, 0xfa, 0xaa,
	 0xaf, 0xfa, 0xd8, 0xfa, 0xbf, 0xff, 0x0f, 0xff, 0xfa,
	 0xaf, 0xfc, 0xe4, 0xfb, 0xe4, 0xaf, 0xe3, 0xfa,
	 0xaf, 0xe3, 0xfb, 0xe3, 0xfb, 0xe2, 0xfa, 0xe3, 0xba,
	 0xd0,
	};

byte level44_data[] =
	{
	 0xd0,
	 0xa5, 0xe2, 0xcf, 0xea, 0xf4, 0xfa,
	 0xaf, 0xe4, 0xbf, 0xe3, 0xfb, 0xff, 0xbf, 0xe3, 0xfa,
	 0xa8, 0xff, 0xfa, 0xda, 0xaf, 0xff, 0xfa,
	 0xaf, 0xff, 0xdc, 0xbf, 0xfa,
	 0xaf, 0xfa, 0xdc, 0xaf, 0xfa,
	 0xaf, 0xff, 0xa2, 0xe4, 0xbf, 0xe4, 0xf3, 0xfa, 0xff, 0xfa,
	 0xaf, 0xff, 0xaf, 0xea, 0xfa, 0xff, 0xfa,
	 0xaf, 0xff, 0xaf, 0xfa, 0xaa, 0xff, 0xfa, 0xd2, 0xe2, 0xaa, 0xaf, 0xfa, 0xfb, 0xfa,
	 0xaf, 0xff, 0xaf, 0xfa, 0xba, 0xff, 0xfa, 0xff, 0xfa, 0xe2, 0xab, 0xaf, 0xfa, 0xff, 0xfa,
	 0xaf, 0xff, 0xaf, 0xfa, 0xaa, 0xff, 0xfa, 0xff, 0xfa, 0xe2, 0xaa, 0xaf, 0xfa, 0xff, 0xfa,
	 0xa9, 0xff, 0xaf, 0xbf, 0xe2, 0xfa, 0xbf, 0xfa, 0xe4, 0xba, 0xff, 0xba,
	 0xaf, 0xff, 0xdc, 0xff, 0xfa,
	 0xa0, 0xf6, 0xec, 0xf7, 0xfa,
	 0xaf, 0xee, 0xba,
	 0xd0,
	};

byte level45_data[] =
	{
	 0xd0,
	 0xa2, 0xe6, 0xfb, 0xe4, 0xbf, 0xff, 0xf3, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xeb, 0xfa,
	 0xaf, 0xfa, 0xd2, 0xe6, 0xaa, 0xaf, 0xe3, 0xba,
	 0xaf, 0xff, 0x4f, 0xe3, 0xbf, 0xe3, 0xf6, 0xe2, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe8, 0xbf, 0xff, 0xfa, 0xd2, 0xaf, 0xfa,
	 0xaa, 0xe2, 0xbf, 0xeb, 0xfa,
	 0xaf, 0xe8, 0xfb, 0xe3, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe2, 0xcf, 0xe5, 0xaa, 0xaf, 0xfa,
	 0xaa, 0xe9, 0xf7, 0xe2, 0xf8, 0xff, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe6, 0xbf, 0xff, 0xfb, 0xff, 0xfb, 0xfa,
	 0xaf, 0xe4, 0xbf, 0xe3, 0xfa, 0xd3, 0xaf, 0xff, 0xfa,
	 0xaa, 0xee, 0xfa,
	 0xaf, 0xff, 0x5f, 0xe4, 0x0f, 0xe2, 0xbf, 0xe2, 0xf9, 0xff, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xeb, 0xba,
	 0xd0,
	};

byte level46_data[] =
	{
	 0xd0,
	 0xab, 0xe2, 0xf8, 0xe3, 0xfb, 0xe2, 0xf2, 0xff, 0xfb, 0xff, 0xf5, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xd5, 0xaf, 0xe4, 0xfa,
	 0xaf, 0xfb, 0xff, 0xbf, 0xfa, 0xaf, 0x6f, 0xff, 0x7f, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xff, 0xfa, 0xfa, 0xe2, 0xfb, 0xaf, 0xaf, 0xff, 0xfb, 0xe2, 0xfa,
	 0xab, 0xe3, 0xfa, 0xff, 0xd3, 0xff, 0xaf, 0xe4, 0xfa,
	 0xaf, 0xfb, 0xff, 0xbf, 0xfa, 0xfb, 0xaf, 0xff, 0xfa, 0xbf, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xf9, 0xfa, 0xff, 0xaf, 0xcf, 0xfa, 0xff, 0xaf, 0xbf, 0xff, 0xfb, 0xff, 0xfa,
	 0xab, 0xe3, 0xfa, 0xff, 0xaf, 0xff, 0xfa, 0xfb, 0xaf, 0xe4, 0xba,
	 0xaf, 0xfb, 0xe2, 0xfa, 0xbf, 0xaf, 0xbf, 0xfa, 0xff, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xab, 0xff, 0xfa, 0xff, 0xd3, 0xff, 0xab, 0xe4, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xfa, 0xfa, 0xff, 0xbf, 0xff, 0xaf, 0xaf, 0xe2, 0xfb, 0xff, 0xfa,
	 0xaf, 0xfb, 0xe2, 0xfa, 0xaf, 0xff, 0xfb, 0xff, 0xfa, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xff, 0xfa, 0xd5, 0xa3, 0xff, 0xf0, 0xff, 0xf4, 0xfa,
	 0xab, 0xe2, 0xbf, 0xe4, 0xbf, 0xff, 0xfb, 0xe3, 0xbf, 0xfa,
	 0xd0,
	};

byte level47_data[] =
	{
	 0xd0,
	 0xa6, 0xe5, 0x7f, 0xe2, 0xfb, 0xe2, 0xfb, 0xff, 0xf4, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xe3, 0xd2, 0xe6, 0xfa,
	 0xaf, 0xff, 0xd2, 0xe2, 0xaa, 0xe2, 0xaa, 0xe2, 0xd2, 0xff, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe3, 0xaa, 0xe3, 0xaa, 0xe3, 0xfc, 0xfa,
	 0xaf, 0xe5, 0x2f, 0xfb, 0xe2, 0xaa, 0xe2, 0xfb, 0xff, 0xfa,
	 0xaf, 0xfa, 0xd3, 0xaf, 0xe3, 0xaa, 0xe2, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xe7, 0xaa, 0xe6, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe2, 0xaa, 0xe3, 0xd3, 0xff, 0xfa,
	 0xaf, 0xe6, 0xaa, 0xe3, 0xbf, 0xe3, 0xfa,
	 0xa8, 0xff, 0xfb, 0xe4, 0xfb, 0xe5, 0xf9, 0xff, 0xfa,
	 0xaf, 0xe6, 0xaa, 0xe3, 0xbf, 0xe2, 0xfb, 0xfa,
	 0xaf, 0xd3, 0xaf, 0xe2, 0xaa, 0xe2, 0xd4, 0xff, 0xfa,
	 0xaf, 0xff, 0xf0, 0xe3, 0x3f, 0xe2, 0xfb, 0xe5, 0x5a,
	 0xab, 0xec, 0xbf, 0xff, 0xfa,
	 0xd0,
	};

byte level48_data[] =
	{
	 0xd0,
	 0xa3, 0xe2, 0xbf, 0xe2, 0xbf, 0xe3, 0xf6, 0xe3, 0x5f, 0xfa,
	 0xaf, 0xff, 0xaf, 0xff, 0xaf, 0xff, 0xaa, 0xff, 0xd2, 0xaf, 0xe2, 0xaa, 0xff, 0xfa,
	 0xaf, 0xff, 0xaa, 0xfb, 0xaf, 0xfa, 0xff, 0xaf, 0xfb, 0xaf, 0xe2, 0xbf, 0xaa, 0xff, 0xfa,
	 0xaf, 0xbf, 0xaf, 0xaf, 0xaf, 0xfa, 0xff, 0xaf, 0xff, 0xaf, 0xe3, 0xaa, 0xff, 0xfa,
	 0xaf, 0xff, 0xaf, 0xfa, 0xaf, 0xfa, 0xff, 0xaf, 0xff, 0xaf, 0xfc, 0xe2, 0xaa, 0xff, 0xfa,
	 0xaf, 0xff, 0xaf, 0xff, 0xaf, 0xff, 0xaa, 0xff, 0x0f, 0xaf, 0xe3, 0xaa, 0xff, 0xba,
	 0xaf, 0xfb, 0xe4, 0xbf, 0xe6, 0xaa, 0xff, 0xfa,
	 0xaf, 0xff, 0xaf, 0xbf, 0xaf, 0xfa, 0xaa, 0xff, 0xd2, 0xaf, 0xfb, 0xff, 0xaa, 0xbf, 0xfa,
	 0xaf, 0xff, 0xfa, 0xfa, 0xff, 0xfa, 0xe3, 0xaf, 0xe3, 0xaa, 0xff, 0xfa,
	 0xaf, 0xbf, 0xff, 0xaf, 0xff, 0xfa, 0xaf, 0xff, 0xbf, 0xaf, 0xff, 0xbf, 0xff, 0xbf, 0xff, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xff, 0xfa, 0xfb, 0xe2, 0xaf, 0xe3, 0xaa, 0xff, 0xfa,
	 0xaf, 0xe2, 0xaf, 0xfb, 0xfa, 0xaa, 0xe2, 0xaf, 0xe3, 0xaa, 0xff, 0xfa,
	 0xa2, 0xf8, 0xe6, 0xbf, 0xff, 0xf7, 0xff, 0xf9, 0xff, 0x4f, 0xfa,
	 0xaf, 0xe4, 0xbf, 0xe9, 0xfa,
	 0xd0,
	};

byte level49_data[] =
	{
	 0xd0,
	 0xa5, 0xe5, 0xf6, 0xe3, 0xbf, 0xe3, 0x4f, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe8, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe3, 0xfa, 0xd3, 0xaf, 0xe2, 0xba,
	 0xaf, 0xfa, 0xd4, 0xaf, 0xe2, 0xf8, 0xe2, 0xfa, 0xaf, 0xff, 0xfa,
	 0xa2, 0xeb, 0xbf, 0xff, 0xf3, 0xfa,
	 0xaf, 0xe3, 0xfb, 0xe2, 0xfb, 0xe7, 0xfa,
	 0xaf, 0xe9, 0xfa, 0xd3, 0xaf, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe2, 0xfb, 0xe8, 0xbf, 0xfa,
	 0xaf, 0xff, 0xfa, 0xd3, 0xe5, 0xfb, 0xe3, 0xfa,
	 0xaf, 0xe7, 0xfa, 0xd5, 0xaf, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe2, 0xbf, 0xe9, 0xfa,
	 0xd5, 0xaf, 0xe5, 0xfb, 0xe3, 0xfa,
	 0xac, 0xe2, 0xbf, 0xe2, 0xf7, 0xe2, 0xf9, 0xe4, 0xf0, 0xfa,
	 0xaf, 0xe4, 0xbf, 0xe3, 0xbf, 0xe5, 0xfa,
	 0xd0,
	};

byte level50_data[] =
	{
	 0xd0,
	 0xa2, 0xe2, 0xbf, 0xe6, 0xbf, 0xe3, 0xf3, 0xfa,
	 0xaf, 0xe6, 0xbf, 0xe4, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xbf, 0xe2, 0xd2, 0xe2, 0xfb, 0xff, 0xd2, 0xe3, 0xfa,
	 0xaa, 0xaf, 0xe2, 0xfa, 0xaa, 0xaf, 0xe2, 0xfa, 0xaa, 0xaf, 0xe2, 0xfa, 0xaa,
	 0xaf, 0xbf, 0xe2, 0x6f, 0xd2, 0xf0, 0xff, 0xd2, 0x4f, 0xe2, 0xf8, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe2, 0xfa, 0xaa, 0xaf, 0xfa, 0xaa, 0xaf, 0xff, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xe5, 0xd4, 0xfb, 0xe4, 0xfa,
	 0xaa, 0xaf, 0xe4, 0xfa, 0xd2, 0xaf, 0xe3, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xff, 0xd2, 0xaf, 0xe5, 0xfa,
	 0xaf, 0xbf, 0xff, 0xbf, 0xe2, 0xfa, 0xd3, 0xe2, 0xfb, 0xff, 0xf9, 0xba,
	 0xaf, 0xe3, 0x7f, 0xff, 0xd2, 0xba, 0xaa, 0xaf, 0x5f, 0xe3, 0xfa,
	 0xaa, 0xaf, 0xe3, 0xfa, 0xaa, 0xaf, 0xff, 0xd2, 0xe3, 0xfa, 0xaa,
	 0xaf, 0xff, 0xbf, 0xe2, 0xd2, 0xfc, 0xff, 0xfa, 0xaa, 0xaf, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe3, 0xfa, 0xaa, 0xaf, 0xe2, 0xfb, 0xd2, 0xe3, 0xfa,
	 0xd0,
	};

byte level51_data[] =
	{
	 0xd0,
	 0xa4, 0xff, 0xfb, 0xe3, 0xbf, 0xe3, 0x5f, 0xe3, 0xfc, 0xfa,
	 0xaf, 0xea, 0xaa, 0xe3, 0xfa,
	 0xaf, 0xe6, 0xbf, 0xe2, 0xaa, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xfb, 0xe7, 0xaa, 0xff, 0xfa, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xd3, 0xff, 0xfb, 0xfa, 0xd2, 0xaf, 0xfa,
	 0xaf, 0xfb, 0xe4, 0xbf, 0xe2, 0xaa, 0xff, 0xfa, 0xff, 0xf6, 0xff, 0xfa,
	 0xaf, 0xe3, 0xd4, 0xab, 0xff, 0xaa, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xd3, 0xaf, 0xff, 0xbf, 0xff, 0xfa, 0xe2, 0xaa, 0xfb, 0xe2, 0xfa,
	 0xaf, 0xe3, 0xa8, 0xe3, 0x9f, 0xaf, 0xbf, 0xe4, 0xfa,
	 0xaf, 0xfb, 0xe2, 0xab, 0xe4, 0xd4, 0xff, 0xfb, 0xfa,
	 0xaf, 0xe3, 0xaf, 0xe4, 0xaf, 0xfb, 0xe4, 0xfa,
	 0xaf, 0xd3, 0xaf, 0xe2, 0xbf, 0xfa, 0xe6, 0xfa,
	 0xa0, 0xff, 0xfb, 0xff, 0xd4, 0xa2, 0xe4, 0xf7, 0xf3, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xe3, 0xfb, 0xe5, 0xba,
	 0xd0,
	};

byte level52_data[] =
	{
	 0xd0,
	 0xa2, 0xe2, 0xbf, 0xe5, 0xfb, 0xe3, 0xbf, 0xf8, 0xfa,
	 0xaf, 0xe4, 0xfb, 0xe2, 0xfb, 0xe2, 0xfa, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xe3, 0xfa,
	 0xaf, 0xfa, 0xdb, 0xaf, 0xfb, 0xfa,
	 0xaf, 0xff, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xaf, 0xfa, 0xff, 0xfa, 0xf9, 0xfa,
	 0xa6, 0xe3, 0xbf, 0xe5, 0x7f, 0xfa, 0xe2, 0xaf, 0xfa,
	 0xaf, 0xe5, 0xfb, 0xe6, 0xbf, 0xfa, 0xfa,
	 0xaf, 0xfb, 0xe6, 0xfb, 0xe5, 0xfa, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe2, 0xfb, 0xe3, 0xaf, 0xfa, 0xd2, 0xaf, 0xfa,
	 0xa3, 0xf4, 0xe7, 0x5f, 0xd4, 0xff, 0xfa,
	 0xaf, 0xe4, 0xbf, 0xe4, 0xaf, 0xfa, 0xd2, 0xfb, 0xfa,
	 0xd6, 0xff, 0xfb, 0xe4, 0xfa, 0xe2, 0xfa,
	 0xac, 0xfb, 0xe2, 0xf0, 0xfa, 0xe6, 0xaf, 0xaf, 0xfb, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xe4, 0xbf, 0xfa, 0xfb, 0xfa, 0xff, 0xfa,
	 0xd0,
	};

byte level53_data[] =
	{
	 0xd0,
	 0xa9, 0xe3, 0xfb, 0xe9, 0xf8, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe7, 0xbf, 0xe4, 0xfa,
	 0xaf, 0xaa, 0xaf, 0xfa, 0xaa, 0xff, 0xaa, 0xaf, 0xe4, 0xbf, 0xe2, 0xfa,
	 0xa6, 0xe3, 0xfb, 0xe9, 0xf7, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe6, 0xfb, 0xe2, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xe3, 0xaa, 0xff, 0xaa, 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xfa, 0xaa, 0xff, 0xfa,
	 0xa5, 0xe4, 0xbf, 0xe8, 0xf4, 0xfa,
	 0xaf, 0xe8, 0xfb, 0xe2, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xfa, 0xaf, 0xfa, 0xd2, 0xff, 0xaa, 0xe3, 0xfa,
	 0xa2, 0xff, 0xbf, 0xe2, 0xbf, 0xe3, 0xbf, 0xe4, 0xf3, 0xfa,
	 0xaf, 0xeb, 0xbf, 0xe2, 0xfa,
	 0xaf, 0xff, 0xbf, 0xe3, 0xaa, 0xff, 0xaa, 0xff, 0xaa, 0xff, 0xaa, 0xff, 0xff, 0xfa,
	 0xac, 0xeb, 0xbf, 0xff, 0xf0, 0xfa,
	 0xaf, 0xe3, 0xbf, 0xe4, 0xbf, 0xe5, 0xfa,
	 0xd0,
	};

byte level54_data[] =
	{
	 0xd0,
	 0xaf, 0xff, 0xbf, 0xe3, 0xbf, 0xff, 0xbf, 0xe3, 0xbf, 0xe2, 0xfa,
	 0xa2, 0xe5, 0x3f, 0xfa, 0xd2, 0xe4, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xbf, 0xe4, 0xaa, 0xa6, 0xe4, 0xf7, 0xfa,
	 0xd3, 0xe2, 0xbf, 0xff, 0xfb, 0xaa, 0xaf, 0xff, 0xbf, 0xe3, 0xfa,
	 0xaf, 0xfb, 0xe3, 0xfa, 0xd6, 0xaf, 0xff, 0xbf, 0xfa,
	 0xaf, 0xe2, 0xfa, 0xda, 0xff, 0xfa,
	 0xab, 0xe2, 0xfa, 0xaa, 0xaf, 0xff, 0xd3, 0xaf, 0xbf, 0xd2, 0xff, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe4, 0xd3, 0xaf, 0xe3, 0xfb, 0xfa,
	 0xa8, 0xe4, 0x9f, 0xfa, 0xaf, 0x4f, 0xfa, 0xaf, 0xe4, 0xfa,
	 0xaf, 0xff, 0xfb, 0xe3, 0xaa, 0xe3, 0xaa, 0xfb, 0xe3, 0xfa,
	 0xaa, 0xd2, 0xff, 0xfb, 0xfa, 0xaa, 0xfb, 0xe2, 0xaa, 0xaf, 0xff, 0xfb, 0xff, 0xfa,
	 0xaf, 0xe4, 0xfa, 0xaf, 0xe2, 0xbf, 0xfa, 0xaf, 0xfb, 0xe2, 0xfa,
	 0xac, 0xfb, 0xe2, 0xfa, 0xaa, 0xaf, 0xbf, 0x5f, 0xff, 0xfa, 0xaa, 0xaf, 0xff, 0xf0, 0xfa,
	 0xaf, 0xe2, 0xfb, 0xfa, 0xaa, 0xaf, 0xe2, 0xfb, 0xfa, 0xaa, 0xaf, 0xe2, 0xfa,
	 0xd0,
	};

//Pointers to level data (to allow "random access" to any level in debugging or cheat modes)
//Due to level data compression, level data size varies.
byte *level_ptr[]={level1_data,level2_data,level3_data,level4_data,level5_data,
		level6_data,level7_data,level8_data,level9_data,level10_data,
		level11_data,level12_data,level13_data,level14_data,level15_data,
		level16_data,level17_data,level18_data,level19_data,level20_data,
		level21_data,level22_data,level23_data,level24_data,level25_data,
		level26_data,level27_data,level28_data,level29_data,level30_data,
		level31_data,level32_data,level33_data,level34_data,level35_data,
		level36_data,level37_data,level38_data,level39_data,level40_data,
		level41_data,level42_data,level43_data,level44_data,level45_data,
		level46_data,level47_data,level48_data,level49_data,level50_data,
		level51_data,level52_data,level53_data,level54_data};

//The level names (Max length 23 Characters)
char *level_name[]={	
			"WELCOME BACK SPANNERMAN",
			"THE GHOUL SHOP",
			"TELEPHONE WIRE",
			"LEANING PIZZA TOWER",
			"THE CAGE",
			"TRAP DOOR",
			"THE ARCHWAY",
			"GREEN BRICK OF HOME",
			"BUBBLES",
			"SID'S CHIP",
			"IRONING BOARD",
			"PASSAGES OF REFLECTION",
			"AREA 48",
			"MEMRISTOR",
			"MINDWARP",
			"GUITAR",
			"RAILWAY CROSSING",
			"RUSSIAN AROUND",
			"VHS TAPE",
			"SIDHENGE",
			"VERNAL EQUINOX",
			"ESPLANADE, THE",
			"RIGMAROLE",
			"NUTFEST",
			"ANVIL",
			"LEAKY PIPES",
			"DUMBELL",
			"EDGBASTON",
			"QUICKLY, NOW",
			"UNHINGED",
			"SP1ES LIKE US",
			"PARALLELOGRAM",
			"CRIMSON KIPPER",
			"TRAMPOLINE",
			"ROLLER COASTER",
			"MIRROR MIRROR",
			"KEEPER OF THE GLOME",
			"IGLOO FARM",
			"NIBBLY WAS 'ERE",
			"SIDTRIS",
			"EXOMORPH",
			"ROUTE 66",
			"PINFOLD",
			"OUR SHED",
			"LONG JUMP",
			"TESSERACT",
			"IS THIS THE END?",
			"NO IT ISN'T",
			"OH NO, ANOTHER LEVEL!",
			"X",
			"LOGIC GATES",
			"OUTSIDE BROADCAST",
			"CHOREOGRAPHY",
			"KING MONSTER"
			};

//number of lives
byte lives;
//level number
byte level;
//number of nuts on a single level
byte nuts;
//amount of time remaining
byte time, time_ticks;
//Temp string for status area
char tempstr[32];
//Position of door;
byte doorrow,doorcol;

//16x24 pixel Sprite data follows (sprite data only, no mask data)
//No masks needed for this game, as sprite data is written in "OR" mode
//All sprites and tiles designed and exported using SevenuP (Thanks Metalbrain!)
//Padding of 7 zero bytes manually pre-pended and array size increased from 384
//to 391 bytes to facilitate use with SP1

/* C source file created by SevenuP v1.20                                */
/* SevenuP (C) Copyright 2002-2006 by Jaime Tejedor Gomez, aka Metalbrain*/

/*
GRAPHIC DATA:
Pixel Size:      ( 16,  24)
Char Size:       (  2,   3)
Frames:             8
Sort Priorities: Char line, Y char, X char, Frame number
Data Outputted:  Gfx
Interleave:      Sprite
Mask:            No
*/

//Player sprite (Sid Spanners has 4 right-facing frames and 4 left-facing frames)
unsigned char sprite_sid1[391] = {

//7 zero data bytes padding
0,0,0,0,0,0,0,

//right0
  0, 14, 31, 29, 31, 14, 63,127,
239,207, 31, 63, 51, 99,113, 48,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0, 18,179, 51, 18, 12,156,
252,108, 12, 12, 76,192,192,128,
  0,  0,  0,  0,  0,  0,  0,  0,

//right1
  0, 14, 31, 29, 31, 14, 31, 63,
111,111, 63, 31, 51, 51, 27, 29,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,128,  0,  6, 12,152,
209,219,126,112,224,192,128,192,
  0,  0,  0,  0,  0,  0,  0,  0,

//right2
  0, 14, 31, 29, 31, 14, 15, 15,
 15, 15, 31, 31,  6,  6,  7,  7,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,128,  0,  0,  0,  0,
140,158,224,224, 30, 12,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,

//right3
  0, 14, 31, 29, 31,110,127,127,
 63, 31, 15, 31, 27, 51, 61, 29,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,128,  0,  0,  0,  0,
  0,128,224,240,176,144,224,192,
  0,  0,  0,  0,  0,  0,  0,  0,

//left0
  0,  0, 72,205,204, 72, 48, 57,
 63, 54, 48, 48, 50,  3,  3,  1,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,112,248,184,248,112,252,254,
247,243,248,252,204,198,142, 12,
  0,  0,  0,  0,  0,  0,  0,  0,

//left1
  0,  0,  0,  1,  0, 96, 48, 25,
139,219,126, 14,  7,  3,  1,  3,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,112,248,184,248,112,248,252,
246,246,252,248,204,204,216,184,
  0,  0,  0,  0,  0,  0,  0,  0,

//left2
  0,  0,  0,  1,  0,  0,  0,  0,
 49,121,  7,  7,120, 48,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,112,248,184,248,112,240,240,
240,240,248,248, 96, 96,224,224,
  0,  0,  0,  0,  0,  0,  0,  0,

//left3
  0,  0,  0,  1,  0,  0,  0,  0,
  0,  1,  7, 15, 13,  9,  7,  3,
  0,  0,  0,  0,  0,  0,  0,  0,
  0,112,248,184,248,118,254,254,
252,248,240,248,216,204,188,184,
  0,  0,  0,  0,  0,  0,  0,  0};

//The four guardian sprites, each having 2 frames
unsigned char sprite_enemy1[391] = {
	
//7 zero data bytes padding
0,0,0,0,0,0,0,

//enemy0 frame0
  1,  3,  7,  5,  7, 14,127,255,
255,127, 99, 71, 15, 15, 31, 31,
  0,  0,  0,  0,  0,  0,  0,  0,
128,192,224, 96,254,255,255,255,
248,248,252,254,255,191,159, 14,
  0,  0,  0,  0,  0,  0,  0,  0,
  
//enemy0 frame1
  1,  3,  7,  6,127,255,255,255,
 31, 31, 63,127,255,253,249,112,
  0,  0,  0,  0,  0,  0,  0,  0,
128,192,224,160,224,112,254,255,
255,254,198,226,240,240,248,248,
  0,  0,  0,  0,  0,  0,  0,  0,
  
//enemy1 frame0
 15, 63,127,127,207,207,231,252,
252,248,255,229,112,122, 63, 15,
  0,  0,  0,  0,  0,  0,  0,  0,
240,252,254,254,231,199,159,255,
255,127,255, 71, 14,158,252,240,
  0,  0,  0,  0,  0,  0,  0,  0,
  
//enemy1 frame1
 15, 63,127,127,231,227,249,255,
255,254,255,226,112,121, 63, 15,
  0,  0,  0,  0,  0,  0,  0,  0,
240,252,254,254,243,243,231, 63,
 63, 31,255,167, 14, 94,252,240,
  0,  0,  0,  0,  0,  0,  0,  0,
  
//enemy2 frame0
  8,  4,  2,255,128,159,183,191,
189,175,176,191,191,159,128,255,
  0,  0,  0,  0,  0,  0,  0,  0,
 16, 32, 64,255,  1,241,123,249,
251,185,123,249,251,241,  1,255,
  0,  0,  0,  0,  0,  0,  0,  0,
  
//enemy2 frame1
  8,  4,  2,255,128,159,191,187,
191,190,183,184,191,159,128,255,
  0,  0,  0,  0,  0,  0,  0,  0,
 16, 32, 64,255,  1,241,251,185,
251,249,219, 57,251,241,  1,255,
  0,  0,  0,  0,  0,  0,  0,  0,
  
//enemy3 frame0
 15, 63,121,125, 63, 31, 14,  6,
  4, 15, 31, 55,123,124, 63, 15,
  0,  0,  0,  0,  0,  0,  0,  0,
240,252,158,222,252,248,240,224,
224,240,248,220,190,126,252,240,
  0,  0,  0,  0,  0,  0,  0,  0,
  
//enemy3 frame1
 15, 63,121,123, 63, 31, 15,  7,
  7, 15, 31, 59,125,126, 63, 15,
  0,  0,  0,  0,  0,  0,  0,  0,
240,252,158,190,252,248,112, 96,
 32,240,248,236,222, 62,252,240,
  0,  0,  0,  0,  0,  0,  0,  0};

//Array of pointers to animated sequence of frames of Sid character walking
unsigned char *anim_sid_left[6];
unsigned char *anim_sid_right[6];

//Array of pointers to "Start frames" of each sprite
//Next frame of guardian sprites is guaranteed to be 48 bytes 
//later in memory that initial frame
unsigned char *start_frame[MAX_SPRITES];

//8x8 tiles (bricks, nuts and door)
byte tile_brick0[] = {223,223,223,  0,251,251,251,  0};
byte tile_brick1[] = {247,239,247,0xaa,0x55,239,247,239};
byte tile_brick2[] = {239,239,  0,253,253,  0,239,239};
byte tile_brick3[] = {219,  0,237,  0,219,  0,237,  0};
byte tile_nut[] = { 0, 60,102, 66, 66,102, 60,  0};
byte tile_door01[] = { 255,128,191,160,175,168,171,170};
byte tile_door02[] = { 255,  1,253,  5,245, 21,213, 85};
byte tile_door03[] = { 170,171,168,175,160,191,128,255};
byte tile_door04[] = { 85,213, 21,245,  5,253,  1,255};

//Define play-area clipping rectangle used by SP1 library
struct sp1_Rect cr = {0, 0, 32, 16};		//Top two-thirds of the screen only
//Smaller rectangles for invalidating 1x1 and 2x2 character squares respectively
struct sp1_Rect onecr = {0,0,1,1};
struct sp1_Rect twocr = {0,0,2,2};

//Function prototypes
void init_universe(void);
void intro_screen(void);
void init_game(void);
void init_level(byte level);
void *u_malloc(uint size);
void u_free(void *addr);
void zx_border2(byte b);
void setcolattr(byte i, byte p, byte f, byte b);
void cls(void);
void colcls(byte i, byte p, byte f, byte b);
void colborcls(byte i, byte p, byte f, byte b, byte o);
void setcolmode(byte m);
//Used during development/testing only
//void fatal_error(char *s);
void draw_level_background(char *map);
void printchrat64(byte x, byte y, char c);
#define printchrat32(x,y,s) printchrat64((x)<<1,(y),(s))
void printstrat64(byte x, byte y, char *s);
#define printstrat32(x,y,s) printstrat64((x)<<1,(y),(s))
void define_tileset(byte level);
void init_sprites(char *map);
void init_anim_lists(void);
//Only needed for debugging
//void debug_msg(char *msg);
void init_im2_handler(void);
void init_keyboard(void);
void add_sprite_colour(struct sp1_cs *cs);
void my_bit_fx(byte n, byte m);
void draw_status_area(void);
void draw_level_name(void);
void draw_lives(void);
void draw_nuts(void);
void draw_time(void);
void game_over(void);
void out_of_time(void);
void won_game(void);
void print_huge_char(byte x, byte y, byte i, char c);
void print_huge_string(byte x, byte y, byte i, char *s);
void decrunch_level_data(char *out, byte *in, word size);

//These globals also moved out of main()
//in order to save further stack space
byte level_over,input;
byte solid_ground,caught;
byte cx,cy,tx,ty;
//An object touched by the player
//and the location of it on the map
char touched;
word touchloc;
//Temporary variable which calculates offset into
//map of the row underneath player characters feet -
//used simply to avoid having to multiply sprite
//row by 32 more than once in the main game loop
word maprowfeet;
struct sprentry *se;

main()
{
byte i;
word j;

init_universe();

beginning:

while(1)
	{
	intro_screen();

	init_game();


levelstart:

	init_level(level);

	level_over=0;

	while(!level_over)
		{
		//Main game loop

		//has the player been caught by an enemy?
		caught=0;

		//Update screen
		sp1_UpdateNow(); 

		//Calculate absolute position of all sprites
		for(i=0;i<MAX_SPRITES;i++)
			{
			se=&sprtbl[i];
			se->px=(se->s->col<<3)+(se->s->hrot&7);
			se->py=(se->s->row<<3)+(se->s->vrot&7);
			
			//collision detection
			//for each enemy sprite - detect if the player
			//sprite has been touched
			if(i)
				{
				//need (int) casts to produce signed result
				cx=(byte)ABS((int)(se->px)-(int)(sprtbl[0].px));
				cy=(byte)ABS((int)(se->py)-(int)(sprtbl[0].py));

				//These values dictate the sensitivity of the collision detection
				if((cx<12)&&(cy<12))
					caught=i;
				}			

			}

		//debugging zone
		//for(temp1=0;temp1<10;temp1++)
		//	delay(10000);
		
		//setcolmode(64);
		//sprintf(tempstr,"%d %d\0",sprtbl[0].px,sprtbl[0].py);
		//printstrat64(0,0,"                        ");
		//printstrat64(0,0,tempstr)

		//Handle Player Character
		//Set sprite entry pointer to sprite zero (player sprite)
		se = &sprtbl[0];

		//check for touching a nut or the door
		maprowfeet=(se->s->row+2)<<5;

		//Reset 'touched' variable to no item
		touched=' ';

		//disregard checking when player has jumped off the top of the map
		if(se->py<192)
			{
			//check six squares behind the player (1 row and 2 rows above maprowfeet)
			for(i=0;i<3;i++)
				for(j=maprowfeet-64;j<maprowfeet;j+=32)
					//disregard empty space and bricks
					if(current_map[j+se->s->col+i]>'a')
						{
						touchloc=j+se->s->col+i;
						touched=current_map[touchloc];		
						}			
		}

		//deal with touched nut (enough of that - ed)
		if(touched=='b')
			{
			current_map[touchloc]=' ';
			ty=touchloc>>5;
			tx=touchloc&31;
			sp1_PrintAt(ty,tx,PAPER_BLACK|INK_YELLOW|BRIGHT,' ');
			onecr.row=ty;
			onecr.col=tx;
			sp1_Invalidate(&onecr);
			sp1_UpdateNow();
			nuts--;
			draw_nuts();
			my_bit_fx(1,2);

			//activate door if no nuts remaining
			if(!nuts)
				{
				my_bit_fx(2,4);
				sp1_PrintAt(doorrow,doorcol,6|BRIGHT|FLASH,'c');
				sp1_PrintAt(doorrow,doorcol+1,6|BRIGHT|FLASH,'d');
				sp1_PrintAt(doorrow+1,doorcol,6|BRIGHT|FLASH,'e');
				sp1_PrintAt(doorrow+1,doorcol+1,6|BRIGHT|FLASH,'f');
				twocr.row=doorrow;
				twocr.col=doorcol;
				sp1_Invalidate(&twocr);				
				sp1_UpdateNow();
				}
			}


		//if((touched>='c')&&(touched<='f')) //door debugging
		
		//deal with player entering open door
		if((!nuts)&&(touched>='c')&&(touched<='f'))
			{
			//Add an extra condition that the player sprite must also have a middling rotation
			//in order to enter the door (i.e. player is partially overlapping with the door)
			//This just prevents some cases of the player entering door when they are diagonally
			//displaced from it by (8,8) pixels which looks a bit wrong when the sprites don't touch
			if((((se->s->hrot&7)>=3)&&((se->s->hrot&7)<=4))
			||(((se->s->vrot&7)>=3)&&((se->s->vrot&7)<=4)))
				{
				//Furthermore add another check to fix "trampoline exits level" bug
				if(se->py<120)
					{
					//set level_over flag to 2 when player succesfully completes level
					level_over=2;
					}
				}
			}

		//deal with player caught
		if(caught)
			{
			zx_border2(2);
			for(i=0;i<3;i++)
				my_bit_fx(1,7);
			zx_border2(0);
			lives--;
			se->dx=0;
			se->dy=0;
			airborne=0;
			jump_tick=0;
			sp1_MoveSprAbs(se->s, &cr, start_frame[0],se->startrow , se->startcol, 0, 0);
			draw_lives();
			//deal with player dead
			if(!lives)
				{
				//set level_over flag to 1 when player dies
				level_over=1;
				}				
			}

		//decrement timer
		if(time_ticks++>50)
			{
			time_ticks=0;
			time--;
			if(time==255)
				level_over=3; //out of time
			else
				draw_time();
			}	

		//solid_ground=((current_map[((se->s->row+2)<<5)+se->s->col]=='a')||
		//	(current_map[((se->s->row+2)<<5)+se->s->col+1]=='a')||
		//	((current_map[((se->s->row+2)<<5)+se->s->col+2]=='a'))

				
		//detect a solid surface under player
        //only check the last tile if the horizontal rotation is non-zero
            solid_ground=((current_map[maprowfeet+se->s->col]=='a')||
			(current_map[maprowfeet+se->s->col+1]=='a')||
			((current_map[maprowfeet+se->s->col+2]=='a'))&&se->s->hrot);

		//check for walking off the end of a platform
		if((!solid_ground)&&(!airborne))
			{
			se->dy=1;
			airborne=1;
			}

		//read keyboard 
		input = (getjoy)(&keys); 

        //player walking on a platform
		if(!airborne)
			{

			if((input & in_LEFT)&&(se->px>8)) 
				{
				facing_left=1;				
				se->dx=-1;
				
				//if somehow got stuck inside a platform, then
				//move back onto the top of it
				if(se->s->vrot&7)
					{
					se->dy=-(se->s->vrot&7);
					}

				//animate sprite

				if(frame_tick++>1)	
					{
					se->frame++;
					if(se->frame>5) se->frame=0;
					frame_tick=0;
					}
				}
			if((input & in_RIGHT)&&(se->px<232)) 
				{
				facing_left=0;
				se->dx=1;

				//if somehow got stuck inside a platform, then
				//move back onto the top of it
				if(se->s->vrot&7)
					{
					se->dy=-(se->s->vrot&7);
					}

				//animate sprite
				if(frame_tick++>1)	
					{
					se->frame++;
					if(se->frame>5) se->frame=0;
					frame_tick=0;
					}
				}
			if(input & (in_FIRE|in_UP|in_DOWN))
				{
				airborne=1;
				se->dx=(input & in_RIGHT?1:0)-(input & in_LEFT?1:0);
				se->dy=-2;
				}			
			}

		if(airborne)
			{
			//adjust speed every few ticks
            //The higher this value, the higher sid can jump
			if(jump_tick++>8)
				{
				if(se->dy<2) se->dy++;
				jump_tick=0;
				//if speed changed to +2 on an odd line (during falling), then adjust to +1
				//for one more iteration, to keep the vertical position an
				//even number and avoid landing inside a platform
				if((se->dy==2)&&(se->s->vrot&1))
					{
					se->dy=1;
					//force increment to speed of two on following interation
					jump_tick=9;
					}
				}

			//landed - check for sold ground, moving downwards and player not off the top of the screen
			//also check for vrot values of 0,1,2 preventing player getting stuck inside platform
			//near the top of the jump
			i=se->s->vrot&7;
            if(solid_ground&&(se->dy>=0)&&(se->py<192)&&(i<3)) 
				{
				airborne=0;
				//nullify residual speed to land exactly on platform				
				se->dy=0;
				jump_tick=0;
				}
            //prevent jumping beyond the sides of the play area
			if((se->px<9)&&(se->dx==-1)) se->dx=0;
			if((se->px>231)&&(se->dx==1)) se->dx=0;

			//Hand-coded adjustments for some non-standard levels
			//(Affecting airborne player)
			switch(level)
				{
				case 12: //Passages of reflection
				//return player to top of screen and reflect position and orientation horizontally
				if(se->py>191&&se->py<200)
					{
					se->s->row=0;
					se->s->col=31-se->s->col;
					se->s->hrot=7-se->s->col;
					facing_left^=1;
					se->dx=-se->dx;
					}
				break;

				case 34: //Trampoline
				//bounce the player out of the bottom at high speed
				if(se->py>191&&se->py<200)
					{
					se->dy=-6;
					jump_tick=0;
					}
				break;
				
				//for most levels, do nothing
				default:
				break;
				}
			}  //if(airborne)
		 
		//move player sprite
		if(facing_left)
			sp1_MoveSprRel(se->s, &cr, anim_sid_left[se->frame], 0, 0, se->dy, se->dx); //Move sprite
		else
			sp1_MoveSprRel(se->s, &cr, anim_sid_right[se->frame], 0, 0, se->dy, se->dx); 
         

		if(!airborne)
			{
			//stop moving if not airborne
			se->dx=0;
         	se->dy=0;
			}

		//move guardian sprites
		for(i=1;i<MAX_SPRITES;i++)
			{
			//set up se to point to current sprite entry
			se=&sprtbl[i];
			if(se->startrow==se->endrow)
				{
				//horizontal guardian
				if(se->direction==1)
					{
					
					//going from start to end
					//cast operands to signed values
					se->dx=SGN((char)se->endcol-(char)se->startcol);

					//check for end reached
					if((se->s->col==se->endcol)&&(se->s->hrot==0))
						{
						se->direction=-1; //reverse direction
						se->dx=0; //stop moving
						}
					}
				else
					{
					//going from end to start
					//cast operands to signed values
					se->dx=SGN((char)se->startcol-(char)se->endcol);
					//check for start reached
					if((se->s->col==se->startcol)&&(se->s->hrot==0))
						{
						se->direction=1; //forward direction
						se->dx=0; //stop moving
						}
					}
				}
			else
				{
				//vertical guardian
				if(se->direction==1)
					{
					//going from start to end
					//cast operands to signed values
					se->dy=SGN((char)se->endrow-(char)se->startrow);

					//check for end reached
					if((se->s->row==se->endrow)&&((se->s->vrot&7)==0))
						{
						se->direction=-1; //reverse direction
						se->dy=0; //stop moving
						}
					}
				else
					{
					//going from end to start
					//cast operands to signed values
					se->dy=SGN((char)se->startrow-(char)se->endrow);
					//check for start reached
					if((se->s->row==se->startrow)&&((se->s->vrot&7)==0))
						{
						se->direction=1; //forward direction
						se->dy=0; //stop moving
						}
					}
											
				}  //end else

				//Level-specific guardian behaviours mods
				switch(level)
					{
					case 29:
					//If on level "QUICKLY, NOW", then guardians move twice as fast
					se->dx+=se->dx;
					se->dy+=se->dy;
					break;

					//for most levels, do nothing
					default:
					break;
					}

			//move the sprite	
			sp1_MoveSprRel(se->s, &cr, (guardian_flip?start_frame[i]+48:start_frame[i]), 0, 0, se->dy, se->dx); 		
			} //end for()
			//alternate between two animated frames
			if(guardian_tick++>15)
				{			
				guardian_flip^=1;
				guardian_tick=0;
				}

		} //end while(!level_over)
	
	//This point is reached if the level has ended
	//End of level conditions
	//level_over==1 Player has ran out of lives (game over)
	//level_over==2 Player has successfully completed the level (go to next level or win the game)
	//level_over==3 Player has ran out of time (game over)

	if(level_over==1)
		{
		//game over
		for(i=0;i<3;i++)
			my_bit_fx(2,6);
		game_over();		
		}
	else if(level_over==2)
		{
		//level completed
		for(i=0;i<3;i++)
			my_bit_fx(2,5);

		if(level++==NUM_LEVELS)
			{
			won_game();
			}
		else
			goto levelstart;		
		}
	else if(level_over==3)
		{
		for(i=0;i<3;i++)
			my_bit_fx(2,6);
		out_of_time();
		}

	} //end while(1)

}  //end main() function

void init_universe(void)
{
struct sp1_ss *s;
byte i;

//Replace system ISR routine and enter IM2 mode
   init_im2_handler();
// Setup the heap
   mallinit();              // set heap as currently empty
   sbrk(HEAP_ADDR,HEAP_SIZE);        // Allocate defined chunk to heap
   current_map=u_malloc(LEVEL_SIZE);  // Allocate space within heap for map data of current level

//Initialise SP1 sprite engine
sp1_Initialize(SP1_IFLAG_MAKE_ROTTBL | SP1_IFLAG_OVERWRITE_TILES | SP1_IFLAG_OVERWRITE_DFILE,
	 INK_YELLOW|PAPER_BLACK|BRIGHT, ' ');


//Create the sprites. In this game, they are maskless 1-byte sprites of the "OR" draw type
	for(i=0;i<MAX_SPRITES;i++)
		{
		
		s=sprtbl[i].s = sp1_CreateSpr(SP1_DRAW_OR1LB, SP1_TYPE_1BYTE, 3, 0, i);

      	sp1_AddColSpr(s, SP1_DRAW_OR1, 0, 24, i);
      	sp1_AddColSpr(s, SP1_DRAW_OR1RB, 0, 0, i);
		}
}

void intro_screen(void)
{
//debugging
//word t,l;
byte i;

colborcls(7,1,0,1,1);

//debugging
//mallinfo(&t,&l);

setcolmode(32);
setcolattr(6,1,0,1);
puts("\n\n\n");
puts(" Sid Spanners 2: The Slackening\n");
setcolattr(7,1,0,1);
puts("        by Digital Prawn\n");
puts("            LEFT = O\n");
puts("           RIGHT = P\n");
puts("          JUMP = Q/Z/M\n");
puts("      Collect all nuts then");
puts("         get to the exit\n");
puts("       Avoid the guardians\n");

printf("       ");
setcolattr(7,1,1,1);
printf("PRESS A KEY TO START\n");

//Play short sound (Serves as keyboard detection delay)
for(i=0;i<3;i++)
	my_bit_fx(1,6);

WAIT_KEY;
}

void init_game(void)
{
init_keyboard();

//reset in-game variables
level=START_LEVEL;
lives=NUM_LIVES;
}

void init_level(byte level)
{
define_tileset(level);
colborcls(2,0,0,1,0);

//copy level_data into current_map

//check for uncompressed map (first byte is always 0x61, the code for 'a')
//This value cannot occur in the frst byte of a compressed map
if(*level_ptr[level-1]==0x61)
	//uncompressed map - straight copy
	memcpy(current_map,level_ptr[level-1],LEVEL_SIZE);
else
	//compressed map - decrunch it
	decrunch_level_data(current_map,level_ptr[level-1],LEVEL_SIZE);

draw_level_background(current_map);

//set sprite colour depending on level number
switch((level-1)&3)
	{
	case 0:
	//reset sprite colours
	sprite_colour[0]=6|BRIGHT;
	sprite_colour[1]=1|BRIGHT;
	sprite_colour[2]=3|BRIGHT;
	sprite_colour[3]=4|BRIGHT;
	sprite_colour[4]=5|BRIGHT;
	break;
	case 1:
	//reset sprite colours
	sprite_colour[0]=6|BRIGHT;
	sprite_colour[2]=1|BRIGHT;
	sprite_colour[3]=3|BRIGHT;
	sprite_colour[4]=4|BRIGHT;
	sprite_colour[1]=5|BRIGHT;
	break;
	case 2:
	//reset sprite colours
	sprite_colour[0]=6|BRIGHT;
	sprite_colour[3]=1|BRIGHT;
	sprite_colour[4]=3|BRIGHT;
	sprite_colour[1]=4|BRIGHT;
	sprite_colour[2]=5|BRIGHT;
	break;
	case 3:
	//reset sprite colours
	sprite_colour[0]=6|BRIGHT;
	sprite_colour[4]=1|BRIGHT;
	sprite_colour[1]=3|BRIGHT;
	sprite_colour[2]=4|BRIGHT;
	sprite_colour[3]=5|BRIGHT;
	break;
	}

init_sprites(current_map);

//reset all animation & action timers
airborne=0;
facing_left=0;
frame_tick=0;
jump_tick=0;
guardian_flip=0;
guardian_tick=0;

//set the time limit
time=TIME_LIMIT;
time_ticks=0;

draw_status_area();
}

void *u_malloc(uint size) 
{
return malloc(size);

//The following only needed during development
/*
void *p;

//if malloc() succeeds then return with carry flag set
if(p=malloc(size)) return_c(p);

//fatal error if malloc() fails
fatal_error("Out of memory!");
*/
}

void u_free(void *addr)
{
free(addr);
}

void zx_border2(byte b)
{
//Call the library function to change the border colour
zx_border(b);
//put (8*b) into the BORDCR system variable
*(byte *)23624=b<<3;
}

void setcolattr(byte i, byte p, byte f, byte b)
{
	putchar(16); putchar(i|0x30);	//ink
	putchar(17); putchar(p|0x30);	//paper
	putchar(18); putchar(f|0x30);	//flash
	putchar(19); putchar(b|0x30);	//bright
}

void cls(void)
{
putchar(12); //send a form feed control
}

void colcls(byte i, byte p, byte f, byte b)
{
setcolattr(i,p,f,b);
cls();
}

void colborcls(byte i, byte p, byte f, byte b, byte o)
{
colcls(i,p,f,b);
zx_border2(o);
}

void setcolmode(byte m)
{
putchar(1);putchar(m);
}

//The following only needed during development
/*
void fatal_error(char *s)
{
zx_border2(2);
setcolmode(64);
colborcls(1,0,0,1,0);
puts("Fatal Error:");
puts(s);
exit(0);
}
*/

void draw_level_background(char *map)
{
byte x,y;
char c;

//colour of wall
byte w;

nuts=0;

//set colour of wall
w=(1+(level%5))|BRIGHT;

//clear the play area
for(y=0;y<16;y++)
	for(x=0;x<32;x++)
		sp1_PrintAt(y,x,INK_YELLOW|BRIGHT,' ');

//print tiles according to level data
for(y=0;y<16;y++)
	for(x=0;x<32;x++)
		{
		c=map[(y<<5)+x];
		//print tiles only (lowercase), ignore sprites (uppercase)
		if(c>='a')
			{
			switch(c)
				{
				//brick
				//different colour depending on level
				case 'a': sp1_PrintAt(y,x,w,'a');
					break;
				//nut
				case 'b': sp1_PrintAt(y,x,7|BRIGHT,'b');
					nuts++;
					break;
				//door
				case 'c': 
					doorrow=y;
					doorcol=x;
					sp1_PrintAt(y,x,6|BRIGHT,'c');
					sp1_PrintAt(y,x+1,6|BRIGHT,'d');
					sp1_PrintAt(y+1,x,6|BRIGHT,'e');
					sp1_PrintAt(y+1,x+1,6|BRIGHT,'f');
					
					//imprint remainder of door onto current level data
					map[(y<<5)+x+1]='d';
					map[((y+1)<<5)+x]='e';
					map[((y+1)<<5)+x+1]='f';
					break;
				//ignore any undefined characters in map data
				default:
					break;
				}
			}	
		}

   sp1_Invalidate(&cr);	//Invalidate the area defined by the clipping rectangle 
   sp1_UpdateNow();  //Update (redraw) the area
}

void printchrat64(byte x, byte y, char c)
{
putchar(22);putchar(32+y);putchar(32+x);putchar(c);
}

void printstrat64(byte x, byte y, char *s)
{
putchar(22);putchar(32+y);putchar(32+x);
printf("%s",s);
}

void define_tileset(byte level)
{
	
//Select one of four different brick designs
//depending on level number

switch(level&3)
	{
	default:
	case 0: sp1_TileEntry('a', tile_brick0);
	break;
	case 1: sp1_TileEntry('a', tile_brick1);
	break;
	case 2: sp1_TileEntry('a', tile_brick2);
	break;
	case 3: sp1_TileEntry('a', tile_brick3);
	break;
	}
	
//Nut
sp1_TileEntry('b',tile_nut); 

//Door
sp1_TileEntry('c',tile_door01); 
sp1_TileEntry('d',tile_door02); 
sp1_TileEntry('e',tile_door03); 
sp1_TileEntry('f',tile_door04); 
}

void init_sprites(char *map)
{
struct sp1_ss *s;
byte row,col,sn;
word i;
char c;

	init_anim_lists();

	//reset sprite parameters
	for(i=0;i<MAX_SPRITES;i++)
		{
		sprtbl[i].dx=0;
		sprtbl[i].dy=0;
		sprtbl[i].frame=0;
		sprtbl[i].direction=1;
		}

	//scan level map for sprite positions
	for(i=0;i<LEVEL_SIZE;i++)
		{
		c=map[i];
		row=i>>5;
		col=i&31;
		if((c>='0')&&(c<='9'))
			{
			//calculate sprite number
			sn=(c-'0')>>1;
			//if it's an even number then it's a start position, else an end position
			if((c-'0')&1)
				{
				//odd
				sprtbl[sn].endcol=col;
				sprtbl[sn].endrow=row;
				}
			else
				{
				//even
				sprtbl[sn].startcol=col;
				sprtbl[sn].startrow=row;
				}
			}
		}
	
	//Colour all sprites, and place them on the screen
	for(i=0;i<MAX_SPRITES;i++)
		{
		//set global variable "colour", used by the hook function add_sprite_colour()
		global_n=i;
		sp1_IterateSprChar(sprtbl[i].s,add_sprite_colour);
		sp1_MoveSprAbs(sprtbl[i].s, &cr, start_frame[i],sprtbl[i].startrow , sprtbl[i].startcol, 0, 0);
		}
}

void init_anim_lists(void)
{
byte i;
//Anim lists for the player-character Sid.
//Comprise the list of pointers to frames which give the impression
//of walking forwards when animated in this sequence.
//
//Offsets into the array of frames are added onto
//7 bytes padding before the first 48-byte frame
//(Then each frame is 48 bytes apart)
anim_sid_right[0]=sprite_sid1+7;
anim_sid_right[1]=sprite_sid1+55;
anim_sid_right[2]=sprite_sid1+103;
anim_sid_right[3]=sprite_sid1+151;
anim_sid_right[4]=sprite_sid1+103;
anim_sid_right[5]=sprite_sid1+55;

anim_sid_left[0]=sprite_sid1+199;
anim_sid_left[1]=sprite_sid1+247;
anim_sid_left[2]=sprite_sid1+295;
anim_sid_left[3]=sprite_sid1+343;
anim_sid_left[4]=sprite_sid1+295;
anim_sid_left[5]=sprite_sid1+247;

//Set up start frames here too
//These are the frames which are initially drawn when
//the map is drawn
//player sprite
start_frame[0]=sprite_sid1+7;

//enemies
for(i=1;i<MAX_SPRITES;i++)
	start_frame[i]=sprite_enemy1+7+(96*(i-1));
}

//Only needed for debugging
/*
void debug_msg(char *msg)
{
printf("Debug: %s\n",msg);
WAIT_KEY;
}
*/

void init_im2_handler(void)
{
#asm  //Disable interrupts
di
#endasm

//Use ISR jump table in standard locations reserved by SP1 library
im2_Init(0xd000);
memset(0xd000,0xd1,257); //Fill 257-byte table with 0xd1d1 

//In this game, the ISR does nothing, so just return immediately 
//(Do not push/pop registers) - poke "RETI" instruction at start
//of ISR routine
bpoke(0xd1d1,0xed);
bpoke(0xd1d2,0x4d);

#asm   //Re-enable interrupts
ei
#endasm

}

void init_keyboard(void)
{
//assign keyboard input keys
getjoy = in_JoyKeyboard; //Use keyboard
keys.left = in_LookupKey('o'); //Left
keys.right = in_LookupKey('p'); //Right
keys.up = in_LookupKey('m'); // Jump
keys.down = in_LookupKey('q'); //Also jump 
keys.fire = in_LookupKey('z'); // Also jump
}

void add_sprite_colour(struct sp1_cs *cs)
{
//Only set the colours for the enemy sprites
//The player sprite by default takes the attributes set in sp1_Initialise() 
if(global_n)
	{
	cs->attr=sprite_colour[global_n];
	cs->attr_mask=0;
	}
}


//Simple wrapper function to call bit_fx() soundFX routines
//supplied with Z88DK sound library
void my_bit_fx(byte n, byte m)
{
switch(n)
	{
	case 1: bit_fx(m); break;
	case 2: bit_fx2(m); break;
	case 3: bit_fx3(m); break;
	case 4: bit_fx4(m); break;
	default: break;
	}
}

void draw_status_area(void)
{

setcolmode(32);
setcolattr(7,0,0,1);

draw_level_name();
draw_lives();
draw_nuts();
draw_time();
}

void draw_level_name(void)
{
sprintf(tempstr,"LEVEL %01d: %s",level,level_name[level-1]);
printstrat32(0,17,tempstr);
}

void draw_lives(void)
{
sprintf(tempstr,"LIVES: %03d  ",lives);
printstrat32(0,20,tempstr);
}

void draw_nuts(void)
{
sprintf(tempstr,"NUTS : %03d  ",nuts);
printstrat32(0,19,tempstr);
}

void draw_time(void)
{
sprintf(tempstr,"TIME : %03d  ",time);
printstrat32(0,21,tempstr);
}

void game_over(void)
{
byte i;

//set border
zx_border2(0);

//clear and initialise low res screen
cclg(0);

print_huge_string(0,16,2,"GAME");
print_huge_string(0,24,2,"OVER");


//Play short noise
for(i=0;i<12;i++)
	my_bit_fx(4,2);

WAIT_KEY;
}

void out_of_time(void)
{
byte i;

//set border
zx_border2(0);

//clear and initialise low res screen
cclg(0);

print_huge_string(4,12,2,"OUT");
print_huge_string(8,20,2,"OF");
print_huge_string(0,28,2,"TIME");

//Play short noise
for(i=0;i<12;i++)
	my_bit_fx(4,2);

WAIT_KEY;
}


void won_game(void)
{
byte i;

//set border
zx_border2(0);

//clear and initialise low res screen
cclg(0);

print_huge_string(0,8,6,"WELL");
print_huge_string(0,16,6,"DONE");
print_huge_string(4,24,4,"YOU");
print_huge_string(0,32,4,"WON!");

//Play short noise
for(i=0;i<3;i++)
	my_bit_fx(4,1);

WAIT_KEY;
}

void print_huge_char(byte x, byte y, byte i, char c)
{
word k;

//get base address of character from ROM
k=0x3d00+((c-32)<<3);

//copy character from ROM to "monochrome sprite" array
memcpy(&mono_sprite0[2],(byte *)k,8);

cputsprite(i,x,y,mono_sprite0);
}

void print_huge_string(byte x, byte y, byte i, char *s)
{
char c;
while(c=*s++)
	{
	print_huge_char(x,y,i,c);
	x+=8;	
	}
}

//Decrunch level data (Compression needed to fit more levels into limited memory space)
//Uncompressed level size=512 bytes. 
//Typical compressed size varies from around 80 bytes to 160 bytes per level

void decrunch_level_data(char *out, byte *in, word size)
{
//t=byte read from input stream
//r=right nybble of byte 't' needed if RLE byte found
byte t,r;
//i="nybble offset" into input stream
//o=byte offset into output stream 
word i,o;
//Inner loop control variable needed for RLE expansion
byte j;

for(i=0,o=0;o<size;i++,o++)
	{
	//check for even 'i'
	if(!(i&1))
		{
		//left nybble
		t=in[i>>1]>>4;
		//Check for RLE compression in left-nybble only
		if((t==0x0d)||(t==0x0e))
			{
			//get right nybble - indicates number of repetitions
			r=in[i>>1]&0x0f;
			//if r==0 then it implies r=16
			for(j=0;j<(r?r:16);j++)
				{
				//0xd?=wall, 0xe?=empty space
				//each RLE byte on the input stream
				//generates 2xn bytes on the output stream
				out[o++]=(t==0x0d?'a':' ');
				out[o++]=(t==0x0d?'a':' ');	
				}
			//decrement the output offset counter by one, as it will
			//be auto-incremented on next iteration
			o--;

			//increment the output offset by 1 (skip right nybble on next iteration)
			i++;

			//skip normal "uncompressed" interpretation of this nybble
			continue; //jump straight to next iteration
			}		
	
		}
	else
		{
		//right nybble
		t=in[i>>1]&0x0f;
		}
	//decode uncompressed nybble
	//digits '0'-'9'
	if(t<=9)
		out[o]='0'+t;
	//letters 'a'-'c'
	else if((t>=0x0a)&&(t<=0x0c))
		out[o]='a'+t-0x0a;
	//empty space
	else
		out[o]=' ';	
	}
}

/* 
Project History

27th December 2010: The day after the first "Sid Spanners" game is released, 
	work is started on this sequel, using the source code from that game.

28th December 2010: With the decrunch_level_data() function implemented it's
now possible to store around four times the number of levels in a given space 
than in the first game. I write a small Linux utility in C called "lcrunch"
to automate compression of the level data from the uncompressed "Sid Spanners 1"
 format. (It's still easier to work with uncompressed levels during the
development phase).

29th December 2010: after learning more about the SP1 library, I reshuffle
the heap, stack and IM2 vector table in memory and also eliminate the (unused)
sprite mask data. A couple more Kilobytes of RAM is saved.

1st January 2010: All 54 levels now designed, implemented and compressed. The game is essentially
completed. Just 80 free bytes of RAM remain between the top of the program and the IM2 vector table

2nd January 2011: Playtesting. It takes me three hours to play through the game from start 
to finish. I find about four minor bugs in the game, including a single
brick in the wrong place on level 52, making it impossible to complete without losing a life.
Another bug is that the Trampoline level allows the player to win the level by exiting via
the trampoline rather than by the door. I also find a nut one square out of position in
"Mirror Mirror" which breaks the intended symmetry. Also discover the need for a short sound on the
intro screen to act as a keypress detection delay. Also find some remnats of debugging code
to be removed which should free up a few more bytes.

2nd January 2011: All of the above bugs fixed. Another playtesting run needed to ensure nothing
was broken by the fixes. 123 bytes now remain.

2nd January 2011: All adjusted levels (and a few more) played through without problems.
Version 1.0 of the game released.

*/

//End "Sid Spanners 2: The Slackening" Source Code