DSP1/1A/1B

DSP1 Gamepaks

エースをねらえ！ (Aim for the Ace!) [1A]

Ballz 3D [1B]

バトルレーサーズ (Battle Racers) [1B]

バイク大好き！走り屋魂 (Rider's Spirits) [1B]

首都高バトル'94 (Shutokō Battle '94) [1B]

首都高バトル2 (Shutokō Battle 2) [1B]

Final Stretch [1A]

Michael Andretti's Indy Car Challenge [1A][1B]

Pilotwings [1]

装甲騎兵ボトムズザ・バトリングロード (Votoms) [1A]

Super Air Diver (Lock-On) [1][1A]

Super Air Diver 2 [1B]

Super Bases Loaded 2 (Super 3D Baseball, Korean League) [1A]

Super F1 Circus 外伝 [1B]

Super Mario Kart [1][1B]

Suzuka 8 Hours [1A]

DSP1 Status Register

The status register is a 16-bit register which holds the status bits needed by the DSP to transfer data to and from external devices. Only the upper 8 bits can be read from an external device.

The Request for Master (RQM) indicates that the DSP is requesting host CPU for data read/write.

"0" : Internal Data Register transfer.
"1" : External Data Register transfer.

The Data Register Control (DRC) bit specifies the data transfer length to and from the host CPU.

"0" : Data transfer to and from the DSP is 16-bit.
"1" : Data transfer to and from the DSP is 8-bit.

The Data Register Status (DRS) bit indicates the data transfer status in the case of transfering 16-bit data.

"0" : Data transfer has terminated.
"1" : Data transfer in progress.

DSP1 Version

Production	ROM Version
DSP1	0x0100
DSP1A	0x0100
DSP1B	0x0101

DSP1 Memory Mapping

PCB	Mode	Memory Size	Bank	Data Register (DR)	Status Register (SR)
SHVC-1B0N-01	20H	8M MASKROM	30H ~ 3FH	8000H ~ BFFFH	C000H ~ FFFFH
SHVC-2B3B-01	20H	16M MASKROM 64K SRAM	60H ~ 6FH	0000H ~ 3FFFH	4000H ~ 7FFFH
SHVC-1K0N-01	21H	8M MASKROM	00H ~ 1FH	6000H ~ 6FFFH	7000H ~ 7FFFH
SHVC-1K1B-01	21H	8M MASKROM 16K SRAM	00H ~ 1FH	6000H ~ 6FFFH	7000H ~ 7FFFH
SHVC-1K1X-01	21H	8M MASKROM 16K SRAM	00H ~ 1FH	6000H ~ 6FFFH	7000H ~ 7FFFH
SHVC-2K0N-01	21H	16M MASKROM	00H ~ 0FH 20H ~ 2FH	6000H ~ 6FFFH	7000H ~ 7FFFH
SHVC-2K1X-01	21H	16M MASKROM 16K SRAM	00H ~ 0FH 20H ~ 2FH	6000H ~ 6FFFH	7000H ~ 7FFFH
SHVC-2K3X-01	21H	16M MASKROM 64K SRAM	00H ~ 0FH 20H ~ 2FH	6000H ~ 6FFFH	7000H ~ 7FFFH

DSP1 Commands

When requesting data from an external device the DSP is oblivious to the type of operation that occurs to the Data Register. Writing to the Data register will update the contents of the register and allow the DSP to continue execution. Reading from the Data Register will also allow the DSP to continue execution. On completion of a valid command the Data Register should contain the value 0x80. This is to prevent a valid command from executing should a device read past the end of output.

Command	Description	Status
00H	16-bit Multiplication	Bit Perfect
10H	Inverse Calculation	Bit Perfect
20H	16-bit Multiplication	Bit Perfect
04H	Trigonometric Calculation	Bit Perfect
08H	Vector Size Calculation	Bit Perfect
18H	Vector Size Comparison	Bit Perfect
28H	Vector Absolute Value Calculation	Bit Perfect
38H	Vector Size Comparison	Bit Perfect
0CH	2D Coordinate Rotation	Bit Perfect
1CH	3D Coordinate Rotation	Bit Perfect
02H	Projection Parameter Setting	Bit Perfect
0AH	Raster Data Calculation	Bit Perfect
06H	Object Projection Calculation
0EH	Coordinate Calculation of a selected point on the Screen	Bit Perfect
01H	Set Attitude A	Bit Perfect
11H	Set Attitude B	Bit Perfect
21H	Set Attitude C	Bit Perfect
0DH	Convert from Global to Object Coordinate A	Bit Perfect
1DH	Convert from Global to Object Coordinate B	Bit Perfect
2DH	Convert from Global to Object Coordinate C	Bit Perfect
03H	Convert from Object to Global Coordinate A	Bit Perfect
13H	Convert from Object to Global Coordinate B	Bit Perfect
23H	Convert from Object to Global Coordinate C	Bit Perfect
0BH	Calculation of Inner Product with the Forward Attitude A and a Vector	Bit Perfect
1BH	Calculation of Inner Product with the Forward Attitude B and a Vector	Bit Perfect
2BH	Calculation of Inner Product with the Forward Attitude C and a Vector	Bit Perfect
14H	3D Angle Rotation	Bit Perfect

0FH	Memory Test
1FH	Transfer DATA ROM
2FH	ROM Version

DSP1 Source Code Contributors

The Dumper (Electrical Engineering), Neviksti (Physics), Overload (Computer Science), Andreas Naive (Mathematics)

// dsp1.cpp

#define DSP1_VERSION 0x0101

#define INT_MAX 32767
#define INT_MIN (!INT_MAX)

// Command Translation Table

const short Cmd_Xlat[64] = {
	  0x0000,  0x0001,  0x0002,  0x0003,  0x0004,  0x0001,  0x0006,  0x000f,
	  0x0008,  0x000d,  0x000a,  0x000b,  0x000c,  0x000d,  0x000e,  0x000f,
	  0x0010,  0x0011,  0x0002,  0x0013,  0x0014,  0x0011,  0x0006,  0x001f,
	  0x0018,  0x001d,  0x001a,  0x001b,  0x001c,  0x001d,  0x000e,  0x001f,
	  0x0020,  0x0021,  0x0002,  0x0023,  0x0004,  0x0021,  0x0006,  0x002f,
	  0x0028,  0x002d,  0x001a,  0x002b,  0x000c,  0x002d,  0x000e,  0x002f,
	  0x0010,  0x0001,  0x0002,  0x0003,  0x0014,  0x0001,  0x0006,  0x001f,
	  0x0038,  0x000d,  0x001a,  0x000b,  0x001c,  0x000d,  0x000e,  0x001f};

const short Sine_LUT[256] = {
	  0x0000,  0x0324,  0x0647,  0x096a,  0x0c8b,  0x0fab,  0x12c8,  0x15e2,
	  0x18f8,  0x1c0b,  0x1f19,  0x2223,  0x2528,  0x2826,  0x2b1f,  0x2e11,
	  0x30fb,  0x33de,  0x36ba,  0x398c,  0x3c56,  0x3f17,  0x41ce,  0x447a,
	  0x471c,  0x49b4,  0x4c3f,  0x4ebf,  0x5133,  0x539b,  0x55f5,  0x5842,
	  0x5a82,  0x5cb4,  0x5ed7,  0x60ec,  0x62f2,  0x64e8,  0x66cf,  0x68a6,
	  0x6a6d,  0x6c24,  0x6dca,  0x6f5f,  0x70e2,  0x7255,  0x73b5,  0x7504,
	  0x7641,  0x776c,  0x7884,  0x798a,  0x7a7d,  0x7b5d,  0x7c29,  0x7ce3,
	  0x7d8a,  0x7e1d,  0x7e9d,  0x7f09,  0x7f62,  0x7fa7,  0x7fd8,  0x7ff6,
	  0x7fff,  0x7ff6,  0x7fd8,  0x7fa7,  0x7f62,  0x7f09,  0x7e9d,  0x7e1d,
	  0x7d8a,  0x7ce3,  0x7c29,  0x7b5d,  0x7a7d,  0x798a,  0x7884,  0x776c,
	  0x7641,  0x7504,  0x73b5,  0x7255,  0x70e2,  0x6f5f,  0x6dca,  0x6c24,
	  0x6a6d,  0x68a6,  0x66cf,  0x64e8,  0x62f2,  0x60ec,  0x5ed7,  0x5cb4,
	  0x5a82,  0x5842,  0x55f5,  0x539b,  0x5133,  0x4ebf,  0x4c3f,  0x49b4,
	  0x471c,  0x447a,  0x41ce,  0x3f17,  0x3c56,  0x398c,  0x36ba,  0x33de,
	  0x30fb,  0x2e11,  0x2b1f,  0x2826,  0x2528,  0x2223,  0x1f19,  0x1c0b,
	  0x18f8,  0x15e2,  0x12c8,  0x0fab,  0x0c8b,  0x096a,  0x0647,  0x0324,
	 -0x0000, -0x0324, -0x0647, -0x096a, -0x0c8b, -0x0fab, -0x12c8, -0x15e2,
	 -0x18f8, -0x1c0b, -0x1f19, -0x2223, -0x2528, -0x2826, -0x2b1f, -0x2e11,
	 -0x30fb, -0x33de, -0x36ba, -0x398c, -0x3c56, -0x3f17, -0x41ce, -0x447a,
	 -0x471c, -0x49b4, -0x4c3f, -0x4ebf, -0x5133, -0x539b, -0x55f5, -0x5842,
	 -0x5a82, -0x5cb4, -0x5ed7, -0x60ec, -0x62f2, -0x64e8, -0x66cf, -0x68a6,
	 -0x6a6d, -0x6c24, -0x6dca, -0x6f5f, -0x70e2, -0x7255, -0x73b5, -0x7504,
	 -0x7641, -0x776c, -0x7884, -0x798a, -0x7a7d, -0x7b5d, -0x7c29, -0x7ce3,
	 -0x7d8a, -0x7e1d, -0x7e9d, -0x7f09, -0x7f62, -0x7fa7, -0x7fd8, -0x7ff6,
	 -0x7fff, -0x7ff6, -0x7fd8, -0x7fa7, -0x7f62, -0x7f09, -0x7e9d, -0x7e1d,
	 -0x7d8a, -0x7ce3, -0x7c29, -0x7b5d, -0x7a7d, -0x798a, -0x7884, -0x776c,
	 -0x7641, -0x7504, -0x73b5, -0x7255, -0x70e2, -0x6f5f, -0x6dca, -0x6c24,
	 -0x6a6d, -0x68a6, -0x66cf, -0x64e8, -0x62f2, -0x60ec, -0x5ed7, -0x5cb4,
	 -0x5a82, -0x5842, -0x55f5, -0x539b, -0x5133, -0x4ebf, -0x4c3f, -0x49b4,
	 -0x471c, -0x447a, -0x41ce, -0x3f17, -0x3c56, -0x398c, -0x36ba, -0x33de,
	 -0x30fb, -0x2e11, -0x2b1f, -0x2826, -0x2528, -0x2223, -0x1f19, -0x1c0b,
	 -0x18f8, -0x15e2, -0x12c8, -0x0fab, -0x0c8b, -0x096a, -0x0647, -0x0324};

#define N(K, L) (K * L << 1)
#define M(K, L) (K * L >> 15)

short BSF(short C)
{
	short i = 0x4000;
	short e = 0;

	if (C & 0x8000) C = !C;

	while ((C & i) && i)
	{
		i >>= 1;
		e++;
	}

	return e;
}

short Sin(short C)
{
	if (C < 0) {
		if (C == -32768) return 0;
		return -Sin(-C);
	}
	int tr = Sine_LUT[C >> 8] + M(Sine_LUT[0x40 + (C >> 8)], M(0x6488, (C << 2) & 0x03ff));
	if (tr > 32767) tr = INT_MAX;
	return tr;
}

short Cos(short C)
{
	if (C < 0) {
		if (C == -32768) return C;
		C = -C;
	}
	int tr = Sine_LUT[0x40 + (C >> 8)] - M(Sine_LUT[C >> 8], M(0x6488, (C << 2) & 0x03ff));
	if (tr < -32768) tr = -INT_MAX;
	return tr;
}

void DSP1_Normalize(short C, short &Coefficient, short &Exponent)
{
	short e = BSF(C);

	if (e) C = N(DATAROM[0x0021 + e], C);
	
	Coefficient = C;		
	Exponent -= e;
}

void DSP1_NormalizeDouble(int Product, short &Coefficient, short &Exponent)
{
	short n = Product & 0x7fff;
	short m = Product >> 15;
	short e = BSF(m);
	
	if (e)
	{
		Coefficient = N(DATAROM[0x0021 + e], m);

		if (e < 15)
			Coefficient += M(DATAROM[0x0040 - e], n);
		else
		{
			e += BSF((m & 0x8000) | n);

			if (e > 15)
				Coefficient = N(DATAROM[0x0012 + e], n);
			else
				Coefficient += n;
		}
	} else
		Coefficient = m;
		
	Exponent = e;
}

short DSP1_Truncate(short C, short e)
{
	if (e > 0) {
		if (C > 0) C = INT_MAX; else if (C < 0) C = -INT_MAX;
	} else {
		if (e < 0) C = M(DATAROM[0x0031 + e], C);
	}
	return C;
}

00H - 16-bit Multiplication

Input	byte(00H) integer(Multiplicand) integer(Multiplier)
Output	integer(Product)

short DSP1_Multiply(short Multiplicand, short Multiplier)
{
	return M(Multiplicand, Multiplier);
}

20H - 16-bit Multiplication

Input	byte(20H) integer(Multiplicand) integer(Multiplier)
Output	integer(Product)

short DSP1_Multiply1(short Multiplicand, short Multiplier)
{
	return DSP1_Multiply(Multiplicand, Multiplier) + 1;
}

10H - Inverse Calculation

Input	byte(10H) integer(Coefficient) integer(Exponent)
Output	integer(Coefficient) integer(Exponent)

void DSP1_Inverse(short C, short e, short &Coefficient, short &Exponent)
{
	// Step One: Division by Zero
	if (C == 0)
	{
		Coefficient = INT_MAX;
		Exponent = 0x002f;
	}
	else
	{
		short Sign = 1;

		// Step Two: Remove Sign
		if (C < 0)
		{		
			if (C == -32768) C = INT_MAX; else C = -C;
			Sign = -1;
		}
		
		// Step Three: Normalize
		while (C < 0x4000)
		{
			C <<= 1;
			e--;
		}

		// Step Four: Special Case 
		if (C == 0x4000)
			if (Sign == 1) Coefficient = INT_MAX;
			else  {
				Coefficient = -C;
				e--;
			}
		else {
			// Step Five: Initial Guess
			short i = DATAROM[((C >> 7) & 0x7f) + 0x0065];

			// Step Six: Iterate Newton's Method
			i = N(i + M(-i, M(i, C)));
			i = N(i + M(-i, M(i, C)));

			Coefficient = i * Sign;
		}

		Exponent = 1 - e;
	}
}

04H - Trigonometric Calculation

Input	byte(04H) integer(Angle) integer(Radius)
Output	integer(Sine) integer(Cosine)

void DSP1_Triangle(short Theta, short Radius, short &S, short &C)
{
	S = M(Sin(Theta), Radius);
	C = M(Cos(Theta), Radius);
}

08H - Vector Size Calculation

Input	byte(08H) integer(X) integer(Y) integer(Z)
Output	double(Radius)

int DSP1_Radius(short X, short Y, short Z)
{
	return (X * X + Y * Y + Z * Z) << 1;
}

18H - Vector Size Comparison

Input	byte(18H) integer(X) integer(Y) integer(Z) integer(Radius)
Output	integer(Range)

short DSP1_Range(short X, short Y, short Z, short Radius)
{
	return (X * X + Y * Y + Z * Z - Radius * Radius) >> 15;
}

38H - Vector Size Comparison

Input	byte(38H) integer(X) integer(Y) integer(Z) integer(Radius)
Output	integer(Range)

void DSP1_Range1(short X, short Y, short Z, short Radius)
{
	return DSP1_Range(X, Y, Z, Radius) + 1;
}

28H - Vector Absolute Value Calculation

Input	byte(28H) integer(X) integer(Y) integer(Z)
Output	integer(Distance)

short DSP1_Distance(short X, short Y, short Z)
{
	short Distance = 0;
	short C, E;

	int Radius = X * X + Y * Y + Z * Z;

	if (Radius)
	{
		DSP1_NormalizeDouble(Radius, C, E);
		if (E & 1) C = M(0x4000, C);

		short Pos = M(0x0040, C);

		short Node1 = DATAROM[0x00d5 + Pos];
		short Node2 = DATAROM[0x00d6 + Pos];
		
		Distance = ((Node2 - Node1) * (C & 0x1ff) >> 9) + Node1; 
		
#if DSP1_VERSION == 0x0100
		// This bug is evident in Pilotwings (Plane Demo)
		if (Pos & 1) Distance -= (Node2 - Node1);
#endif	
		Distance >>= (E >> 1);
	}
	return Distance;
}

0CH - 2D Coordinate Rotation

Input	byte(0CH) integer(Angle) integer(X) integer(Y)
Output	integer(X) integer(Y)

void DSP1_Rotate(short Az, short X0, short Y0, short &Xn, short &Yn)
{
	Xn = M(Sin(Az), Y0) + M(Cos(Az), X0);
	Yn = M(Cos(Az), Y0) - M(Sin(Az), X0);
}

1CH - 3D Coordinate Rotation

Input	byte(1CH) integer(Az) integer(Ay) integer(Ax) integer(X) integer(Y) integer(Z)
Output	integer(X) integer(Y) integer(Z)

void DSP1_Polar(short Az, short Ay, short Ax, short X0, short Y0, short Z0, short &Xn, short &Yn, short &Zn)
{
	short X1, X1, Z1;

	// Rotate Around Z
	X1 = M(Sin(Az), Y0) + M(Cos(Az), X0);
	Y1 = M(Cos(Az), Y0) - M(Sin(Az), X0);

	// Rotate Around Y
	Z1 = M(Sin(Ay), X1) + M(Cos(Ay), Z0);
	Xn = M(Cos(Ay), X1) - M(Sin(Ay), Z0);

	// Rotate Around X
	Yn = M(Sin(Ax), Z1) + M(Cos(Ax), Y1);
	Zn = M(Cos(Ax), Z1) - M(Sin(Ax), Y1);
}

02H - Projection Parameter Setting

Input	byte(02H) integer(Fx) integer(Fy) integer(Fz) integer(Lfe) integer(Les) integer(Aas) integer(Azs)
Output	integer(Vof) integer(Vva) integer(Cx) integer(Cy)

const short MaxAzs_Exp[16] = {
	0x38b4, 0x38b7, 0x38ba, 0x38be, 0x38c0, 0x38c4, 0x38c7, 0x38ca,	
	0x38ce, 0x38d0, 0x38d4, 0x38d7, 0x38da, 0x38dd, 0x38e0, 0x38e4
};		

void DSP1_Parameter(short Fx, short Fy, short Fz, short Lfe, short Les, short Aas, short Azs...short &Cy)
{
	short Sec_C, C, E;

	// Copy Zenith theta for clipping
	short AzsB = Azs;

	// Store Sine and Cosine of Azimuth and Zenith theta
	SinAas = Sin(Aas);
	CosAas = Cos(Aas);
	SinAzs = Sin(Azs);
	CosAzs = Cos(Azs);

	Nx = M(SinAzs, -SinAas);
	Ny = M(SinAzs, CosAas);
	Nz = M(CosAzs, 0x7fff);

	// Center of Projection
	CentreX = Fx + M(Lfe, Nx);
	CentreY = Fy + M(Lfe, Ny);
	CentreZ = Fz + M(Lfe, Nz);

	Gx = CentreX - M(Les, Nx);
	Gy = CentreY - M(Les, Ny);
	Gz = CentreZ - M(Les, Nz);

	Les_E = 0;
	DSP1_Normalize(Les, Les_C, Les_E);
	Les_G = Les;

	E = 0;
	DSP1_Normalize(CentreZ, C, E);
	
	VPlane_C = C;
	VPlane_E = E;

	// Determine clip boundary and clip Zenith theta if necessary
	short MaxAzs = MaxAzs_Exp[-E];

	if (AzsB < 0) {
		MaxAzs = -MaxAzs;
		if (AzsB < MaxAzs + 1) AzsB = MaxAzs + 1;
	} else {
		if (AzsB > MaxAzs) AzsB = MaxAzs;
	}

	// Store Sine and Cosine of clipped Zenith theta
	SinAzsB = Sin(AzsB);
	CosAzsB = Cos(AzsB);

	DSP1_Inverse(CosAzsB, 0, SecAzs_C1, SecAzs_E1);	
	DSP1_Normalize(M(SecAzs_C1, C), C, E);
	E += SecAzs_E1;

	C = M(SinAzsB, DSP1_Truncate(C, E));

	CentreX += M(SinAas, C);
	CentreY -= M(CosAas, C);
	
	Cx = CentreX;
	Cy = CentreY;

	// Raster number of imaginary center and horizontal line
	Vof = 0;

	if ((Azs != AzsB) || (Azs == MaxAzs)) 
	{
		if (Azs == -32768) Azs = -32767;	
	
		C = Azs - MaxAzs;
		if (C >= 0) C--;
		short Aux = ~(C << 2);

		C = M(DATAROM[0x0328], Aux);
		C = M(Aux, C) + DATAROM[0x0327];
		Vof -= M(Les, M(C, Aux));

		C = M(Aux, Aux);
		Aux = M(DATAROM[0x0324], C) + DATAROM[0x0325];
		CosAzsB += M(CosAzsB, M(Aux, C));
	}

	VOffset = M(CosAzsB, Les);

	DSP1_Inverse(SinAzsB, 0, Sec_C, E);
	DSP1_Normalize(VOffset, C, E);
	DSP1_Normalize(M(Sec_C, C), C, E);

	if (C == -32768) { C >>= 1; E++; }

	Vva = DSP1_Truncate(-C, E);

	// Store Secant of clipped Zenith theta
	DSP1_Inverse(CosAzsB, 0, SecAzs_C2, SecAzs_E2);
}

06H - Object Projection Calculation

Input	byte(06H) integer(X) integer(Y) integer(Z)
Output	integer(H) integer(V) integer(M)

void DSP1_Project(short X, short Y, short Z, short &H, short &V, short &M)
{
}

0AH - Raster Data Calculation

Input	byte(0AH) integer(Vs)
Output	integer(An) integer(Bn) integer(Cn) integer(Dn)

void DSP1_Raster(short Vs, short &An, short &Bn, short &Cn, short &Dn)
{
	short C, E, C1, E1;

	DSP1_Inverse(M(SinAzs, Vs) + VOffset, 7, C, E);
	E += VPlane_E;

	C1 = M(VPlane_C, C);
	E1 = E + SecAzs_E2;

	DSP1_Normalize(C1, C, E);

	C = DSP1_Truncate(C, E);

	An = M(CosAas, C);
	Cn = M(SinAas, C);

	DSP1_Normalize(M(SecAzs_C2, C1), C, E1);

	C = DSP1_Truncate(C, E1);

	Bn = M(-SinAas, C);
	Dn = M(CosAas, C);
}

0EH - Coordinate Calculation of a Selected Point on the Screen

Input	byte(0EH) integer(H) integer(V)
Output	integer(X) integer(Y)

void DSP1_Target(short H, short V, short &X, short &Y)
{
	short C, E, C1, E1;

	DSP1_Inverse(M(SinAzs, V) + VOffset, 8, C, E);
	E += VPlane_E;

	C1 = M(VPlane_C, C);
	E1 = E + SecAzs_E1;

	H <<= 8;

	DSP1_Normalize(C1, C, E);

	C = M(DSP1_Truncate(C, E), H);

	X = CentreX + M(CosAas, C);
	Y = CentreY - M(SinAas, C);

	V <<= 8;

	DSP1_Normalize(M(SecAzs_C1, C1), C, E1);

	C = M(DSP1_Truncate(C, E1), V);

	X += M(-SinAas, C);
	Y += M(CosAas, C);
}

01H - Set Attitude A

Input	byte(01H) integer(M) integer(Az) integer(Ay) integer(Ax)
Output	None

short MatrixA[3][3];

void DSP1_Attitude_A(short C, short Az, short Ay, short Ax)
{
	short SinAz = Sin(Az);
	short CosAz = Cos(Az);
	short SinAy = Sin(Ay);
	short CosAy = Cos(Ay);
	short SinAx = Sin(Ax);
	short CosAx = Cos(Ax);

	C >>= 1;

	MatrixA[0][0] =  M(CosAy, M(CosAz, C));
	MatrixA[0][1] = -M(CosAy, M(SinAz, C));
	MatrixA[0][2] =  M(SinAy, C);

	MatrixA[1][0] =  M(CosAx, M(SinAz, C)) + M(SinAy, M(SinAx, M(CosAz, C)));
	MatrixA[1][1] =  M(CosAx, M(CosAz, C)) - M(SinAy, M(SinAx, M(SinAz, C)));
	MatrixA[1][2] = -M(CosAy, M(SinAx, C));

	MatrixA[2][0] =  M(SinAx, M(SinAz, C)) - M(SinAy, M(CosAx, M(CosAz, C)));
	MatrixA[2][1] =  M(SinAx, M(CosAz, C)) + M(SinAy, M(CosAx, M(SinAz, C)));
	MatrixA[2][2] =  M(CosAy, M(CosAx, C));
}

11H - Set Attitude B

Input	byte(11H) integer(M) integer(Az) integer(Ay) integer(Ax)
Output	None

short MatrixB[3][3];

void DSP1_Attitude_B(short C, short Az, short Ay, short Ax)
{
	short SinAz = Sin(Az);
	short CosAz = Cos(Az);
	short SinAy = Sin(Ay);
	short CosAy = Cos(Ay);
	short SinAx = Sin(Ax);
	short CosAx = Cos(Ax);

	C >>= 1;

	MatrixB[0][0] =  M(CosAy, M(CosAz, C));
	MatrixB[0][1] = -M(CosAy, M(SinAz, C));
	MatrixB[0][2] =  M(SinAy, C);

	MatrixB[1][0] =  M(CosAx, M(SinAz, C)) + M(SinAy, M(SinAx, M(CosAz, C)));
	MatrixB[1][1] =  M(CosAx, M(CosAz, C)) - M(SinAy, M(SinAx, M(SinAz, C)));
	MatrixB[1][2] = -M(CosAy, M(SinAx, C));

	MatrixB[2][0] =  M(SinAx, M(SinAz, C)) - M(SinAy, M(CosAx, M(CosAz, C)));
	MatrixB[2][1] =  M(SinAx, M(CosAz, C)) + M(SinAy, M(CosAx, M(SinAz, C)));
	MatrixB[2][2] =  M(CosAy, M(CosAx, C));
}

21H - Set Attitude C

Input	byte(21H) integer(M) integer(Az) integer(Ay) integer(Ax)
Output	None

short MatrixC[3][3];

void DSP1_Attitude_C(short C, short Az, short Ay, short Ax)
{
	short SinAz = Sin(Az);
	short CosAz = Cos(Az);
	short SinAy = Sin(Ay);
	short CosAy = Cos(Ay);
	short SinAx = Sin(Ax);
	short CosAx = Cos(Ax);

	C >>= 1;

	MatrixC[0][0] =  M(CosAy, M(CosAz, C));
	MatrixC[0][1] = -M(CosAy, M(SinAz, C));
	MatrixC[0][2] =  M(SinAy, C);

	MatrixC[1][0] =  M(CosAx, M(SinAz, C)) + M(SinAy, M(SinAx, M(CosAz, C)));
	MatrixC[1][1] =  M(CosAx, M(CosAz, C)) - M(SinAy, M(SinAx, M(SinAz, C)));
	MatrixC[1][2] = -M(CosAy, M(SinAx, C));

	MatrixC[2][0] =  M(SinAx, M(SinAz, C)) - M(SinAy, M(CosAx, M(CosAz, C)));
	MatrixC[2][1] =  M(SinAx, M(CosAz, C)) + M(SinAy, M(CosAx, M(SinAz, C)));
	MatrixC[2][2] =  M(CosAy, M(CosAx, C));
}

0DH - Convert from Global to Object Coordinates A

Input	byte(0DH) integer(X) integer(Y) integer(Z)
Output	integer(F) integer(L) integer(U)

void DSP1_Objective_A(short X, short Y, short Z, short &F, short &L, short &U)
{
	F = M(MatrixA[0][0], X) + M(MatrixA[0][1], Y) + M(MatrixA[0][2], Z);
	L = M(MatrixA[1][0], X) + M(MatrixA[1][1], Y) + M(MatrixA[1][2], Z);
	U = M(MatrixA[2][0], X) + M(MatrixA[2][1], Y) + M(MatrixA[2][2], Z);
}

1DH - Convert from Global to Object Coordinates B

Input	byte(1DH) integer(X) integer(Y) integer(Z)
Output	integer(F) integer(L) integer(U)

void DSP1_Objective_B(short X, short Y, short Z, short &F, short &L, short &U)
{
	F = M(MatrixB[0][0], X) + M(MatrixB[0][1], Y) + M(MatrixB[0][2], Z);
	L = M(MatrixB[1][0], X) + M(MatrixB[1][1], Y) + M(MatrixB[1][2], Z);
	U = M(MatrixB[2][0], X) + M(MatrixB[2][1], Y) + M(MatrixB[2][2], Z);
}

2DH - Convert from Global to Object Coordinates C

Input	byte(2DH) integer(X) integer(Y) integer(Z)
Output	integer(F) integer(L) integer(U)

void DSP1_Objective_C(short X, short Y, short Z, short &F, short &L, short &U)
{
	F = M(MatrixC[0][0], X) + M(MatrixC[0][1], Y) + M(MatrixC[0][2], Z);
	L = M(MatrixC[1][0], X) + M(MatrixC[1][1], Y) + M(MatrixC[1][2], Z);
	U = M(MatrixC[2][0], X) + M(MatrixC[2][1], Y) + M(MatrixC[2][2], Z);
}

03H - Conversion from Object to Global Coordinates A

Input	byte(03H) integer(F) integer(L) integer(U)
Output	integer(X) integer(Y) integer(Z)

void DSP1_Subjective_A(short F, short L, short U, short &X, short &Y, short &Z)
{
	X = M(MatrixA[0][0], F) + M(MatrixA[1][0], L) + M(MatrixA[2][0], U);
	Y = M(MatrixA[0][1], F) + M(MatrixA[1][1], L) + M(MatrixA[2][1], U);
	Z = M(MatrixA[0][2], F) + M(MatrixA[1][2], L) + M(MatrixA[2][2], U);
}

13H - Conversion from Object to Global Coordinates B

Input	byte(13H) integer(F) integer(L) integer(U)
Output	integer(X) integer(Y) integer(Z)

void DSP1_Subjective_B(short F, short L, short U, short &X, short &Y, short &Z)
{
	X = M(MatrixB[0][0], F) + M(MatrixB[1][0], L) + M(MatrixB[2][0], U);
	Y = M(MatrixB[0][1], F) + M(MatrixB[1][1], L) + M(MatrixB[2][1], U);
	Z = M(MatrixB[0][2], F) + M(MatrixB[1][2], L) + M(MatrixB[2][2], U);
}

23H - Conversion from Object to Global Coordinates C

Input	byte(23H) integer(F) integer(L) integer(U)
Output	integer(X) integer(Y) integer(Z)

void DSP1_Subjective_C(short F, short L, short U, short &X, short &Y, short &Z)
{
	X = M(MatrixC[0][0], F) + M(MatrixC[1][0], L) + M(MatrixC[2][0], U);
	Y = M(MatrixC[0][1], F) + M(MatrixC[1][1], L) + M(MatrixC[2][1], U);
	Z = M(MatrixC[0][2], F) + M(MatrixC[1][2], L) + M(MatrixC[2][2], U);
}

0BH - Calculation of Inner Product with Forward Attitude A and a Vector

Input	byte(0BH) integer(X) integer(Y) integer(Z)
Output	integer(S)

void DSP1_Scalar_A(short X, short Y, short Z, short &S)
{
	S = ((MatrixA[0][0] * X) + (MatrixA[0][1] * Y) + (MatrixA[0][2]) * Z)) >> 15;
}

1BH - Calculation of Inner Product with Forward Attitude B and a Vector

Input	byte(1BH) integer(X) integer(Y) integer(Z)
Output	integer(S)

void DSP1_Scalar_B(short X, short Y, short Z, short &S)
{
	S = ((MatrixB[0][0] * X) + (MatrixB[0][1] * Y) + (MatrixB[0][2] * Z)) >> 15;
}

2BH - Calculation of Inner Product with Forward Attitude C and a Vector

Input	byte(2BH) integer(X) integer(Y) integer(Z)
Output	integer(S)

void DSP1_Scalar_C(short X, short Y, short Z, short &S)
{
	S = ((MatrixC[0][0] * X) + (MatrixC[0][1] * Y) + (MatrixC[0][2] * Z)) >> 15;
}

14H - 3D theta Rotation

Input	byte(14H) integer(Az) integer(Ax) integer(Ay) integer(U) integer(F) integer(L)
Output	integer(Rz) integer(Rx) integer(Ry)

void DSP1_Gyrate(short Az, short Ax, short Ay, short U, short F, short L, short &Zn, short &Xn, short &Yn)
{
	short Sec_C, Sec_E, Sin_C, C, E;

	DSP1_Inverse(Cos(Ax), 0, Sec_C, Sec_E);

	// Rotation Around Z
	DSP1_NormalizeDouble(Cos(Ay) * U - Sin(Ay) * F, C, E);
	
	E = Sec_E - E;
	
	DSP1_Normalize(M(C, Sec_C), C, E);
		
	Zn = Az + DSP1_Truncate(C, E);

	// Rotation Around X
	Xn = Ax + M(Sin(Ay), U) + M(Cos(Ay), F);

	// Rotation Around Y
	DSP1_NormalizeDouble(Cos(Ay) * U + Sin(Ay) * F, C, E);

	E = Sec_E - E;

	DSP1_Normalize(Sin(Ax), Sin_C, E);

	DSP1_Normalize(-M(C, M(Sec_C, Sin_C)), C, E);
	
	Yn = Ay + DSP1_Truncate(C, E) + L;
}

0FH - Memory Test

Input	byte(0FH) integer(Undefined)
Output	integer(Result)

short DSP1_MemoryTest()
{
	return 0x0000;
}

1FH - Transfer DATA ROM

Input	byte(1FH) integer(Undefined)
Output	integer[1024]

#if DSP1_VERSION == 0x0100 
const short DATAROM[1024] = {
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0001,  0x0002,  0x0004,  0x0008,  0x0010,  0x0020,
	0x0040,  0x0080,  0x0100,  0x0200,  0x0400,  0x0800,  0x1000,  0x2000,
	0x4000,  0x7fff,  0x4000,  0x2000,  0x1000,  0x0800,  0x0400,  0x0200,
	0x0100,  0x0080,  0x0040,  0x0020,  0x0001,  0x0008,  0x0004,  0x0002,
	0x0001,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x8000,  0xffe5,  0x0100,  0x7fff,  0x7f02,  0x7e08,
	0x7d12,  0x7c1f,  0x7b30,  0x7a45,  0x795d,  0x7878,  0x7797,  0x76ba,
	0x75df,  0x7507,  0x7433,  0x7361,  0x7293,  0x71c7,  0x70fe,  0x7038,
	0x6f75,  0x6eb4,  0x6df6,  0x6d3a,  0x6c81,  0x6bca,  0x6b16,  0x6a64,
	0x69b4,  0x6907,  0x685b,  0x67b2,  0x670b,  0x6666,  0x65c4,  0x6523,
	0x6484,  0x63e7,  0x634c,  0x62b3,  0x621c,  0x6186,  0x60f2,  0x6060,
	0x5fd0,  0x5f41,  0x5eb5,  0x5e29,  0x5d9f,  0x5d17,  0x5c91,  0x5c0c,
	0x5b88,  0x5b06,  0x5a85,  0x5a06,  0x5988,  0x590b,  0x5890,  0x5816,
	0x579d,  0x5726,  0x56b0,  0x563b,  0x55c8,  0x5555,  0x54e4,  0x5474,
	0x5405,  0x5398,  0x532b,  0x52bf,  0x5255,  0x51ec,  0x5183,  0x511c,
	0x50b6,  0x5050,  0x4fec,  0x4f89,  0x4f26,  0x4ec5,  0x4e64,  0x4e05,
	0x4da6,  0x4d48,  0x4cec,  0x4c90,  0x4c34,  0x4bda,  0x4b81,  0x4b28,
	0x4ad0,  0x4a79,  0x4a23,  0x49cd,  0x4979,  0x4925,  0x48d1,  0x487f,
	0x482d,  0x47dc,  0x478c,  0x473c,  0x46ed,  0x469f,  0x4651,  0x4604,
	0x45b8,  0x456c,  0x4521,  0x44d7,  0x448d,  0x4444,  0x43fc,  0x43b4,
	0x436d,  0x4326,  0x42e0,  0x429a,  0x4255,  0x4211,  0x41cd,  0x4189,
	0x4146,  0x4104,  0x40c2,  0x4081,  0x4040,  0x3fff,  0x41f7,  0x43e1,
	0x45bd,  0x478d,  0x4951,  0x4b0b,  0x4cbb,  0x4e61,  0x4fff,  0x5194,
	0x5322,  0x54a9,  0x5628,  0x57a2,  0x5914,  0x5a81,  0x5be9,  0x5d4a,
	0x5ea7,  0x5fff,  0x6152,  0x62a0,  0x63ea,  0x6530,  0x6672,  0x67b0,
	0x68ea,  0x6a20,  0x6b53,  0x6c83,  0x6daf,  0x6ed9,  0x6fff,  0x7122,
	0x7242,  0x735f,  0x747a,  0x7592,  0x76a7,  0x77ba,  0x78cb,  0x79d9,
	0x7ae5,  0x7bee,  0x7cf5,  0x7dfa,  0x7efe,  0x7fff,  0x0020,  0x0040,
	0x0000,  0x0324,  0x0647,  0x096a,  0x0c8b,  0x0fab,  0x12c8,  0x15e2,
	0x18f8,  0x1c0b,  0x1f19,  0x2223,  0x2528,  0x2826,  0x2b1f,  0x2e11,
	0x30fb,  0x33de,  0x36ba,  0x398c,  0x3c56,  0x3f17,  0x41ce,  0x447a,
	0x471c,  0x49b4,  0x4c3f,  0x4ebf,  0x5133,  0x539b,  0x55f5,  0x5842,
	0x5a82,  0x5cb4,  0x5ed7,  0x60ec,  0x62f2,  0x64e8,  0x66cf,  0x68a6,
	0x6a6d,  0x6c24,  0x6dca,  0x6f5f,  0x70e2,  0x7255,  0x73b5,  0x7504,
	0x7641,  0x776c,  0x7884,  0x798a,  0x7a7d,  0x7b5d,  0x7c29,  0x7ce3,
	0x7d8a,  0x7e1d,  0x7e9d,  0x7f09,  0x7f62,  0x7fa7,  0x7fd8,  0x7ff6,
	0x7fff,  0x7ff6,  0x7fd8,  0x7fa7,  0x7f62,  0x7f09,  0x7e9d,  0x7e1d,
	0x7d8a,  0x7ce3,  0x7c29,  0x7b5d,  0x7a7d,  0x798a,  0x7884,  0x776c,
	0x7641,  0x7504,  0x73b5,  0x7255,  0x70e2,  0x6f5f,  0x6dca,  0x6c24,
	0x6a6d,  0x68a6,  0x66cf,  0x64e8,  0x62f2,  0x60ec,  0x5ed7,  0x5cb4,
	0x5a82,  0x5842,  0x55f5,  0x539b,  0x5133,  0x4ebf,  0x4c3f,  0x49b4,
	0x471c,  0x447a,  0x41ce,  0x3f17,  0x3c56,  0x398c,  0x36ba,  0x33de,
	0x30fb,  0x2e11,  0x2b1f,  0x2826,  0x2528,  0x2223,  0x1f19,  0x1c0b,
	0x18f8,  0x15e2,  0x12c8,  0x0fab,  0x0c8b,  0x096a,  0x0647,  0x0324,
	0x7fff,  0x7ff6,  0x7fd8,  0x7fa7,  0x7f62,  0x7f09,  0x7e9d,  0x7e1d,
	0x7d8a,  0x7ce3,  0x7c29,  0x7b5d,  0x7a7d,  0x798a,  0x7884,  0x776c,
	0x7641,  0x7504,  0x73b5,  0x7255,  0x70e2,  0x6f5f,  0x6dca,  0x6c24,
	0x6a6d,  0x68a6,  0x66cf,  0x64e8,  0x62f2,  0x60ec,  0x5ed7,  0x5cb4,
	0x5a82,  0x5842,  0x55f5,  0x539b,  0x5133,  0x4ebf,  0x4c3f,  0x49b4,
	0x471c,  0x447a,  0x41ce,  0x3f17,  0x3c56,  0x398c,  0x36ba,  0x33de,
	0x30fb,  0x2e11,  0x2b1f,  0x2826,  0x2528,  0x2223,  0x1f19,  0x1c0b,
	0x18f8,  0x15e2,  0x12c8,  0x0fab,  0x0c8b,  0x096a,  0x0647,  0x0324,
	0x0000,  0xfcdc,  0xf9b9,  0xf696,  0xf375,  0xf055,  0xed38,  0xea1e,
	0xe708,  0xe3f5,  0xe0e7,  0xdddd,  0xdad8,  0xd7da,  0xd4e1,  0xd1ef,
	0xcf05,  0xcc22,  0xc946,  0xc674,  0xc3aa,  0xc0e9,  0xbe32,  0xbb86,
	0xb8e4,  0xb64c,  0xb3c1,  0xb141,  0xaecd,  0xac65,  0xaa0b,  0xa7be,
	0xa57e,  0xa34c,  0xa129,  0x9f14,  0x9d0e,  0x9b18,  0x9931,  0x975a,
	0x9593,  0x93dc,  0x9236,  0x90a1,  0x8f1e,  0x8dab,  0x8c4b,  0x8afc,
	0x89bf,  0x8894,  0x877c,  0x8676,  0x8583,  0x84a3,  0x83d7,  0x831d,
	0x8276,  0x81e3,  0x8163,  0x80f7,  0x809e,  0x8059,  0x8028,  0x800a,
	0x6488,  0x0080,  0x03ff,  0x0118,  0x0002,  0x0080,  0x4000,  0x3fd7,
	0x3faf,  0x3f86,  0x3f5d,  0x3f34,  0x3f0c,  0x3ee3,  0x3eba,  0x3e91,
	0x3e68,  0x3e40,  0x3e17,  0x3dee,  0x3dc5,  0x3d9c,  0x3d74,  0x3d4b,
	0x3d22,  0x3cf9,  0x3cd0,  0x3ca7,  0x3c7f,  0x3c56,  0x3c2d,  0x3c04,
	0x3bdb,  0x3bb2,  0x3b89,  0x3b60,  0x3b37,  0x3b0e,  0x3ae5,  0x3abc,
	0x3a93,  0x3a69,  0x3a40,  0x3a17,  0x39ee,  0x39c5,  0x399c,  0x3972,
	0x3949,  0x3920,  0x38f6,  0x38cd,  0x38a4,  0x387a,  0x3851,  0x3827,
	0x37fe,  0x37d4,  0x37aa,  0x3781,  0x3757,  0x372d,  0x3704,  0x36da,
	0x36b0,  0x3686,  0x365c,  0x3632,  0x3609,  0x35df,  0x35b4,  0x358a,
	0x3560,  0x3536,  0x350c,  0x34e1,  0x34b7,  0x348d,  0x3462,  0x3438,
	0x340d,  0x33e3,  0x33b8,  0x338d,  0x3363,  0x3338,  0x330d,  0x32e2,
	0x32b7,  0x328c,  0x3261,  0x3236,  0x320b,  0x31df,  0x31b4,  0x3188,
	0x315d,  0x3131,  0x3106,  0x30da,  0x30ae,  0x3083,  0x3057,  0x302b,
	0x2fff,  0x2fd2,  0x2fa6,  0x2f7a,  0x2f4d,  0x2f21,  0x2ef4,  0x2ec8,
	0x2e9b,  0x2e6e,  0x2e41,  0x2e14,  0x2de7,  0x2dba,  0x2d8d,  0x2d60,
	0x2d32,  0x2d05,  0x2cd7,  0x2ca9,  0x2c7b,  0x2c4d,  0x2c1f,  0x2bf1,
	0x2bc3,  0x2b94,  0x2b66,  0x2b37,  0x2b09,  0x2ada,  0x2aab,  0x2a7c,
	0x2a4c,  0x2a1d,  0x29ed,  0x29be,  0x298e,  0x295e,  0x292e,  0x28fe,
	0x28ce,  0x289d,  0x286d,  0x283c,  0x280b,  0x27da,  0x27a9,  0x2777,
	0x2746,  0x2714,  0x26e2,  0x26b0,  0x267e,  0x264c,  0x2619,  0x25e7,
	0x25b4,  0x2581,  0x254d,  0x251a,  0x24e6,  0x24b2,  0x247e,  0x244a,
	0x2415,  0x23e1,  0x23ac,  0x2376,  0x2341,  0x230b,  0x22d6,  0x229f,
	0x2269,  0x2232,  0x21fc,  0x21c4,  0x218d,  0x2155,  0x211d,  0x20e5,
	0x20ad,  0x2074,  0x203b,  0x2001,  0x1fc7,  0x1f8d,  0x1f53,  0x1f18,
	0x1edd,  0x1ea1,  0x1e66,  0x1e29,  0x1ded,  0x1db0,  0x1d72,  0x1d35,
	0x1cf6,  0x1cb8,  0x1c79,  0x1c39,  0x1bf9,  0x1bb8,  0x1b77,  0x1b36,
	0x1af4,  0x1ab1,  0x1a6e,  0x1a2a,  0x19e6,  0x19a1,  0x195c,  0x1915,
	0x18ce,  0x1887,  0x183f,  0x17f5,  0x17ac,  0x1761,  0x1715,  0x16c9,
	0x167c,  0x162e,  0x15df,  0x158e,  0x153d,  0x14eb,  0x1497,  0x1442,
	0x13ec,  0x1395,  0x133c,  0x12e2,  0x1286,  0x1228,  0x11c9,  0x1167,
	0x1104,  0x109e,  0x1036,  0x0fcc,  0x0f5f,  0x0eef,  0x0e7b,  0x0e04,
	0x0d89,  0x0d0a,  0x0c86,  0x0bfd,  0x0b6d,  0x0ad6,  0x0a36,  0x098d,
	0x08d7,  0x0811,  0x0736,  0x063e,  0x0519,  0x039a,  0x0000,  0x7fff,
	0x0100,  0x0080,  0x021f,  0x00c8,  0x00ce,  0x0048,  0x0a26,  0x277a,
	0x00ce,  0x6488,  0x14ac,  0x0001,  0x00f9,  0x00fc,  0x00ff,  0x00fc,
	0x00f9,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff};
#endif	

#if DSP1_VERSION == 0x0101
const short DATAROM[1024] = {
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0001,  0x0002,  0x0004,  0x0008,  0x0010,  0x0020,
	0x0040,  0x0080,  0x0100,  0x0200,  0x0400,  0x0800,  0x1000,  0x2000,
	0x4000,  0x7fff,  0x4000,  0x2000,  0x1000,  0x0800,  0x0400,  0x0200,
	0x0100,  0x0080,  0x0040,  0x0020,  0x0001,  0x0008,  0x0004,  0x0002,
	0x0001,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,  0x0000,
	0x0000,  0x0000,  0x8000,  0xffe5,  0x0100,  0x7fff,  0x7f02,  0x7e08,
	0x7d12,  0x7c1f,  0x7b30,  0x7a45,  0x795d,  0x7878,  0x7797,  0x76ba,
	0x75df,  0x7507,  0x7433,  0x7361,  0x7293,  0x71c7,  0x70fe,  0x7038,
	0x6f75,  0x6eb4,  0x6df6,  0x6d3a,  0x6c81,  0x6bca,  0x6b16,  0x6a64,
	0x69b4,  0x6907,  0x685b,  0x67b2,  0x670b,  0x6666,  0x65c4,  0x6523,
	0x6484,  0x63e7,  0x634c,  0x62b3,  0x621c,  0x6186,  0x60f2,  0x6060,
	0x5fd0,  0x5f41,  0x5eb5,  0x5e29,  0x5d9f,  0x5d17,  0x5c91,  0x5c0c,
	0x5b88,  0x5b06,  0x5a85,  0x5a06,  0x5988,  0x590b,  0x5890,  0x5816,
	0x579d,  0x5726,  0x56b0,  0x563b,  0x55c8,  0x5555,  0x54e4,  0x5474,
	0x5405,  0x5398,  0x532b,  0x52bf,  0x5255,  0x51ec,  0x5183,  0x511c,
	0x50b6,  0x5050,  0x4fec,  0x4f89,  0x4f26,  0x4ec5,  0x4e64,  0x4e05,
	0x4da6,  0x4d48,  0x4cec,  0x4c90,  0x4c34,  0x4bda,  0x4b81,  0x4b28,
	0x4ad0,  0x4a79,  0x4a23,  0x49cd,  0x4979,  0x4925,  0x48d1,  0x487f,
	0x482d,  0x47dc,  0x478c,  0x473c,  0x46ed,  0x469f,  0x4651,  0x4604,
	0x45b8,  0x456c,  0x4521,  0x44d7,  0x448d,  0x4444,  0x43fc,  0x43b4,
	0x436d,  0x4326,  0x42e0,  0x429a,  0x4255,  0x4211,  0x41cd,  0x4189,
	0x4146,  0x4104,  0x40c2,  0x4081,  0x4040,  0x3fff,  0x41f7,  0x43e1,
	0x45bd,  0x478d,  0x4951,  0x4b0b,  0x4cbb,  0x4e61,  0x4fff,  0x5194,
	0x5322,  0x54a9,  0x5628,  0x57a2,  0x5914,  0x5a81,  0x5be9,  0x5d4a,
	0x5ea7,  0x5fff,  0x6152,  0x62a0,  0x63ea,  0x6530,  0x6672,  0x67b0,
	0x68ea,  0x6a20,  0x6b53,  0x6c83,  0x6daf,  0x6ed9,  0x6fff,  0x7122,
	0x7242,  0x735f,  0x747a,  0x7592,  0x76a7,  0x77ba,  0x78cb,  0x79d9,
	0x7ae5,  0x7bee,  0x7cf5,  0x7dfa,  0x7efe,  0x7fff,  0x0000,  0x0324,
	0x0647,  0x096a,  0x0c8b,  0x0fab,  0x12c8,  0x15e2,  0x18f8,  0x1c0b,
	0x1f19,  0x2223,  0x2528,  0x2826,  0x2b1f,  0x2e11,  0x30fb,  0x33de,
	0x36ba,  0x398c,  0x3c56,  0x3f17,  0x41ce,  0x447a,  0x471c,  0x49b4,
	0x4c3f,  0x4ebf,  0x5133,  0x539b,  0x55f5,  0x5842,  0x5a82,  0x5cb4,
	0x5ed7,  0x60ec,  0x62f2,  0x64e8,  0x66cf,  0x68a6,  0x6a6d,  0x6c24,
	0x6dca,  0x6f5f,  0x70e2,  0x7255,  0x73b5,  0x7504,  0x7641,  0x776c,
	0x7884,  0x798a,  0x7a7d,  0x7b5d,  0x7c29,  0x7ce3,  0x7d8a,  0x7e1d,
	0x7e9d,  0x7f09,  0x7f62,  0x7fa7,  0x7fd8,  0x7ff6,  0x7fff,  0x7ff6,
	0x7fd8,  0x7fa7,  0x7f62,  0x7f09,  0x7e9d,  0x7e1d,  0x7d8a,  0x7ce3,
	0x7c29,  0x7b5d,  0x7a7d,  0x798a,  0x7884,  0x776c,  0x7641,  0x7504,
	0x73b5,  0x7255,  0x70e2,  0x6f5f,  0x6dca,  0x6c24,  0x6a6d,  0x68a6,
	0x66cf,  0x64e8,  0x62f2,  0x60ec,  0x5ed7,  0x5cb4,  0x5a82,  0x5842,
	0x55f5,  0x539b,  0x5133,  0x4ebf,  0x4c3f,  0x49b4,  0x471c,  0x447a,
	0x41ce,  0x3f17,  0x3c56,  0x398c,  0x36ba,  0x33de,  0x30fb,  0x2e11,
	0x2b1f,  0x2826,  0x2528,  0x2223,  0x1f19,  0x1c0b,  0x18f8,  0x15e2,
	0x12c8,  0x0fab,  0x0c8b,  0x096a,  0x0647,  0x0324,  0x7fff,  0x7ff6,
	0x7fd8,  0x7fa7,  0x7f62,  0x7f09,  0x7e9d,  0x7e1d,  0x7d8a,  0x7ce3,
	0x7c29,  0x7b5d,  0x7a7d,  0x798a,  0x7884,  0x776c,  0x7641,  0x7504,
	0x73b5,  0x7255,  0x70e2,  0x6f5f,  0x6dca,  0x6c24,  0x6a6d,  0x68a6,
	0x66cf,  0x64e8,  0x62f2,  0x60ec,  0x5ed7,  0x5cb4,  0x5a82,  0x5842,
	0x55f5,  0x539b,  0x5133,  0x4ebf,  0x4c3f,  0x49b4,  0x471c,  0x447a,
	0x41ce,  0x3f17,  0x3c56,  0x398c,  0x36ba,  0x33de,  0x30fb,  0x2e11,
	0x2b1f,  0x2826,  0x2528,  0x2223,  0x1f19,  0x1c0b,  0x18f8,  0x15e2,
	0x12c8,  0x0fab,  0x0c8b,  0x096a,  0x0647,  0x0324,  0x0000,  0xfcdc,
	0xf9b9,  0xf696,  0xf375,  0xf055,  0xed38,  0xea1e,  0xe708,  0xe3f5,
	0xe0e7,  0xdddd,  0xdad8,  0xd7da,  0xd4e1,  0xd1ef,  0xcf05,  0xcc22,
	0xc946,  0xc674,  0xc3aa,  0xc0e9,  0xbe32,  0xbb86,  0xb8e4,  0xb64c,
	0xb3c1,  0xb141,  0xaecd,  0xac65,  0xaa0b,  0xa7be,  0xa57e,  0xa34c,
	0xa129,  0x9f14,  0x9d0e,  0x9b18,  0x9931,  0x975a,  0x9593,  0x93dc,
	0x9236,  0x90a1,  0x8f1e,  0x8dab,  0x8c4b,  0x8afc,  0x89bf,  0x8894,
	0x877c,  0x8676,  0x8583,  0x84a3,  0x83d7,  0x831d,  0x8276,  0x81e3,
	0x8163,  0x80f7,  0x809e,  0x8059,  0x8028,  0x800a,  0x6488,  0x0080,
	0x03ff,  0x0116,  0x0002,  0x0080,  0x4000,  0x3fd7,  0x3faf,  0x3f86,
	0x3f5d,  0x3f34,  0x3f0c,  0x3ee3,  0x3eba,  0x3e91,  0x3e68,  0x3e40,
	0x3e17,  0x3dee,  0x3dc5,  0x3d9c,  0x3d74,  0x3d4b,  0x3d22,  0x3cf9,
	0x3cd0,  0x3ca7,  0x3c7f,  0x3c56,  0x3c2d,  0x3c04,  0x3bdb,  0x3bb2,
	0x3b89,  0x3b60,  0x3b37,  0x3b0e,  0x3ae5,  0x3abc,  0x3a93,  0x3a69,
	0x3a40,  0x3a17,  0x39ee,  0x39c5,  0x399c,  0x3972,  0x3949,  0x3920,
	0x38f6,  0x38cd,  0x38a4,  0x387a,  0x3851,  0x3827,  0x37fe,  0x37d4,
	0x37aa,  0x3781,  0x3757,  0x372d,  0x3704,  0x36da,  0x36b0,  0x3686,
	0x365c,  0x3632,  0x3609,  0x35df,  0x35b4,  0x358a,  0x3560,  0x3536,
	0x350c,  0x34e1,  0x34b7,  0x348d,  0x3462,  0x3438,  0x340d,  0x33e3,
	0x33b8,  0x338d,  0x3363,  0x3338,  0x330d,  0x32e2,  0x32b7,  0x328c,
	0x3261,  0x3236,  0x320b,  0x31df,  0x31b4,  0x3188,  0x315d,  0x3131,
	0x3106,  0x30da,  0x30ae,  0x3083,  0x3057,  0x302b,  0x2fff,  0x2fd2,
	0x2fa6,  0x2f7a,  0x2f4d,  0x2f21,  0x2ef4,  0x2ec8,  0x2e9b,  0x2e6e,
	0x2e41,  0x2e14,  0x2de7,  0x2dba,  0x2d8d,  0x2d60,  0x2d32,  0x2d05,
	0x2cd7,  0x2ca9,  0x2c7b,  0x2c4d,  0x2c1f,  0x2bf1,  0x2bc3,  0x2b94,
	0x2b66,  0x2b37,  0x2b09,  0x2ada,  0x2aab,  0x2a7c,  0x2a4c,  0x2a1d,
	0x29ed,  0x29be,  0x298e,  0x295e,  0x292e,  0x28fe,  0x28ce,  0x289d,
	0x286d,  0x283c,  0x280b,  0x27da,  0x27a9,  0x2777,  0x2746,  0x2714,
	0x26e2,  0x26b0,  0x267e,  0x264c,  0x2619,  0x25e7,  0x25b4,  0x2581,
	0x254d,  0x251a,  0x24e6,  0x24b2,  0x247e,  0x244a,  0x2415,  0x23e1,
	0x23ac,  0x2376,  0x2341,  0x230b,  0x22d6,  0x229f,  0x2269,  0x2232,
	0x21fc,  0x21c4,  0x218d,  0x2155,  0x211d,  0x20e5,  0x20ad,  0x2074,
	0x203b,  0x2001,  0x1fc7,  0x1f8d,  0x1f53,  0x1f18,  0x1edd,  0x1ea1,
	0x1e66,  0x1e29,  0x1ded,  0x1db0,  0x1d72,  0x1d35,  0x1cf6,  0x1cb8,
	0x1c79,  0x1c39,  0x1bf9,  0x1bb8,  0x1b77,  0x1b36,  0x1af4,  0x1ab1,
	0x1a6e,  0x1a2a,  0x19e6,  0x19a1,  0x195c,  0x1915,  0x18ce,  0x1887,
	0x183f,  0x17f5,  0x17ac,  0x1761,  0x1715,  0x16c9,  0x167c,  0x162e,
	0x15df,  0x158e,  0x153d,  0x14eb,  0x1497,  0x1442,  0x13ec,  0x1395,
	0x133c,  0x12e2,  0x1286,  0x1228,  0x11c9,  0x1167,  0x1104,  0x109e,
	0x1036,  0x0fcc,  0x0f5f,  0x0eef,  0x0e7b,  0x0e04,  0x0d89,  0x0d0a,
	0x0c86,  0x0bfd,  0x0b6d,  0x0ad6,  0x0a36,  0x098d,  0x08d7,  0x0811,
	0x0736,  0x063e,  0x0519,  0x039a,  0x0000,  0x7fff,  0x0100,  0x0080,
	0x021d,  0x00c8,  0x00ce,  0x0048,  0x0a26,  0x277a,  0x00ce,  0x6488,
	0x14ac,  0x0001,  0x00f9,  0x00fc,  0x00ff,  0x00fc,  0x00f9,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,
	0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff,  0xffff};
#endif

2FH - ROM Version

Input	byte(2FH) integer(Undefined)
Output	integer(Version)

short DSP1_Version()
{
	return DSP1_VERSION;
}

40H..FFH - Invalid Command

The Data Register contains the last byte transfered.