Previous

199869 Revisions

Next

r18916 Friday 9th November, 2012 at 14:54:18 UTC by Tafoid
Added IQ_132's recently updated pgmcrypt decryption routine and shuffled around pgm/027 decryption functions to a new file (machine\pgmcrypt.h).  From Haze/IQ_132. (nw) New games marked as GAME_NOT_WORKING ------------------------------------ Fearless Pinocchio  [letoram, Kevin Eshbach, Smitdogg, The Dumping Union]

[src/mame]	mame.lst
[src/mame/drivers]	igs_m027.c pgm.c
[src/mame/includes]	pgm.h
[src/mame/machine]	pgmcrypt.c pgmcrypt.h* pgmprot4.c pgmprot5.c

trunk/src/mame/mame.lst

r18915	r18916
9094	9094	gonefsh2      // (c) 200?
9095	9095	chessc2         // (c) 200?
9096	9096	haunthig      // (c) 200?
	9097	fearless      // (c) 2006
9097	9098
9098	9099	// IGS PGM System Games
9099	9100	pgm            // Base Unit

trunk/src/mame/machine/pgmcrypt.c

r18915	r18916
1		/* IGS PGM System Encryptions */
	1	/* IGS 027 Encryptions
2	2
	3	the IGS027 chips are typically used with encrypted ROMs.
	4
	5	Games with an External ARM Rom usually have that ROM encrypted
	6	otherwise (in the case of PGM) the 68k ROM ends up encrypted
	7	instead.  The encryption is controlled by a set of registers
	8	mapped to ARM space where the table and some additional values
	9	are uploaded.  We don't currently emulate this in realtime
	10	even for cases where the internal ROM is dumped.
	11
	12	*/
	13
	14
	15
3	16	#include "emu.h"
4		#include "includes/pgm.h"
	17	#include "pgmcrypt.h"
5	18
	19	// a common set of these are used, selectable in the real scheme by an uploaded bitfield
	20	// some may be duplicates simply due to differing rom sizes
6	21
	22	#define IGS27_CRYPT1 \
	23	if ((i & 0x040480) != 0x000080) x ^= 0x0001; \
	24
	25	#define IGS27_CRYPT1_ALT \
	26	if ((i & 0x040080) != 0x000080) x ^= 0x0001; \
	27
	28	#define IGS27_CRYPT1_ALT2 \
	29	if ((i & 0x0480) != 0x0080) x ^= 0x0001; \
	30
	31	#define IGS27_CRYPT2 \
	32	if ((i & 0x104008) == 0x104008) x ^= 0x0002; \
	33
	34	#define IGS27_CRYPT2_ALT \
	35	if ((i & 0x004008) == 0x004008) x ^= 0x0002; \
	36
	37	#define IGS27_CRYPT2_ALT2 \
	38	if((i & 0x004008) == 0x004008 && (i & 0x180000) != 0x000000) x ^= 0x0002; \
	39
	40	#define IGS27_CRYPT2_ALT3 \
	41	if((i & 0x84008) == 0x84008) x ^= 0x0002; \
	42
	43	#define IGS27_CRYPT3 \
	44	if ((i & 0x080030) == 0x080010) x ^= 0x0004; \
	45
	46	#define IGS27_CRYPT3_ALT \
	47	if((i & 0x000030) == 0x000010 && (i & 0x180000) != 0x080000) x ^= 0x0004; \
	48
	49	#define IGS27_CRYPT3_ALT2 \
	50	if ((i & 0x000030) == 0x000010) x ^= 0x0004; \
	51
	52	// ket - due to address starting at 0 and not 100000/2!
	53	#define IGS27_CRYPT3_ALT3 \
	54	if ((i & 0x080030) == 0x000010) x ^= 0x0004; \
	55
	56	#define IGS27_CRYPT4 \
	57	if ((i & 0x000242) != 0x000042) x ^= 0x0008; \
	58
	59	#define IGS27_CRYPT4_ALT \
	60	if ((i & 0x000042) != 0x000042) x ^= 0x0008; \
	61
	62	#define IGS27_CRYPT5 \
	63	if ((i & 0x008100) == 0x008000) x ^= 0x0010; \
	64
	65	#define IGS27_CRYPT5_ALT \
	66	if ((i & 0x48100) == 0x48000) x ^= 0x0010; \
	67
	68	#define IGS27_CRYPT6 \
	69	if ((i & 0x002004) != 0x000004) x ^= 0x0020; \
	70
	71	#define IGS27_CRYPT6_ALT \
	72	if ((i & 0x022004) != 0x000004) x ^= 0x0020; \
	73
	74	#define IGS27_CRYPT7 \
	75	if ((i & 0x011800) != 0x010000) x ^= 0x0040; \
	76
	77	#define IGS27_CRYPT7_ALT \
	78	if ((i & 0x01800) != 0x00000) x ^= 0x0040; \
	79
	80	#define IGS27_CRYPT8 \
	81	if ((i & 0x004820) == 0x004820) x ^= 0x0080; \
	82
	83	#define IGS27_CRYPT8_ALT \
	84	if ((i & 0x000820) == 0x000820) x ^= 0x0080; \
	85
	86
7	87	static const UINT8 kov_tab[256] = {
8	88	0x17, 0x1c, 0xe3, 0x02, 0x62, 0x59, 0x97, 0x4a, 0x67, 0x4d, 0x1f, 0x11, 0x76, 0x64, 0xc1, 0xe1,
9	89	0xd2, 0x41, 0x9f, 0xfd, 0xfa, 0x04, 0xfe, 0xab, 0x89, 0xeb, 0xc0, 0xf5, 0xac, 0x2b, 0x64, 0x22,
r18915	r18916
34	114	for(i=0; i<rom_size/2; i++) {
35	115	UINT16 x = src[i];
36	116
37		if((i & 0x040480) != 0x000080)
38		x ^= 0x0001;
	117	IGS27_CRYPT1
	118	IGS27_CRYPT2_ALT
	119	IGS27_CRYPT3_ALT
	120	IGS27_CRYPT4
	121	IGS27_CRYPT5
	122	IGS27_CRYPT6_ALT
	123	IGS27_CRYPT7
	124	IGS27_CRYPT8
39	125
40		if((i & 0x004008) == 0x004008)
41		x ^= 0x0002;
42
43		if((i & 0x000030) == 0x000010 && (i & 0x180000) != 0x080000)
44		x ^= 0x0004;
45
46		if((i & 0x000242) != 0x000042)
47		x ^= 0x0008;
48
49		if((i & 0x008100) == 0x008000)
50		x ^= 0x0010;
51
52		if((i & 0x022004) != 0x000004)
53		x ^= 0x0020;
54
55		if((i & 0x011800) != 0x010000)
56		x ^= 0x0040;
57
58		if((i & 0x004820) == 0x004820)
59		x ^= 0x0080;
60
61	126	x ^= kov_tab[i & 0xff] << 8;
62	127
63	128	src[i] = x;
r18915	r18916
96	161	for(i=0; i<rom_size/2; i++) {
97	162	UINT16 x = src[i];
98	163
99		if((i & 0x040080) != 0x000080)
100		x ^= 0x0001;
	164	IGS27_CRYPT1_ALT
	165	IGS27_CRYPT2_ALT2
	166	IGS27_CRYPT3_ALT2
	167	IGS27_CRYPT4
	168	IGS27_CRYPT5
	169	IGS27_CRYPT6
	170	IGS27_CRYPT7
	171	IGS27_CRYPT8_ALT
101	172
102		if((i & 0x004008) == 0x004008 && (i & 0x180000) != 0x000000)
103		x ^= 0x0002;
104
105		if((i & 0x000030) == 0x000010)
106		x ^= 0x0004;
107
108		if((i & 0x000242) != 0x000042)
109		x ^= 0x0008;
110
111		if((i & 0x008100) == 0x008000)
112		x ^= 0x0010;
113
114		if((i & 0x002004) != 0x000004)
115		x ^= 0x0020;
116
117		if((i & 0x011800) != 0x010000)
118		x ^= 0x0040;
119
120		if((i & 0x000820) == 0x000820)
121		x ^= 0x0080;
122
123	173	x ^= kovsh_tab[i & 0xff] << 8;
124	174
125	175	src[i] = x;
126	176	}
127	177	}
128	178
129		void pgm_dw2_decrypt(running_machine &machine)
130		{
131	179
132		int i;
133		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base()+0x100000);
134
135		int rom_size = 0x80000;
136
137		for(i=0; i<rom_size/2; i++) {
138		UINT16 x = src[i];
139
140		if(((i & 0x020890) == 0x000000)
141		|| ((i & 0x020000) == 0x020000 && (i & 0x001500) != 0x001400))
142		x ^= 0x0002;
143
144		if(((i & 0x020400) == 0x000000 && (i & 0x002010) != 0x002010)
145		|| ((i & 0x020000) == 0x020000 && (i & 0x000148) != 0x000140))
146		x ^= 0x0400;
147
148		src[i] = x;
149		}
150		}
151
152	180	static const UINT8 photoy2k_tab[256] = {
153	181	0xd9, 0x92, 0xb2, 0xbc, 0xa5, 0x88, 0xe3, 0x48, 0x7d, 0xeb, 0xc5, 0x4d, 0x31, 0xe4, 0x82, 0xbc,
154	182	0x82, 0xcf, 0xe7, 0xf3, 0x15, 0xde, 0x8f, 0x91, 0xef, 0xc6, 0xb8, 0x81, 0x97, 0xe3, 0xdf, 0x4d,
r18915	r18916
179	207	for(i=0; i<rom_size/2; i++) {
180	208	UINT16 x = src[i];
181	209
182		if((i & 0x40080) != 0x00080)
183		x ^= 0x0001;
	210	IGS27_CRYPT1_ALT
	211	IGS27_CRYPT2_ALT3
	212	IGS27_CRYPT3_ALT2
	213	IGS27_CRYPT4
	214	IGS27_CRYPT5_ALT
	215	IGS27_CRYPT6
	216	IGS27_CRYPT7_ALT
	217	IGS27_CRYPT8
184	218
185		if((i & 0x84008) == 0x84008)
186		x ^= 0x0002;
187
188		if((i & 0x00030) == 0x00010)
189		x ^= 0x0004;
190
191		if((i & 0x00242) != 0x00042)
192		x ^= 0x0008;
193
194		if((i & 0x48100) == 0x48000)
195		x ^= 0x0010;
196
197		if((i & 0x02004) != 0x00004)
198		x ^= 0x0020;
199
200		if((i & 0x01800) != 0x00000)
201		x ^= 0x0040;
202
203		if((i & 0x04820) == 0x04820)
204		x ^= 0x0080;
205
206	219	x ^= photoy2k_tab[i & 0xff] << 8;
207	220
208	221	src[i] = x;
r18915	r18916
239	252	for(i=0; i<rom_size/2; i++) {
240	253	UINT16 x = src[i];
241	254
242		if((i & 0x40480) != 0x00080)
243		x ^= 0x0100;
	255	IGS27_CRYPT1
	256	IGS27_CRYPT3_ALT2
	257	IGS27_CRYPT4
	258	IGS27_CRYPT5
	259	IGS27_CRYPT6_ALT
	260	IGS27_CRYPT7
	261	IGS27_CRYPT8
244	262
245		if((i & 0x00030) == 0x00010)
246		x ^= 0x0400;
247
248		if((i & 0x00242) != 0x00042)
249		x ^= 0x0800;
250
251		if((i & 0x08100) == 0x08000)
252		x ^= 0x1000;
253
254		if((i & 0x22004) != 0x00004)
255		x ^= 0x2000;
256
257		if((i & 0x11800) != 0x10000)
258		x ^= 0x4000;
259
260		if((i & 0x04820) == 0x04820)
261		x ^= 0x8000;
262
263		x = x ^ pstar[i & 255];
264		src[i] = (x<<8)|(x>>8) ;
	263	x = x ^ pstar[(i & 255)] << 8;
	264	src[i] = x ;
265	265	}
266	266	}
267	267
268		void pgm_dw3_decrypt(running_machine &machine)
269		{
270
271		//  int i;
272		//  UINT16 *src=(UINT16 *) (OP_ROM+0x100000);
273
274		int i;
275		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base()+0x100000);
276
277		int rom_size = 0x100000;
278
279		for(i=0; i<rom_size/2; i++) {
280		UINT16 x = src[i];
281
282		if((i & 0x005460) == 0x001400)
283		x ^= 0x0100;
284
285		if((i & 0x005450) == 0x001040)
286		x ^= 0x0100;
287
288		if((i & 0x005e00) == 0x001c00)
289		x ^= 0x40;
290
291		if((i & 0x005580) == 0x001100)
292		x ^= 0x40;
293
294
295
296		src[i] = x;
297		}
298		}
299
300		void pgm_killbld_decrypt(running_machine &machine)
301		{
302
303		//  int i;
304		//  UINT16 *src=(UINT16 *) (OP_ROM+0x100000);
305
306		int i;
307		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base()+0x100000);
308
309		int rom_size = 0x200000;
310
311		for(i=0; i<rom_size/2; i++) {
312		UINT16 x = src[i];
313
314		if((i & 0x6d00) == 0x0400 || (i & 0x6c80) == 0x0880)
315		x ^= 0x0008;
316		if((i & 0x7500) == 0x2400 || (i & 0x7600) == 0x3200)
317		x ^= 0x1000;
318
319		src[i] = x;
320		}
321		}
322
323
324	268	static const UINT8 dfront_tab[256] = {
325	269	0x51, 0xc4, 0xe3, 0x10, 0x1c, 0xad, 0x8a, 0x39, 0x8c, 0xe0, 0xa5, 0x04, 0x0f, 0xe4, 0x35, 0xc3,
326	270	0x2d, 0x6b, 0x32, 0xe2, 0x60, 0x54, 0x63, 0x06, 0xa3, 0xf1, 0x0b, 0x5f, 0x6c, 0x5c, 0xb3, 0xec,
r18915	r18916
350	294	for(i=0; i<rom_size/2; i++) {
351	295	UINT16 x = src[i];
352	296
353		if((i & 0x040080) != 0x000080)
354		x ^= 0x0001;
	297	IGS27_CRYPT1_ALT
	298	IGS27_CRYPT2
	299	IGS27_CRYPT3
	300	IGS27_CRYPT4_ALT
	301	IGS27_CRYPT5
	302	IGS27_CRYPT6
	303	IGS27_CRYPT7
	304	IGS27_CRYPT8
355	305
356		if((i & 0x104008) == 0x104008)
357		x ^= 0x0002;
358
359		if((i & 0x080030) == 0x080010)
360		x ^= 0x0004;
361
362		if((i & 0x000042) != 0x000042)
363		x ^= 0x0008;
364
365		if((i & 0x008100) == 0x008000)
366		x ^= 0x0010;
367
368		if((i & 0x002004) != 0x000004)
369		x ^= 0x0020;
370
371		if((i & 0x011800) != 0x010000)
372		x ^= 0x0040;
373
374		if((i & 0x004820) == 0x004820)
375		x ^= 0x0080;
376
377	306	x ^= dfront_tab[(i>> 1) & 0xff] << 8;
378	307
379	308	src[i] = x;
r18915	r18916
410	339	for(i=0; i<rom_size/2; i++) {
411	340	UINT16 x = src[i];
412	341
413		if((i & 0x0480) != 0x0080)
414		x ^= 0x0001;
	342	IGS27_CRYPT1_ALT2
	343	// NO CRYPT2
	344	// NO CRYPT3
	345	IGS27_CRYPT4_ALT
	346	IGS27_CRYPT5
	347	IGS27_CRYPT6
	348	IGS27_CRYPT7_ALT
	349	IGS27_CRYPT8_ALT
415	350
416		if((i & 0x0042) != 0x0042)
417		x ^= 0x0008;
418
419		if((i & 0x8100) == 0x8000)
420		x ^= 0x0010;
421
422		if((i & 0x2004) != 0x0004)
423		x ^= 0x0020;
424
425		if((i & 0x1800) != 0x0000)
426		x ^= 0x0040;
427
428		if((i & 0x0820) == 0x0820)
429		x ^= 0x0080;
430
431	351	x ^= ddp2_tab[(i>> 1) & 0xff] << 8;
432	352
433	353	src[i] = x;
r18915	r18916
464	384	for(i=0; i<rom_size/2; i++) {
465	385	UINT16 x = src[i];
466	386
467		if((i & 0x040480) != 0x000080)
468		x ^= 0x0001;
	387	IGS27_CRYPT1
	388	IGS27_CRYPT2_ALT
	389	IGS27_CRYPT3_ALT2
	390	IGS27_CRYPT4
	391	IGS27_CRYPT5
	392	IGS27_CRYPT6_ALT
	393	IGS27_CRYPT7
	394	IGS27_CRYPT8_ALT
469	395
470		if((i & 0x004008) == 0x004008)
471		x ^= 0x0002;
472
473		if((i & 0x000030) == 0x000010)
474		x ^= 0x0004;
475
476		if((i & 0x000242) != 0x000042)
477		x ^= 0x0008;
478
479		if((i & 0x008100) == 0x008000)
480		x ^= 0x0010;
481
482		if((i & 0x022004) != 0x000004)
483		x ^= 0x0020;
484
485		if((i & 0x011800) != 0x010000)
486		x ^= 0x0040;
487
488		if((i & 0x000820) == 0x000820)
489		x ^= 0x0080;
490
491	396	x ^= mm_tab[(i>> 1) & 0xff] << 8;
492	397
493	398	src[i] = x;
r18915	r18916
523	428	for(i=0; i<rom_size/2; i++) {
524	429	UINT16 x = src[i];
525	430
526		if((i & 0x40080) != 0x00080)
527		x ^= 0x0001;
	431	IGS27_CRYPT1_ALT
	432	// NO CRYPT2
	433	IGS27_CRYPT3
	434	IGS27_CRYPT4_ALT
	435	IGS27_CRYPT5_ALT
	436	IGS27_CRYPT6_ALT
	437	IGS27_CRYPT7_ALT
	438	IGS27_CRYPT8_ALT
528	439
529		if((i & 0x80030) == 0x80010)
530		x ^= 0x0004;
531
532		if((i & 0x00042) != 0x00042)
533		x ^= 0x0008;
534
535		if((i & 0x48100) == 0x48000)
536		x ^= 0x0010;
537
538		if((i & 0x22004) != 0x00004)
539		x ^= 0x0020;
540
541		if((i & 0x01800) != 0x00000)
542		x ^= 0x0040;
543
544		if((i & 0x00820) == 0x00820)
545		x ^= 0x0080;
546
547	440	x ^= kov2_tab[(i >> 1) & 0xff] << 8;
548	441
549	442	src[i] = x;
r18915	r18916
579	472	for(i=0; i<rom_size/2; i++) {
580	473	UINT16 x = src[i];
581	474
582		if((i & 0x40080) != 0x00080)
583		x ^= 0x0001;
	475	IGS27_CRYPT1_ALT
	476	IGS27_CRYPT2_ALT
	477	IGS27_CRYPT3
	478	IGS27_CRYPT4
	479	IGS27_CRYPT5
	480	IGS27_CRYPT6
	481	IGS27_CRYPT7
	482	IGS27_CRYPT8_ALT
584	483
585		if((i & 0x04008) == 0x04008)
586		x ^= 0x0002;
587
588		if((i & 0x80030) == 0x80010)
589		x ^= 0x0004;
590
591		if((i & 0x00242) != 0x00042)
592		x ^= 0x0008;
593
594		if((i & 0x08100) == 0x08000)
595		x ^= 0x0010;
596
597		if((i & 0x02004) != 0x00004)
598		x ^= 0x0020;
599
600		if((i & 0x11800) != 0x10000)
601		x ^= 0x0040;
602
603		if((i & 0x00820) == 0x00820)
604		x ^= 0x0080;
605
606	484	x ^= kov2p_tab[(i >> 1) & 0xff] << 8;
607	485
608	486	src[i] = x;
r18915	r18916
638	516	for(i=0; i<rom_size/2; i++) {
639	517	UINT16 x = src[i];
640	518
641		if((i & 0x040080) != 0x000080)
642		x ^= 0x0100;
	519	IGS27_CRYPT1_ALT
	520	IGS27_CRYPT2_ALT
	521	IGS27_CRYPT3_ALT2
	522	IGS27_CRYPT4
	523	IGS27_CRYPT5
	524	IGS27_CRYPT6_ALT
	525	IGS27_CRYPT7
	526	IGS27_CRYPT8
643	527
644		if((i & 0x004008) == 0x004008)
645		x ^= 0x0200;
646
647		if((i & 0x000030) == 0x000010)
648		x ^= 0x0400;
649
650		if((i & 0x000242) != 0x000042)
651		x ^= 0x0800;
652
653		if((i & 0x008100) == 0x008000)
654		x ^= 0x1000;
655
656		if((i & 0x022004) != 0x000004)
657		x ^= 0x2000;
658
659		if((i & 0x011800) != 0x010000)
660		x ^= 0x4000;
661
662		if((i & 0x004820) == 0x004820)
663		x ^= 0x8000;
664
665		x ^= puzzli2_tab[i & 0xff];
666		src[i] = (x<<8)|(x>>8) ;
	528	x ^= puzzli2_tab[i & 0xff] << 8;
	529	src[i] = x;
667	530	}
668	531	}
669	532
r18915	r18916
697	560	for(i=0; i<rom_size/2; i++) {
698	561	UINT16 x = src[i];
699	562
700		if((i & 0x40080) != 0x00080)
701		x ^= 0x0001;
	563	IGS27_CRYPT1_ALT
	564	IGS27_CRYPT2
	565	IGS27_CRYPT3
	566	IGS27_CRYPT4_ALT
	567	IGS27_CRYPT5
	568	IGS27_CRYPT6_ALT
	569	IGS27_CRYPT7
	570	IGS27_CRYPT8_ALT
702	571
703		if((i & 0x104008) == 0x104008)
704		x ^= 0x0002;
705
706		if((i & 0x80030) == 0x80010)
707		x ^= 0x0004;
708
709		if((i & 0x000042) != 0x000042)
710		x ^= 0x0008;
711
712		if((i & 0x08100) == 0x08000)
713		x ^= 0x0010;
714
715		if((i & 0x022004) != 0x000004)
716		x ^= 0x0020;
717
718		if((i & 0x11800) != 0x10000)
719		x ^= 0x0040;
720
721		if((i & 0x00820) == 0x00820)
722		x ^= 0x0080;
723
724	572	x ^= theglad_tab[(i >> 1) & 0xff] << 8;
725	573
726	574	src[i] = x;
r18915	r18916
757	605	for(i=0; i<rom_size/2; i++) {
758	606	unsigned short x = src[i];
759	607
760		if((i & 0x040480) != 0x000080 )
761		x ^= 0x0001;
	608	IGS27_CRYPT1
	609	IGS27_CRYPT2_ALT
	610	IGS27_CRYPT3_ALT2
	611	IGS27_CRYPT4
	612	IGS27_CRYPT5_ALT
	613	IGS27_CRYPT6
	614	IGS27_CRYPT7
	615	IGS27_CRYPT8_ALT
762	616
763		if((i & 0x004008) == 0x004008 )
764		x ^= 0x0002;
765
766		if((i & 0x000030) == 0x000010 )
767		x ^= 0x0004;
768
769		if((i & 0x000242) != 0x000042 )
770		x ^= 0x0008;
771
772		if((i & 0x048100) == 0x048000 )
773		x ^= 0x0010;
774
775		if((i & 0x002004) != 0x000004 )
776		x ^= 0x0020;
777
778		if((i & 0x011800) != 0x010000 )
779		x ^= 0x0040;
780
781		if((i & 0x000820) == 0x000820 )
782		x ^= 0x0080;
783
784	617	x ^= oldsplus_tab[i & 0xff] << 8;
785	618
786	619	src[i] = x;
r18915	r18916
817	650	for(i=0; i<rom_size/2; i++) {
818	651	unsigned short x = src[i];
819	652
820		if((i & 0x040080) != 0x000080)
821		x ^= 0x0001;
	653	IGS27_CRYPT1_ALT
	654	IGS27_CRYPT2_ALT2
	655	IGS27_CRYPT3_ALT2
	656	IGS27_CRYPT4_ALT
	657	IGS27_CRYPT5
	658	IGS27_CRYPT6_ALT
	659	IGS27_CRYPT7
	660	IGS27_CRYPT8_ALT
822	661
823		if((i & 0x004008) == 0x004008 && (i & 0x180000) != 0x000000)
824		x ^= 0x0002;
825
826		if((i & 0x000030) == 0x000010)
827		x ^= 0x0004;
828
829		if((i & 0x000042) != 0x000042)
830		x ^= 0x0008;
831
832		if((i & 0x008100) == 0x008000)
833		x ^= 0x0010;
834
835		if((i & 0x022004) != 0x000004)
836		x ^= 0x0020;
837
838		if((i & 0x011800) != 0x010000)
839		x ^= 0x0040;
840
841		if((i & 0x000820) == 0x000820)
842		x ^= 0x0080;
843
844	662	x ^= kovshp_tab[i & 0xff] << 8;
845	663
846	664	src[i] = x;
r18915	r18916
877	695	for(i=0; i<rom_size/2; i++) {
878	696	UINT16 x = src[i];
879	697
880		if((i & 0x040480) != 0x000080)
881		x ^= 0x0001;
	698	IGS27_CRYPT1
	699	IGS27_CRYPT2
	700	IGS27_CRYPT3
	701	IGS27_CRYPT4
	702	IGS27_CRYPT5
	703	IGS27_CRYPT6
	704	IGS27_CRYPT7
	705	IGS27_CRYPT8_ALT
882	706
883		if((i & 0x104008) == 0x104008)
884		x ^= 0x0002;
885
886		if((i & 0x080030) == 0x080010)
887		x ^= 0x0004;
888
889		if((i & 0x000242) != 0x000042)
890		x ^= 0x0008;
891
892		if((i & 0x008100) == 0x008000)
893		x ^= 0x0010;
894
895		if((i & 0x002004) != 0x000004)
896		x ^= 0x0020;
897
898		if((i & 0x011800) != 0x010000)
899		x ^= 0x0040;
900
901		if((i & 0x000820) == 0x000820)
902		x ^= 0x0080;
903
904	707	x ^= killbldp_tab[(i >> 1) & 0xff] << 8;
905	708
906	709	src[i] = x;
r18915	r18916
918	721	for(i=0; i<rom_size/2; i++) {
919	722	UINT16 x = src[i];
920	723
921		if((i & 0x040080) != 0x000080)
922		x ^= 0x0001;
	724	IGS27_CRYPT1_ALT
	725	IGS27_CRYPT2_ALT
	726	IGS27_CRYPT3
	727	IGS27_CRYPT4_ALT
	728	IGS27_CRYPT5_ALT
	729	IGS27_CRYPT6
	730	IGS27_CRYPT7
	731	IGS27_CRYPT8_ALT
923	732
924		if((i & 0x004008) == 0x004008)
925		x ^= 0x0002;
926
927		if((i & 0x080030) == 0x080010)
928		x ^= 0x0004;
929
930		if((i & 0x000042) != 0x000042)
931		x ^= 0x0008;
932
933		if((i & 0x048100) == 0x048000)
934		x ^= 0x0010;
935
936		if((i & 0x002004) != 0x000004)
937		x ^= 0x0020;
938
939		if((i & 0x011800) != 0x010000)
940		x ^= 0x0040;
941
942		if((i & 0x000820) == 0x000820)
943		x ^= 0x0080;
944
945	733	src[i] = x;
946	734	}
947	735	}
r18915	r18916
976	764	UINT16 x = src[i];
977	765
978	766	// preliminary!
979		if ((i & 0x040080) != 0x000080) x ^= 0x0001; // ok?
980		if ((i & 0x084008) == 0x084008) x ^= 0x0002;
981		if ((i & 0x080030) == 0x080010) x ^= 0x0004;
982		if ((i & 0x000242) != 0x000042) x ^= 0x0008; // ok?
983		if ((i & 0x048100) == 0x048000) x ^= 0x0010; //
984		if ((i & 0x022004) != 0x000004) x ^= 0x0020; // ok?
985		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
986		if ((i & 0x000820) == 0x000820) x ^= 0x0080;
	767	IGS27_CRYPT1_ALT; // ok?
	768	IGS27_CRYPT2_ALT3
	769	IGS27_CRYPT3
	770	IGS27_CRYPT4 // ok?
	771	IGS27_CRYPT5_ALT  //
	772	IGS27_CRYPT6_ALT // ok?
	773	IGS27_CRYPT7
	774	IGS27_CRYPT8_ALT
987	775
988	776	x ^= svgpcb_tab[(i >> 1) & 0xff] << 8;
989	777
r18915	r18916
1022	810	{
1023	811	UINT16 x = src[i];
1024	812
1025		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
1026		if ((i & 0x084008) == 0x084008) x ^= 0x0002;
1027		if ((i & 0x000030) == 0x000010 && (i & 0x180000) != 0x080000) x ^= 0x0004;
1028		if ((i & 0x000042) != 0x000042) x ^= 0x0008;
1029		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
1030		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
1031		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1032		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
	813	IGS27_CRYPT1
	814	IGS27_CRYPT2_ALT3
	815	IGS27_CRYPT3_ALT
	816	IGS27_CRYPT4_ALT
	817	IGS27_CRYPT5
	818	IGS27_CRYPT6_ALT
	819	IGS27_CRYPT7
	820	IGS27_CRYPT8
1033	821
1034	822	x ^= py2k2_tab[i & 0xff] << 8;
1035	823
r18915	r18916
1068	856	{
1069	857	UINT16 x = src[i];
1070	858
1071		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
1072		if ((i & 0x004008) == 0x004008) x ^= 0x0002;
1073		if ((i & 0x080030) == 0x000010) x ^= 0x0004; // due to address starting at 0 and not 100000/2!
1074		if ((i & 0x000042) != 0x000042) x ^= 0x0008;
1075		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
1076		if ((i & 0x002004) != 0x000004) x ^= 0x0020;
1077		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1078		if ((i & 0x000820) == 0x000820) x ^= 0x0080;
	859	IGS27_CRYPT1
	860	IGS27_CRYPT2_ALT
	861	IGS27_CRYPT3_ALT3
	862	IGS27_CRYPT4_ALT
	863	IGS27_CRYPT5
	864	IGS27_CRYPT6
	865	IGS27_CRYPT7
	866	IGS27_CRYPT8_ALT
1079	867
1080	868
1081	869	x ^= ket_tab[i & 0xff] << 8;
r18915	r18916
1114	902	{
1115	903	UINT16 x = src[i];
1116	904
1117		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
1118		if ((i & 0x084008) == 0x084008) x ^= 0x0002; // correct?
1119		if ((i & 0x000030) == 0x000010) x ^= 0x0004;
1120		if ((i & 0x000042) != 0x000042) x ^= 0x0008;
1121		if ((i & 0x048100) == 0x048000) x ^= 0x0010;
1122		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
1123		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1124		if ((i & 0x000820) == 0x000820) x ^= 0x0080;
	905	IGS27_CRYPT1
	906	IGS27_CRYPT2_ALT3
	907	IGS27_CRYPT3_ALT2
	908	IGS27_CRYPT4_ALT
	909	IGS27_CRYPT5_ALT
	910	IGS27_CRYPT6_ALT
	911	IGS27_CRYPT7
	912	IGS27_CRYPT8_ALT
1125	913
1126	914	x ^= espgal_tab[i & 0xff] << 8;
1127	915
r18915	r18916
1161	949	{
1162	950	UINT16 x = src[i];
1163	951
1164		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
1165		if ((i & 0x104008) == 0x104008) x ^= 0x0002;
1166		if ((i & 0x080030) == 0x080010) x ^= 0x0004;
1167		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
1168		if ((i & 0x048100) == 0x048000) x ^= 0x0010;
1169		if ((i & 0x002004) != 0x000004) x ^= 0x0020;
1170		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1171		if ((i & 0x000820) == 0x000820) x ^= 0x0080;
	952	IGS27_CRYPT1
	953	IGS27_CRYPT2
	954	IGS27_CRYPT3
	955	IGS27_CRYPT4
	956	IGS27_CRYPT5_ALT
	957	IGS27_CRYPT6
	958	IGS27_CRYPT7
	959	IGS27_CRYPT8_ALT
1172	960
1173	961	x ^= happy6in1_tab[(i >> 1) & 0xff] << 8;
1174	962
1175	963	src[i] = x;
1176	964	}
1177	965	}
	966
	967	static const UINT8 sdwx_tab[] =
	968	{
	969	0x49,0x47,0x53,0x30,0x30,0x35,0x35,0x52,0x44,0x34,0x30,0x32,0x30,0x36,0x32,0x31,
	970	0x8A,0xBB,0x20,0x67,0x97,0xA5,0x20,0x45,0x6B,0xC0,0xE8,0x0C,0x80,0xFB,0x49,0xAA,
	971	0x1E,0xAC,0x29,0xF2,0xB9,0x9F,0x01,0x4A,0x8D,0x5F,0x95,0x96,0x78,0xC3,0xF6,0x65,
	972	0x17,0xBD,0xB6,0x5B,0x25,0x5F,0x6B,0xDE,0x10,0x2E,0x67,0x05,0xDC,0xAC,0xB6,0xBD,
	973	0x3D,0x20,0x58,0x3D,0xF0,0xA8,0xC0,0xAD,0x5B,0x82,0x8D,0x12,0x65,0x97,0x87,0x7D,
	974	0x97,0x49,0xDD,0x74,0x74,0x7E,0x9D,0xA1,0x15,0xED,0x75,0xB9,0x09,0xA8,0xA8,0xB0,
	975	0x6B,0xEA,0x54,0x1B,0x45,0x23,0xE2,0xE5,0x25,0x42,0xCE,0x36,0xFE,0x42,0x99,0xA0,
	976	0x41,0xF8,0x0B,0x8C,0x3C,0x1B,0xAE,0xE4,0xB2,0x94,0x87,0x02,0xBC,0x08,0x17,0xD9,
	977	0xE0,0xA4,0x93,0x63,0x6F,0x28,0x5F,0x4A,0x24,0x36,0xD1,0xDA,0xFA,0xDD,0x23,0x26,
	978	0x4E,0x61,0xB9,0x7A,0x36,0x4D,0x95,0x01,0x20,0xBC,0x18,0xB7,0xAF,0xE4,0xFB,0x92,
	979	0xD2,0xE3,0x8E,0xEC,0x26,0xCE,0x2F,0x34,0x8F,0xF7,0x0D,0xD6,0x11,0x7F,0x1F,0x68,
	980	0xF4,0x1D,0x5F,0x16,0x19,0x2D,0x4C,0x4F,0x96,0xFC,0x9F,0xB0,0x99,0x53,0x4C,0x32,
	981	0x7B,0x41,0xBC,0x90,0x23,0x2E,0x4A,0xFC,0x9E,0x1D,0xFC,0x02,0xFC,0x41,0x83,0xBC,
	982	0x6D,0xC4,0x75,0x37,0x9D,0xD3,0xC9,0x26,0x4D,0xED,0x93,0xC6,0x32,0x6D,0x02,0x11,
	983	0x12,0x56,0x97,0x26,0x1D,0x5F,0xA7,0xF8,0x89,0x3F,0x14,0x36,0x72,0x3B,0x48,0x7B,
	984	0xF1,0xED,0x72,0xB7,0x7A,0x56,0x05,0xDE,0x7B,0x27,0x6D,0xCF,0x33,0x4C,0x14,0x86,
	985	};
	986
	987
	988	void sdwx_decrypt(running_machine &machine)
	989	{
	990
	991	int i;
	992	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	993
	994	int rom_size = 0x80000;
	995
	996	for(i=0; i<rom_size/2; i++)
	997	{
	998	UINT16 x = src[i];
	999
	1000	IGS27_CRYPT1_ALT2
	1001	IGS27_CRYPT2_ALT
	1002	IGS27_CRYPT3_ALT2
	1003	IGS27_CRYPT4
	1004	IGS27_CRYPT5
	1005	IGS27_CRYPT6_ALT
	1006	IGS27_CRYPT7
	1007	IGS27_CRYPT8
	1008
	1009	x ^= sdwx_tab[(i >> 1) & 0xff] << 8;
	1010
	1011	src[i] = x;
	1012	}
	1013	}
	1014
	1015
	1016	static const UINT8 hauntedh_tab[0x100] = {
	1017	0x49, 0x47, 0x53, 0x30, 0x32, 0x35, 0x34, 0x52, 0x44, 0x34, 0x30, 0x36, 0x30, 0x35, 0x32, 0x36,
	1018	0x6C, 0x65, 0x33, 0xFD, 0x7A, 0x71, 0x3D, 0xB8, 0x07, 0xF1, 0x86, 0x96, 0x19, 0x5A, 0xA2, 0x05,
	1019	0x49, 0xB1, 0xED, 0x2E, 0x7C, 0x7A, 0x65, 0x8B, 0xE1, 0xE3, 0xC8, 0xAA, 0x2B, 0x32, 0xEE, 0x3F,
	1020	0x10, 0x6C, 0x69, 0x70, 0x02, 0x47, 0x5B, 0x5D, 0x2D, 0x52, 0x97, 0xEF, 0xB1, 0x63, 0xFB, 0xE3,
	1021	0x21, 0x41, 0x0C, 0x17, 0x3C, 0x93, 0xD4, 0x13, 0xEB, 0x08, 0xF9, 0xDB, 0x7A, 0xC8, 0x1E, 0xF4,
	1022	0x1B, 0x1B, 0x7F, 0xB4, 0x98, 0x59, 0xC8, 0xCF, 0x58, 0x12, 0x36, 0x1F, 0x96, 0x7D, 0xF0, 0xB3,
	1023	0xDC, 0x26, 0xA8, 0x1C, 0xC6, 0xD4, 0x6E, 0xF3, 0xF5, 0xB9, 0xD4, 0xAF, 0x52, 0xDD, 0x48, 0xA5,
	1024	0x85, 0xCC, 0xAD, 0x60, 0xB4, 0x7F, 0x3C, 0x24, 0x80, 0x88, 0x9B, 0xBD, 0x3E, 0x82, 0x3B, 0x8D,
	1025	0x73, 0xB8, 0xF7, 0xD5, 0x92, 0x15, 0xeb, 0x43, 0xF9, 0x4C, 0x91, 0xBD, 0x29, 0x48, 0x22, 0x6D,
	1026	0x45, 0xD6, 0x2C, 0x0D, 0xCE, 0x91, 0x70, 0x74, 0x9D, 0x0E, 0xFE, 0x62, 0x22, 0x49, 0x94, 0x88,
	1027	0xDB, 0x50, 0x33, 0xDB, 0x18, 0x2E, 0x03, 0x1B, 0xED, 0x1A, 0x69, 0x9E, 0x78, 0xE1, 0x66, 0x62,
	1028	0x54, 0x91, 0x33, 0x52, 0x5E, 0x67, 0x1B, 0xD9, 0xA7, 0xFB, 0x98, 0xA5, 0xBA, 0xAA, 0xB1, 0xBD,
	1029	0x0F, 0x44, 0x93, 0xC6, 0xCF, 0xF7, 0x6F, 0x91, 0xCA, 0x7B, 0x93, 0xEA, 0xB6, 0x7F, 0xCC, 0x9C,
	1030	0xAB, 0x54, 0xFB, 0xC8, 0xDB, 0xD9, 0xF5, 0x68, 0x96, 0xA7, 0xA1, 0x1F, 0x7D, 0x7D, 0x4C, 0x43,
	1031	0x06, 0xED, 0x50, 0x2D, 0x30, 0x48, 0xE6, 0xC0, 0x88, 0xC8, 0x48, 0x38, 0x5D, 0xFC, 0x0a, 0x35,
	1032	0x3F, 0x79, 0xBA, 0x07, 0xBE, 0xBF, 0xB7, 0x3B, 0x61, 0x69, 0x4F, 0x67, 0xE5, 0x9A, 0x1D, 0x33
	1033	};
	1034
	1035	void hauntedh_decrypt(running_machine &machine)
	1036	{
	1037	int i;
	1038	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1039
	1040	int rom_size = 0x080000;
	1041
	1042	for(i=0; i<rom_size/2; i++) {
	1043	UINT16 x = src[i];
	1044
	1045	IGS27_CRYPT1
	1046	//  IGS27_CRYPT2
	1047	//  IGS27_CRYPT3
	1048	IGS27_CRYPT4_ALT
	1049	//  IGS27_CRYPT5
	1050	IGS27_CRYPT6
	1051	IGS27_CRYPT7_ALT
	1052	IGS27_CRYPT8
	1053
	1054	x ^= hauntedh_tab[(i>> 1) & 0xff] << 8;
	1055
	1056	src[i] = x;
	1057	}
	1058	}
	1059
	1060
	1061	static const UINT8 chessc2_tab[0x100] = {
	1062	0x49, 0x47, 0x53, 0x30, 0x30, 0x38, 0x32, 0x52, 0x44, 0x34, 0x30, 0x32, 0x31, 0x32, 0x31, 0x31,
	1063	0x28, 0xCA, 0x9C, 0xAD, 0xBB, 0x2D, 0xF0, 0x41, 0x6E, 0xCE, 0xAD, 0x73, 0xAE, 0x1C, 0xD1, 0x14,
	1064	0x6F, 0x9A, 0x75, 0x18, 0xA8, 0x91, 0x68, 0xe4, 0x09, 0xF4, 0x0F, 0xD7, 0xFF, 0x93, 0x7D, 0x1B,
	1065	0xEB, 0x84, 0xce, 0xAD, 0x9E, 0xCF, 0xC9, 0xAB, 0x18, 0x59, 0xb6, 0xde, 0x82, 0x13, 0x7C, 0x88,
	1066	0x69, 0x63, 0xFF, 0x6F, 0x3C, 0xD2, 0xB9, 0x29, 0x09, 0xF8, 0x97, 0xAA, 0x74, 0xA5, 0x16, 0x0D,
	1067	0xF9, 0x51, 0x9E, 0x9f, 0x63, 0xC6, 0x1E, 0x32, 0x8C, 0x0C, 0xE9, 0xA0, 0x56, 0x95, 0xD1, 0x9D,
	1068	0xEA, 0xA9, 0x82, 0xC3, 0x30, 0x15, 0x21, 0xD8, 0x8F, 0x10, 0x25, 0x61, 0xE6, 0x6D, 0x75, 0x6D,
	1069	0xCB, 0x08, 0xC3, 0x9B, 0x03, 0x6A, 0x28, 0x6D, 0x42, 0xBF, 0x00, 0xd2, 0x24, 0xFA, 0x08, 0xEE,
	1070	0x6B, 0x46, 0xB7, 0x2C, 0x7B, 0xB0, 0xDA, 0x86, 0x13, 0x14, 0x73, 0x14, 0x4D, 0x45, 0xD3, 0xD4,
	1071	0xD9, 0x80, 0xF5, 0xB8, 0x76, 0x13, 0x1E, 0xF6, 0xB1, 0x4A, 0xB3, 0x8B, 0xE2, 0x9A, 0x5A, 0x11,
	1072	0x64, 0x11, 0x55, 0xC3, 0x14, 0xFD, 0x1B, 0xCe, 0x0C, 0xDC, 0x38, 0xDA, 0xA1, 0x84, 0x66, 0xD9,
	1073	0x9b, 0x93, 0xED, 0x0F, 0xB4, 0x19, 0x38, 0x62, 0x53, 0x85, 0xB9, 0xE5, 0x89, 0xCd, 0xFE, 0x9E,
	1074	0x4D, 0xE2, 0x14, 0x9F, 0xF4, 0x53, 0x1C, 0x46, 0xf4, 0x40, 0x2C, 0xCC, 0xDa, 0x82, 0x69, 0x15,
	1075	0x88, 0x18, 0x62, 0xB7, 0xB4, 0xD5, 0xAF, 0x4B, 0x9E, 0x48, 0xCA, 0xF4, 0x11, 0xEC, 0x2D, 0x2C,
	1076	0x9D, 0x91, 0xAD, 0xDA, 0x13, 0x0A, 0x16, 0x86, 0x41, 0x18, 0x08, 0x01, 0xef, 0x97, 0x11, 0x1f,
	1077	0x1A, 0xE7, 0x0C, 0xC9, 0x6D, 0x9D, 0xB9, 0x49, 0x0B, 0x6B, 0x9E, 0xD4, 0x72, 0x4D, 0x1D, 0x59
	1078	};
	1079
	1080	void chessc2_decrypt(running_machine &machine)
	1081	{
	1082	int i;
	1083	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1084
	1085	int rom_size = 0x80000;
	1086
	1087	for(i=0; i<rom_size/2; i++) {
	1088	UINT16 x = src[i];
	1089
	1090	IGS27_CRYPT1
	1091	IGS27_CRYPT2_ALT
	1092	//  IGS27_CRYPT3
	1093	IGS27_CRYPT4
	1094	IGS27_CRYPT5
	1095	IGS27_CRYPT6 // correct??
	1096	IGS27_CRYPT7
	1097	IGS27_CRYPT8
	1098
	1099	x ^= chessc2_tab[(i>> 1) & 0xff] << 8;
	1100
	1101	src[i] = x;
	1102	}
	1103	}
	1104
	1105
	1106	static const UINT8 klxyj_tab[0x100] = {
	1107	0x49, 0x47, 0x53, 0x30, 0x30, 0x30, 0x38, 0x52, 0x44, 0x34, 0x30, 0x31, 0x30, 0x39, 0x32, 0x34,
	1108	0x3F, 0x0F, 0x66, 0x9A, 0xBF, 0x0D, 0x06, 0x55, 0x09, 0x01, 0xEB, 0x72, 0xEB, 0x9B, 0x89, 0xFA,
	1109	0x24, 0xD1, 0x5D, 0xCA, 0xE6, 0x8A, 0x8C, 0xE0, 0x92, 0x8D, 0xBF, 0xE4, 0xAF, 0xAA, 0x3E, 0xFA,
	1110	0x2B, 0x27, 0x4B, 0xC7, 0xD6, 0x6D, 0xC1, 0xC2, 0x1C, 0xF4, 0xED, 0xBD, 0x03, 0x6C, 0xAD, 0xB3,
	1111	0x65, 0x2D, 0xC7, 0xD3, 0x6E, 0xE0, 0x8C, 0xCE, 0x59, 0x6F, 0xAE, 0x5E, 0x66, 0x2B, 0x5E, 0x17,
	1112	0x20, 0x3D, 0xA9, 0x72, 0xCD, 0x4F, 0x14, 0x17, 0x35, 0x7B, 0x77, 0x6B, 0x98, 0x73, 0x17, 0x5A,
	1113	0xEA, 0xF2, 0x07, 0x66, 0x51, 0x64, 0xC1, 0xF0, 0xE2, 0xD1, 0x00, 0xC6, 0x97, 0x0F, 0xE0, 0xEE,
	1114	0x94, 0x28, 0x39, 0xB2, 0x9B, 0x0A, 0x38, 0xED, 0xCC, 0x6E, 0x40, 0x94, 0xA2, 0x0A, 0x00, 0x88,
	1115	0x2B, 0xFA, 0xD5, 0x9A, 0x87, 0x6C, 0x62, 0xDF, 0xA4, 0x8B, 0x6D, 0x37, 0x38, 0xAE, 0xFD, 0x18,
	1116	0xFF, 0xC2, 0xB2, 0xA0, 0x37, 0xF5, 0x64, 0xDB, 0x59, 0xA5, 0x00, 0x51, 0x19, 0x88, 0x9F, 0xD4,
	1117	0xA0, 0x1C, 0xE7, 0x88, 0x08, 0x51, 0xA7, 0x33, 0x19, 0x75, 0xAE, 0xC7, 0x42, 0x61, 0xEC, 0x2D,
	1118	0xDB, 0xE2, 0xCC, 0x54, 0x9A, 0x6A, 0xD1, 0x7A, 0x53, 0xF8, 0x6F, 0xBA, 0xF4, 0x45, 0x2C, 0xD7,
	1119	0xC0, 0x30, 0xF7, 0x47, 0xCC, 0x6B, 0xC8, 0x83, 0xB7, 0x67, 0x7A, 0x8E, 0xAD, 0x7E, 0xE5, 0xC4,
	1120	0x9F, 0x60, 0x40, 0xE5, 0xBC, 0xC0, 0xB5, 0x61, 0x33, 0x3F, 0x46, 0xE6, 0x2D, 0x98, 0xDF, 0x28,
	1121	0x05, 0x0E, 0xBC, 0xF0, 0xCA, 0x13, 0xFE, 0x68, 0xF7, 0x3A, 0x89, 0xA5, 0x71, 0x5F, 0x21, 0x76,
	1122	0xC2, 0x14, 0xC5, 0x6C, 0x95, 0x4f, 0x4f, 0x2A, 0x71, 0x52, 0x3C, 0xEE, 0xAA, 0xDB, 0xf1, 0x00
	1123	};
	1124
	1125	void klxyj_decrypt(running_machine &machine)
	1126	{
	1127	int i;
	1128	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1129
	1130	int rom_size = 0x80000;
	1131
	1132	for(i=0; i<rom_size/2; i++) {
	1133	UINT16 x = src[i];
	1134
	1135	IGS27_CRYPT1
	1136	IGS27_CRYPT2_ALT
	1137	//  IGS27_CRYPT3
	1138	IGS27_CRYPT4
	1139	IGS27_CRYPT5
	1140	IGS27_CRYPT6
	1141	IGS27_CRYPT7
	1142	IGS27_CRYPT8
	1143
	1144	x ^= klxyj_tab[(i>> 1) & 0xff] << 8;
	1145
	1146	src[i] = x;
	1147	}
	1148	}
	1149
	1150	static const UINT8 big2_tab[0x100] = {
	1151	0x68, 0x56, 0xC2, 0x54, 0xA2, 0x8C, 0x7B, 0x4F, 0x37, 0xAC, 0x60, 0xF8, 0x24, 0xDF, 0x3E, 0x6B,
	1152	0xE2, 0x89, 0x3D, 0xF3, 0x31, 0x83, 0x4A, 0x65, 0x27, 0x98, 0xC5, 0xBF, 0x78, 0x3E, 0x6C, 0x02,
	1153	0x07, 0x96, 0x88, 0x4D, 0xAE, 0xA6, 0x56, 0x3A, 0x4A, 0xD5, 0xB8, 0x7E, 0x0B, 0xA7, 0x1D, 0xBC,
	1154	0xFA, 0xBA, 0xAD, 0xA9, 0xCB, 0x02, 0xBA, 0x66, 0xE5, 0x41, 0x63, 0x1A, 0xB0, 0xCA, 0x8A, 0xCF,
	1155	0x1E, 0x76, 0xF9, 0x8F, 0x7C, 0xE7, 0xD0, 0xC0, 0x7B, 0xFC, 0x32, 0xBC, 0x7A, 0x95, 0x2F, 0xB4,
	1156	0x16, 0x88, 0xF5, 0xC6, 0xF4, 0xE3, 0x33, 0x5D, 0xCE, 0x65, 0xCE, 0xCA, 0xBC, 0x37, 0xC8, 0x20,
	1157	0xC5, 0xEF, 0x6D, 0x55, 0xA6, 0xC7, 0xBF, 0x96, 0xE1, 0x1A, 0x24, 0xEA, 0x09, 0x20, 0x4E, 0x0B,
	1158	0x4D, 0xEB, 0x6B, 0x82, 0x44, 0xA1, 0x8F, 0x01, 0xF8, 0xFB, 0x5E, 0x05, 0x35, 0xFF, 0xFE, 0xAC,
	1159	0x13, 0xF9, 0x3C, 0xD4, 0xC1, 0xC0, 0xFD, 0x76, 0x95, 0x27, 0xE7, 0x41, 0x52, 0xC1, 0x51, 0x7A,
	1160	0xB8, 0xDA, 0x69, 0x13, 0x52, 0xB3, 0xA4, 0x0B, 0x7B, 0xFD, 0x6B, 0x05, 0xB2, 0x98, 0x04, 0x2C,
	1161	0x20, 0x8C, 0xBE, 0x46, 0x68, 0x48, 0x60, 0x17, 0xAE, 0x1B, 0xD4, 0xF8, 0xEA, 0xF1, 0x10, 0xB8,
	1162	0x6F, 0x4F, 0x45, 0xB3, 0xB6, 0x90, 0x4C, 0x31, 0x70, 0x61, 0x4D, 0x02, 0xCC, 0x7B, 0xB1, 0x57,
	1163	0x06, 0xA0, 0x4B, 0xE2, 0x31, 0xD9, 0xC2, 0x31, 0x45, 0xEE, 0x42, 0x48, 0x6B, 0x26, 0x63, 0x7E,
	1164	0x89, 0x40, 0x59, 0x9A, 0x09, 0xB1, 0x5E, 0x2D, 0xEF, 0x20, 0x5C, 0x32, 0x1B, 0x20, 0xDF, 0xE5,
	1165	0xDA, 0x2D, 0x3B, 0xE1, 0xB4, 0xE9, 0xFA, 0x7D, 0x71, 0x97, 0x88, 0x68, 0x6D, 0xD8, 0x22, 0x82,
	1166	0x1E, 0xA6, 0xFC, 0xFE, 0xE3, 0x8E, 0xB1, 0xB7, 0x0F, 0x32, 0xF1, 0xCF, 0x36, 0xFE, 0x65, 0x8E
	1167	};
	1168
	1169	void big2_decrypt(running_machine &machine)
	1170	{
	1171	int i;
	1172	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1173
	1174	int rom_size = 0x80000;
	1175
	1176	for(i=0; i<rom_size/2; i++) {
	1177	UINT16 x = src[i];
	1178
	1179	IGS27_CRYPT1
	1180	IGS27_CRYPT2_ALT
	1181	//  IGS27_CRYPT3
	1182	IGS27_CRYPT4
	1183	IGS27_CRYPT5
	1184	IGS27_CRYPT6_ALT
	1185	IGS27_CRYPT7
	1186	IGS27_CRYPT8
	1187
	1188	x ^= big2_tab[(i>> 1) & 0xff] << 8;
	1189
	1190	src[i] = x;
	1191	}
	1192	}
	1193
	1194	static const UINT8 gonefsh2_tab[0x100] = {
	1195	0x49, 0x47, 0x53, 0x30, 0x30, 0x38, 0x32, 0x52, 0x44, 0x34, 0x30, 0x32, 0x31, 0x32, 0x31, 0x31,
	1196	0x28, 0xca, 0x9c, 0xAD, 0xbb, 0x2d, 0xf0, 0x41, 0x6e, 0xce, 0xad, 0x73, 0xae, 0x1c, 0xd1, 0x14,
	1197	0x6f, 0x9a, 0x75, 0x18, 0xa8, 0x91, 0x68, 0xe4, 0x09, 0xf4, 0x0f, 0xd7, 0xff, 0x93, 0x7d, 0x1b,
	1198	0xeb, 0x84, 0xce, 0xad, 0x9e, 0xcf, 0xc9, 0xab, 0x18, 0x59, 0xb6, 0xde, 0x82, 0x13, 0x7c, 0x88,
	1199	0x69, 0x63, 0xff, 0x6f, 0x3c, 0xd2, 0xb9, 0x29, 0x09, 0xf8, 0x97, 0xaa, 0x74, 0xa5, 0x16, 0x0d,
	1200	0xf9, 0x51, 0x9e, 0x9f, 0x63, 0xc6, 0x1e, 0x32, 0x8c, 0x0c, 0xe9, 0xa0, 0x56, 0x95, 0xd1, 0x9d,
	1201	0xea, 0xa9, 0x82, 0xc3, 0x30, 0x15, 0x21, 0xd8, 0x8f, 0x10, 0x25, 0x61, 0xe6, 0x6d, 0x75, 0x6d,
	1202	0xcb, 0x08, 0xc3, 0x9b, 0x03, 0x6a, 0x28, 0x6d, 0x42, 0xbf, 0x00, 0xd2, 0x24, 0xfa, 0x08, 0xee,
	1203	0x6b, 0x46, 0xb7, 0x2c, 0x7b, 0xb0, 0xda, 0x86, 0x13, 0x14, 0x73, 0x14, 0x4d, 0x45, 0xd3, 0xd4,
	1204	0xd9, 0x80, 0xf5, 0xb8, 0x76, 0x13, 0x1e, 0xf6, 0xb1, 0x4a, 0xb3, 0x8b, 0xe2, 0x9a, 0x5a, 0x11,
	1205	0x64, 0x11, 0x55, 0xc3, 0x14, 0xfd, 0x1b, 0xce, 0x0c, 0xdc, 0x38, 0xda, 0xa1, 0x84, 0x66, 0xd9,
	1206	0x9b, 0x93, 0xed, 0x0f, 0xb4, 0x19, 0x38, 0x62, 0x53, 0x85, 0xb9, 0xe4, 0x89, 0xcd, 0xfe, 0x9e,
	1207	0x4d, 0xe2, 0x14, 0x9f, 0xf4, 0x53, 0x1c, 0x46, 0xf4, 0x40, 0x2c, 0xcc, 0xda, 0x82, 0x69, 0x15,
	1208	0x88, 0x18, 0x62, 0xb7, 0xb4, 0xd5, 0xaf, 0x4b, 0x9e, 0x48, 0xca, 0xf4, 0x11, 0xec, 0x2d, 0x2e,
	1209	0x9d, 0x91, 0xad, 0xda, 0x13, 0x0a, 0x16, 0x86, 0x41, 0x18, 0x08, 0x01, 0xEF, 0x97, 0x11, 0x1f,
	1210	0x1a, 0xe7, 0x0c, 0xc9, 0x6f, 0x9d, 0xb9, 0x49, 0x0b, 0x6b, 0x9e, 0xd4, 0x72, 0x4d, 0x1d, 0x59
	1211	};
	1212
	1213	void gonefsh2_decrypt(running_machine &machine)
	1214	{
	1215	int i;
	1216	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1217
	1218	int rom_size = 0x80000;
	1219
	1220	for(i=0; i<rom_size/2; i++) {
	1221	UINT16 x = src[i];
	1222
	1223	IGS27_CRYPT1
	1224	IGS27_CRYPT2_ALT
	1225	//  IGS27_CRYPT3
	1226	IGS27_CRYPT4
	1227	IGS27_CRYPT5
	1228	IGS27_CRYPT6_ALT
	1229	IGS27_CRYPT7
	1230	IGS27_CRYPT8
	1231
	1232	x ^= gonefsh2_tab[(i>> 1) & 0xff] << 8;
	1233
	1234	src[i] = x;
	1235	}
	1236	}
	1237
	1238	static const UINT8 sddz_tab[0x100] = {
	1239	0xd7, 0x5f, 0xc8, 0x5b, 0xbf, 0xfa, 0x61, 0x0c, 0xdd, 0xab, 0xc3, 0x26, 0x3b, 0xd8, 0xbc, 0x1e,
	1240	0xa6, 0x4b, 0xcf, 0xdc, 0x12, 0x61, 0x70, 0xd2, 0x76, 0xef, 0x44, 0xe8, 0x9a, 0x65, 0xf5, 0x13,
	1241	0xb3, 0x1e, 0xcd, 0x00, 0xdf, 0x30, 0xa7, 0x9d, 0xb7, 0x49, 0xdf, 0xf6, 0xa7, 0x0b, 0x1a, 0x58,
	1242	0x2a, 0xea, 0x0e, 0x92, 0x39, 0x96, 0x25, 0x5d, 0x1b, 0xda, 0x27, 0x63, 0x4f, 0xe0, 0xda, 0x04,
	1243	0x7e, 0x10, 0x16, 0xbc, 0xff, 0x52, 0x73, 0x4a, 0x82, 0xd4, 0xba, 0xd8, 0x13, 0xb3, 0xe9, 0xfd,
	1244	0x9a, 0x6c, 0x6c, 0xd6, 0xef, 0x63, 0x9d, 0xa2, 0xf6, 0x26, 0x94, 0x55, 0x25, 0x93, 0x21, 0x26,
	1245	0x2a, 0xbf, 0x4b, 0xc8, 0x22, 0x18, 0x2d, 0x5d, 0xb6, 0x02, 0xba, 0x70, 0xcd, 0xae, 0xd5, 0xed,
	1246	0x5f, 0x48, 0xca, 0xd5, 0x3d, 0x41, 0xd0, 0xee, 0xd7, 0xd9, 0xba, 0x01, 0x6c, 0x34, 0x58, 0x33,
	1247	0xde, 0x44, 0x6d, 0xee, 0x95, 0x5c, 0x0f, 0x97, 0x98, 0xdc, 0xf0, 0x76, 0xc5, 0x73, 0x46, 0x51,
	1248	0x1c, 0xe5, 0xe0, 0xda, 0x4b, 0x38, 0xb6, 0x08, 0x20, 0xfd, 0xa2, 0xbc, 0x0e, 0xcc, 0xa9, 0xac,
	1249	0x84, 0xb8, 0x42, 0x5c, 0x5b, 0x14, 0x4f, 0xc3, 0xb0, 0x2b, 0xbd, 0x68, 0x42, 0xbc, 0x9c, 0x01,
	1250	0x7e, 0xec, 0xd6, 0x3b, 0x20, 0x10, 0x07, 0x78, 0xdf, 0x18, 0xa5, 0xa2, 0x15, 0xa2, 0x7a, 0xa0,
	1251	0x7c, 0xf1, 0xcb, 0x1a, 0x7d, 0x69, 0x47, 0xe9, 0xd9, 0xf6, 0xf7, 0x78, 0x41, 0x8f, 0x0f, 0x24,
	1252	0xed, 0xb5, 0x04, 0x39, 0x09, 0xf0, 0x7b, 0x06, 0x14, 0xb4, 0xc1, 0xe2, 0xc5, 0xa0, 0x2d, 0x75,
	1253	0xb9, 0xb7, 0xa8, 0x81, 0x03, 0x13, 0xce, 0x0e, 0x47, 0x45, 0x0f, 0xfe, 0xe5, 0x24, 0xf7, 0x77,
	1254	0x4c, 0x87, 0xd2, 0x04, 0xe9, 0xc1, 0xea, 0x7b, 0xbe, 0x58, 0x4f, 0x35, 0x27, 0xfc, 0xf1, 0x11
	1255	};
	1256
	1257	void sddz_decrypt(running_machine &machine)
	1258	{
	1259	int i;
	1260	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1261
	1262	int rom_size = 0x80000;
	1263
	1264	for(i=0; i<rom_size/2; i++) {
	1265	UINT16 x = src[i];
	1266
	1267	IGS27_CRYPT1_ALT;
	1268	IGS27_CRYPT2_ALT
	1269	//  IGS27_CRYPT3
	1270	IGS27_CRYPT4
	1271	IGS27_CRYPT5
	1272	IGS27_CRYPT6_ALT
	1273	IGS27_CRYPT7
	1274	IGS27_CRYPT8
	1275
	1276	x ^= sddz_tab[(i>> 1) & 0xff] << 8;
	1277
	1278	src[i] = x;
	1279	}
	1280	}
	1281
	1282	static const UINT8 lhzb3_tab[0x100] = {
	1283	0x13, 0x45, 0x21, 0xA1, 0x69, 0x9A, 0x05, 0xDA, 0x7D, 0x10, 0xDA, 0x7F, 0x34, 0x9F, 0xF3, 0x64,
	1284	0x35, 0xF9, 0x16, 0x1C, 0xD4, 0x60, 0x02, 0xF3, 0x42, 0xC7, 0x42, 0x29, 0xF3, 0x2C, 0x31, 0x71,
	1285	0x50, 0x35, 0x4E, 0xAA, 0x9F, 0x09, 0xC3, 0xDD, 0x2F, 0x72, 0x30, 0x77, 0xC7, 0x30, 0xBC, 0xC8,
	1286	0x51, 0xA0, 0x5E, 0xBB, 0xC3, 0x8E, 0x69, 0xD7, 0x4F, 0x57, 0x56, 0x77, 0xCB, 0x43, 0xD6, 0x46,
	1287	0x62, 0x21, 0x18, 0xFD, 0x7D, 0x24, 0x58, 0x61, 0xEC, 0xFE, 0xA9, 0x77, 0x59, 0x3B, 0x03, 0x0A,
	1288	0xEF, 0xDF, 0x90, 0x60, 0x46, 0x43, 0x33, 0x38, 0x92, 0x2D, 0x5A, 0x08, 0x0D, 0x2F, 0x05, 0x75,
	1289	0x3E, 0x60, 0x87, 0x22, 0xB7, 0xBF, 0xD6, 0xF9, 0x17, 0x86, 0xEA, 0x02, 0xBE, 0x23, 0xBA, 0xD3,
	1290	0xDD, 0x0D, 0x3E, 0x8C, 0x65, 0xA0, 0xF8, 0xD8, 0x2F, 0x35, 0xC6, 0x26, 0x6C, 0x81, 0xE6, 0x29,
	1291	0x50, 0x30, 0x4A, 0x8E, 0xFA, 0xC2, 0x1E, 0xFD, 0xA7, 0xA5, 0x98, 0x53, 0x18, 0x94, 0xFF, 0x1D,
	1292	0x41, 0x2F, 0xFF, 0x58, 0x33, 0xDC, 0x2B, 0x67, 0x4B, 0xDD, 0xD3, 0x56, 0x9C, 0xB2, 0x09, 0x4E,
	1293	0x9B, 0xB1, 0xEE, 0x58, 0x0A, 0xE4, 0x42, 0x56, 0x26, 0x23, 0x2C, 0x3F, 0x14, 0x73, 0x46, 0x9A,
	1294	0xA1, 0x42, 0x17, 0x12, 0xDB, 0xA2, 0xDD, 0x5D, 0x0C, 0xEC, 0xDC, 0xF7, 0xC1, 0x76, 0xE0, 0x24,
	1295	0x65, 0xEF, 0x41, 0x83, 0x35, 0x38, 0x78, 0x0E, 0x65, 0x82, 0xE3, 0x55, 0x90, 0xA8, 0xD5, 0xF7,
	1296	0x66, 0xCF, 0xE2, 0x61, 0x91, 0x3C, 0x69, 0xCB, 0xE7, 0x75, 0x62, 0x6F, 0xD7, 0x9B, 0x69, 0x0C,
	1297	0x0D, 0x07, 0x0C, 0x9C, 0x68, 0x24, 0x51, 0x51, 0x1F, 0x8D, 0x8B, 0xD6, 0x2E, 0x67, 0x5F, 0xC3,
	1298	0x07, 0x00, 0x12, 0x61, 0x77, 0xA8, 0x15, 0xA1, 0xD6, 0xD0, 0xD3, 0x57, 0x73, 0x62, 0xB9, 0xBB
	1299	};
	1300
	1301	void lhzb3_decrypt(running_machine &machine)
	1302	{
	1303	int i;
	1304	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1305
	1306	int rom_size = 0x80000;
	1307
	1308	for(i=0; i<rom_size/2; i++) {
	1309	UINT16 x = src[i];
	1310
	1311	IGS27_CRYPT1
	1312	IGS27_CRYPT2_ALT
	1313	//  IGS27_CRYPT3
	1314	IGS27_CRYPT4
	1315	IGS27_CRYPT5
	1316	IGS27_CRYPT6_ALT
	1317	IGS27_CRYPT7
	1318	IGS27_CRYPT8
	1319
	1320	x ^= lhzb3_tab[(i>> 1) & 0xff] << 8;
	1321
	1322	src[i] = x;
	1323	}
	1324	}
	1325
	1326	static const UINT8 mgfx_tab[0x100] = {
	1327	0x49, 0x47, 0x53, 0x30, 0x30, 0x38, 0x33, 0x52, 0x44, 0x34, 0x30, 0x32, 0x31, 0x32, 0x31, 0x32,
	1328	0x82, 0x6B, 0xCA, 0xBE, 0x9B, 0x9F, 0xC3, 0xA5, 0x8F, 0x2A, 0x9F, 0x0E, 0x26, 0x28, 0x4A, 0x9D,
	1329	0xA2, 0x57, 0xFC, 0x43, 0xF3, 0x34, 0x05, 0x72, 0x1E, 0x59, 0xD9, 0xA0, 0xE7, 0x16, 0x5B, 0xFF,
	1330	0xC6, 0x4F, 0x6E, 0x7A, 0x09, 0x96, 0xBA, 0xF3, 0x46, 0x89, 0xBB, 0xBC, 0x04, 0x6D, 0x11, 0x54,
	1331	0xA9, 0x0B, 0x03, 0x63, 0xA6, 0xCB, 0x54, 0xF7, 0xE2, 0x0F, 0x4B, 0x01, 0x65, 0xD3, 0xFD, 0x0B,
	1332	0x46, 0x82, 0xDE, 0x3C, 0xD7, 0x1B, 0x87, 0x8E, 0x0E, 0x84, 0xCA, 0x4D, 0x37, 0x2E, 0xF4, 0xD4,
	1333	0xD8, 0xEB, 0x61, 0x84, 0xE5, 0x0C, 0x46, 0x05, 0x25, 0xBF, 0xBB, 0xC0, 0xE4, 0xA7, 0x07, 0x9D,
	1334	0xDA, 0xBD, 0x31, 0xFA, 0x5B, 0x66, 0xC3, 0xEC, 0xC1, 0xD5, 0xE1, 0xB9, 0x17, 0xA4, 0x8B, 0x96,
	1335	0x07, 0xAE, 0x2F, 0x9D, 0x06, 0x30, 0x73, 0x12, 0xBE, 0x1F, 0x40, 0xD7, 0xBB, 0xCC, 0x12, 0x2D,
	1336	0x5A, 0xB6, 0x7F, 0xAD, 0xEF, 0xB0, 0x06, 0x86, 0x36, 0x34, 0x1A, 0xF8, 0xFC, 0x06, 0x6F, 0x11,
	1337	0x0E, 0x0C, 0x84, 0xA7, 0x62, 0x6D, 0x71, 0x97, 0x84, 0xE9, 0xF3, 0x3C, 0x44, 0x79, 0xB5, 0x32,
	1338	0x9E, 0x27, 0xE1, 0x4C, 0xEA, 0x30, 0xE7, 0xD4, 0x45, 0x57, 0x8D, 0x02, 0x3E, 0x8C, 0x38, 0xBF,
	1339	0xC5, 0xBE, 0x79, 0x9B, 0x51, 0xFD, 0xDB, 0x0B, 0x51, 0xD5, 0xEC, 0xE8, 0xD6, 0xE6, 0x89, 0x26,
	1340	0x7E, 0xC8, 0x6F, 0xD1, 0xA4, 0x1E, 0xFF, 0x4D, 0xC5, 0xF8, 0x51, 0xCE, 0x36, 0x6F, 0x7D, 0x16,
	1341	0x04, 0x7B, 0x26, 0x6F, 0x2C, 0x18, 0x47, 0xE8, 0xFC, 0x99, 0x42, 0xD3, 0xC9, 0x4C, 0x26, 0x7F,
	1342	0xD2, 0x4F, 0x40, 0x32, 0x74, 0xB2, 0xE6, 0x6B, 0x90, 0xCF, 0x7F, 0x56, 0x3A, 0xE5, 0xD7, 0x8F
	1343	};
	1344
	1345	void mgfx_decrypt(running_machine &machine)
	1346	{
	1347	int i;
	1348	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1349
	1350	int rom_size = 0x80000;
	1351
	1352	for(i=0; i<rom_size/2; i++) {
	1353	UINT16 x = src[i];
	1354
	1355	IGS27_CRYPT1_ALT
	1356	//  IGS27_CRYPT2
	1357	IGS27_CRYPT3_ALT2
	1358	IGS27_CRYPT4
	1359	//  IGS27_CRYPT5
	1360	IGS27_CRYPT6_ALT
	1361	IGS27_CRYPT7
	1362	IGS27_CRYPT8
	1363
	1364	x ^= mgfx_tab[(i>> 1) & 0xff] << 8;
	1365
	1366	src[i] = x;
	1367	}
	1368	}
	1369
	1370	static const UINT8 lhzb4_tab[0x100] = {
	1371	0x49, 0x47, 0x53, 0x30, 0x31, 0x36, 0x39, 0x52, 0x44, 0x32, 0x30, 0x34, 0x30, 0x37, 0x33, 0x30,
	1372	0x87, 0xA5, 0x22, 0x6E, 0x2F, 0x89, 0xC6, 0x3B, 0xF3, 0x4D, 0x29, 0xD5, 0x46, 0x17, 0x9C, 0x38,
	1373	0xC2, 0xE4, 0x16, 0x4B, 0x36, 0xFD, 0xE0, 0x7F, 0xF2, 0xBE, 0x83, 0xA6, 0x52, 0x87, 0xF2, 0x11,
	1374	0x88, 0x03, 0xF4, 0xEE, 0xAF, 0x98, 0xD5, 0xE0, 0x0E, 0x2F, 0x4D, 0xDF, 0xA9, 0x26, 0xB1, 0x53,
	1375	0x0E, 0x92, 0x58, 0x6C, 0x5E, 0xB9, 0x50, 0xC5, 0x99, 0xCF, 0x42, 0x39, 0x2F, 0xF1, 0xA3, 0x04,
	1376	0xC5, 0x60, 0x1D, 0x1E, 0x44, 0xFF, 0x3D, 0xD5, 0x28, 0x0E, 0x5D, 0xA9, 0x08, 0x29, 0xD4, 0x6C,
	1377	0x61, 0x7C, 0x5D, 0x9B, 0xA7, 0x48, 0xC5, 0xF7, 0x8E, 0x9B, 0xD9, 0x67, 0x95, 0x4B, 0x8F, 0x12,
	1378	0xD4, 0x35, 0x74, 0xB8, 0x07, 0xB4, 0x55, 0x52, 0xDC, 0x64, 0x32, 0xEA, 0x7A, 0x18, 0x5F, 0xBC,
	1379	0x52, 0x19, 0xFC, 0x8E, 0x2A, 0xA2, 0x98, 0x4D, 0x66, 0x99, 0x21, 0xE9, 0x9A, 0x8E, 0x0F, 0x72,
	1380	0x4D, 0xF9, 0xD1, 0x74, 0x10, 0xB0, 0x77, 0x8F, 0xC0, 0xA7, 0xA2, 0x5B, 0x17, 0xED, 0xA9, 0x7B,
	1381	0x7A, 0xE3, 0x0D, 0xFF, 0xFE, 0xBE, 0x1F, 0xFF, 0xBB, 0x40, 0xF0, 0x76, 0x56, 0xB2, 0x79, 0x5D,
	1382	0xC9, 0x26, 0x0C, 0x08, 0x76, 0xEB, 0xFA, 0xC5, 0x6C, 0x51, 0x86, 0xB2, 0xF9, 0x9E, 0x0A, 0xDF,
	1383	0x70, 0x50, 0x68, 0xA5, 0x3C, 0x96, 0xB4, 0x46, 0x25, 0x09, 0x1F, 0xC6, 0xE2, 0xAF, 0x26, 0x09,
	1384	0xE0, 0x32, 0xFD, 0x2E, 0x52, 0x5D, 0x36, 0x2B, 0x79, 0xD8, 0xB6, 0xA9, 0x35, 0x24, 0xDA, 0x22,
	1385	0xCD, 0xDA, 0xE5, 0x39, 0xFB, 0x20, 0xAD, 0x59, 0x3C, 0x6C, 0x86, 0x92, 0x56, 0x7D, 0x6F, 0xB0,
	1386	0x29, 0x96, 0x7C, 0x9D, 0xBB, 0xFD, 0x83, 0xF9, 0x7F, 0xB5, 0x0A, 0xF8, 0xE6, 0x77, 0x71, 0x7B
	1387	};
	1388
	1389	void lhzb4_decrypt(running_machine &machine)
	1390	{
	1391	int i;
	1392	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1393
	1394	int rom_size = 0x80000;
	1395
	1396	for(i=0; i<rom_size/2; i++) {
	1397	UINT16 x = src[i];
	1398
	1399	IGS27_CRYPT1
	1400	//  IGS27_CRYPT2
	1401	//  IGS27_CRYPT3
	1402	IGS27_CRYPT4_ALT
	1403	//  IGS27_CRYPT5
	1404	IGS27_CRYPT6_ALT
	1405	IGS27_CRYPT7
	1406	IGS27_CRYPT8_ALT
	1407
	1408	x ^= lhzb4_tab[(i>> 1) & 0xff] << 8;
	1409
	1410	src[i] = x;
	1411	}
	1412	}
	1413
	1414
	1415	static const UINT8 fearless_tab[256] = {
	1416	0x49, 0x47, 0x53, 0x30, 0x32, 0x30, 0x32, 0x52, 0x44, 0x32, 0x30, 0x35, 0x30, 0x31, 0x30, 0x33,
	1417	0x0A, 0x68, 0x3C, 0x24, 0x56, 0x67, 0xED, 0xE3, 0x3A, 0x99, 0x20, 0x24, 0x09, 0x4D, 0x0C, 0xB6,
	1418	0x0D, 0xBB, 0xE0, 0xE4, 0x93, 0x79, 0x6C, 0x10, 0x3B, 0x3B, 0x10, 0x91, 0x7E, 0xCF, 0xE5, 0xC9,
	1419	0x80, 0x58, 0x2B, 0x8B, 0x18, 0xCA, 0xF3, 0xAC, 0x1D, 0xA6, 0x0D, 0xE7, 0xF4, 0xF7, 0x34, 0xF6,
	1420	0x57, 0x8D, 0x79, 0xEF, 0x67, 0x79, 0xED, 0xDC, 0xF5, 0xCA, 0x92, 0x9E, 0x0D, 0x86, 0x84, 0x04,
	1421	0xC5, 0xEB, 0x64, 0x27, 0x44, 0xE7, 0x05, 0x09, 0x15, 0xD5, 0x5A, 0x6D, 0xAE, 0x7A, 0xA0, 0xF9,
	1422	0x3C, 0x40, 0xC8, 0x8B, 0xB1, 0xB1, 0x27, 0xD8, 0x10, 0x37, 0x61, 0x4B, 0xF8, 0x12, 0x92, 0x1D,
	1423	0x70, 0x9A, 0xBF, 0xB0, 0xF2, 0xB7, 0x7D, 0x32, 0xBA, 0x9E, 0xE0, 0x6F, 0x4F, 0xCE, 0xA6, 0xF6,
	1424	0x53, 0x4A, 0xA5, 0x70, 0x88, 0x18, 0x72, 0x3C, 0x24, 0xFA, 0x53, 0x50, 0x57, 0x6B, 0x67, 0x4C,
	1425	0x19, 0xDD, 0x14, 0xDF, 0x39, 0x32, 0xB1, 0x5F, 0xA2, 0x79, 0x75, 0xA4, 0xF1, 0xEA, 0xA0, 0x25,
	1426	0x35, 0x24, 0xE8, 0x56, 0x05, 0xA5, 0x26, 0x41, 0xC8, 0x8A, 0x41, 0x63, 0x41, 0x89, 0x5B, 0xC9,
	1427	0x59, 0x2C, 0x3B, 0x6C, 0x31, 0x50, 0xFB, 0xC9, 0x68, 0xDD, 0xF2, 0xC4, 0xA9, 0xC7, 0xE4, 0xBF,
	1428	0x79, 0x46, 0x69, 0xF6, 0x3F, 0x51, 0x9B, 0x1E, 0x95, 0x61, 0x04, 0x3E, 0xCE, 0x64, 0xC6, 0xCD,
	1429	0xC8, 0xFF, 0x0C, 0x0D, 0xF3, 0x08, 0xB1, 0xA7, 0xA2, 0x44, 0x30, 0x88, 0x92, 0x5D, 0xCC, 0xFB,
	1430	0xB8, 0x27, 0x00, 0x07, 0x4F, 0x14, 0x29, 0x0B, 0x22, 0xF5, 0x72, 0x98, 0x17, 0xF3, 0x00, 0x8F,
	1431	0xFD, 0xCD, 0x60, 0x7C, 0x97, 0x54, 0x2D, 0x32, 0xE9, 0x24, 0x05, 0xA7, 0xC1, 0xA4, 0xAF, 0x11
	1432	};
	1433
	1434	void fearless_decrypt(running_machine &machine)
	1435	{
	1436	int i;
	1437	UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
	1438
	1439	int rom_size = 0x80000;
	1440
	1441	for(i=0; i<rom_size/2; i++)
	1442	{
	1443	UINT16 x = src[i];
	1444
	1445	// might not be 100% correct...
	1446	IGS27_CRYPT1
	1447	// IGS27_CRYPT2
	1448	IGS27_CRYPT3_ALT2
	1449	IGS27_CRYPT4
	1450	// IGS27_CRYPT5
	1451	IGS27_CRYPT6_ALT
	1452	IGS27_CRYPT7
	1453	IGS27_CRYPT8
	1454
	1455	x ^= fearless_tab[(i>> 1) & 0xff] << 8;
	1456
	1457	src[i] = x;
	1458	}
	1459	}

trunk/src/mame/machine/pgmcrypt.h

r0	r18916
	1	/* IGS 027 Encryptions */
	2
	3	void pgm_kov_decrypt(running_machine &machine);
	4	void pgm_kovsh_decrypt(running_machine &machine);
	5	void pgm_kov2_decrypt(running_machine &machine);
	6	void pgm_kov2p_decrypt(running_machine &machine);
	7	void pgm_mm_decrypt(running_machine &machine);
	8	void pgm_photoy2k_decrypt(running_machine &machine);
	9	void pgm_py2k2_decrypt(running_machine &machine);
	10	void pgm_pstar_decrypt(running_machine &machine);
	11	void pgm_puzzli2_decrypt(running_machine &machine);
	12	void pgm_theglad_decrypt(running_machine &machine);
	13	void pgm_ddp2_decrypt(running_machine &machine);
	14	void pgm_dfront_decrypt(running_machine &machine);
	15	void pgm_oldsplus_decrypt(running_machine &machine);
	16	void pgm_kovshp_decrypt(running_machine &machine);
	17	void pgm_killbldp_decrypt(running_machine &machine);
	18	void pgm_svg_decrypt(running_machine &machine);
	19	void pgm_svgpcb_decrypt(running_machine &machine);
	20	void pgm_ket_decrypt(running_machine &machine);
	21	void pgm_espgal_decrypt(running_machine &machine);
	22	void pgm_happy6_decrypt(running_machine &machine);
	23	void sdwx_decrypt(running_machine &machine);
	24	void hauntedh_decrypt(running_machine &machine);
	25	void chessc2_decrypt(running_machine &machine);
	26	void klxyj_decrypt(running_machine &machine);
	27	void big2_decrypt(running_machine &machine);
	28	void gonefsh2_decrypt(running_machine &machine);
	29	void sddz_decrypt(running_machine &machine);
	30	void lhzb3_decrypt(running_machine &machine);
	31	void mgfx_decrypt(running_machine &machine);
	32	void lhzb4_decrypt(running_machine &machine);
	33	void fearless_decrypt(running_machine &machine);

trunk/src/mame/machine/pgmprot4.c

r18915	r18916
33	33	*/
34	34
35	35
	36	void pgm_dw3_decrypt(running_machine &machine)
	37	{
	38
	39	//  int i;
	40	//  UINT16 *src=(UINT16 *) (OP_ROM+0x100000);
	41
	42	int i;
	43	UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base()+0x100000);
	44
	45	int rom_size = 0x100000;
	46
	47	for(i=0; i<rom_size/2; i++) {
	48	UINT16 x = src[i];
	49
	50	if((i & 0x005460) == 0x001400)
	51	x ^= 0x0100;
	52
	53	if((i & 0x005450) == 0x001040)
	54	x ^= 0x0100;
	55
	56	if((i & 0x005e00) == 0x001c00)
	57	x ^= 0x40;
	58
	59	if((i & 0x005580) == 0x001100)
	60	x ^= 0x40;
	61
	62
	63
	64	src[i] = x;
	65	}
	66	}
	67
	68	void pgm_killbld_decrypt(running_machine &machine)
	69	{
	70
	71	//  int i;
	72	//  UINT16 *src=(UINT16 *) (OP_ROM+0x100000);
	73
	74	int i;
	75	UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base()+0x100000);
	76
	77	int rom_size = 0x200000;
	78
	79	for(i=0; i<rom_size/2; i++) {
	80	UINT16 x = src[i];
	81
	82	if((i & 0x6d00) == 0x0400 || (i & 0x6c80) == 0x0880)
	83	x ^= 0x0008;
	84	if((i & 0x7500) == 0x2400 || (i & 0x7600) == 0x3200)
	85	x ^= 0x1000;
	86
	87	src[i] = x;
	88	}
	89	}
	90
	91
	92
36	93	static void IGS022_do_dma(running_machine& machine, UINT16 src, UINT16 dst, UINT16 size, UINT16 mode)
37	94	{
38	95	pgm_022_025_state *state = machine.driver_data<pgm_022_025_state>();

trunk/src/mame/machine/pgmprot5.c

r18915	r18916
50	50	}
51	51	}
52	52
	53	static void pgm_dw2_decrypt(running_machine &machine)
	54	{
53	55
	56	int i;
	57	UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base()+0x100000);
54	58
	59	int rom_size = 0x80000;
	60
	61	for(i=0; i<rom_size/2; i++) {
	62	UINT16 x = src[i];
	63
	64	if(((i & 0x020890) == 0x000000)
	65	|| ((i & 0x020000) == 0x020000 && (i & 0x001500) != 0x001400))
	66	x ^= 0x0002;
	67
	68	if(((i & 0x020400) == 0x000000 && (i & 0x002010) != 0x002010)
	69	|| ((i & 0x020000) == 0x020000 && (i & 0x000148) != 0x000140))
	70	x ^= 0x0400;
	71
	72	src[i] = x;
	73	}
	74	}
	75
55	76	static void drgwld2_common_init(running_machine &machine)
56	77	{
57	78	pgm_basic_init(machine);

trunk/src/mame/includes/pgm.h

r18915	r18916
6	6	#include "sound/ics2115.h"
7	7	#include "cpu/arm7/arm7core.h"
8	8	#include "machine/nvram.h"
	9	#include "machine/pgmcrypt.h"
9	10
10	11	#define PGMARM7LOGERROR 0
11	12
r18915	r18916
334	335
335	336
336	337
337		/*----------- defined in machine/pgmcrypt.c -----------*/
338
339		void pgm_kov_decrypt(running_machine &machine);
340		void pgm_kovsh_decrypt(running_machine &machine);
341		void pgm_kov2_decrypt(running_machine &machine);
342		void pgm_kov2p_decrypt(running_machine &machine);
343		void pgm_mm_decrypt(running_machine &machine);
344		void pgm_dw2_decrypt(running_machine &machine);
345		void pgm_photoy2k_decrypt(running_machine &machine);
346		void pgm_py2k2_decrypt(running_machine &machine);
347		void pgm_dw3_decrypt(running_machine &machine);
348		void pgm_killbld_decrypt(running_machine &machine);
349		void pgm_pstar_decrypt(running_machine &machine);
350		void pgm_puzzli2_decrypt(running_machine &machine);
351		void pgm_theglad_decrypt(running_machine &machine);
352		void pgm_ddp2_decrypt(running_machine &machine);
353		void pgm_dfront_decrypt(running_machine &machine);
354		void pgm_oldsplus_decrypt(running_machine &machine);
355		void pgm_kovshp_decrypt(running_machine &machine);
356		void pgm_killbldp_decrypt(running_machine &machine);
357		void pgm_svg_decrypt(running_machine &machine);
358		void pgm_svgpcb_decrypt(running_machine &machine);
359		void pgm_ket_decrypt(running_machine &machine);
360		void pgm_espgal_decrypt(running_machine &machine);
361		void pgm_happy6_decrypt(running_machine &machine);
362
363	338	/*----------- defined in machine/pgmprot.c -----------*/
364	339
365	340

trunk/src/mame/drivers/igs_m027.c

r18915	r18916
12	12	To emulate these games the Internal ROM will need dumping
13	13	There are at least 20 other games on this and similar platforms.
14	14
	15	Many of these also seem to have a 80C51 based MCU, also covered by
	16	a holographic sticker, this appears to be unprotected but has only been
	17	read for a few sets, it probably either acts as a secondary protection
	18	device or as a main CPU instructing the ARM.
	19
15	20	*/
16	21
17	22	#include "emu.h"
18	23	#include "cpu/arm7/arm7.h"
19	24	#include "cpu/arm7/arm7core.h"
20	25	#include "machine/nvram.h"
	26	#include "machine/pgmcrypt.h"
	27	#include "sound/ics2115.h"
21	28
22	29
23	30	class igs_m027_state : public driver_device
r18915	r18916
55	62	DECLARE_DRIVER_INIT(hauntedh);
56	63	DECLARE_DRIVER_INIT(bigd2);
57	64	DECLARE_DRIVER_INIT(klxyj);
	65	DECLARE_DRIVER_INIT(fearless);
58	66	TILE_GET_INFO_MEMBER(get_tx_tilemap_tile_info);
59	67	TILE_GET_INFO_MEMBER(get_bg_tilemap_tile_info);
60	68	virtual void video_start();
r18915	r18916
390	398	MACHINE_CONFIG_END
391	399
392	400
	401	static void sound_irq( device_t *device, int level )
	402	{
	403	}
393	404
394	405
	406	static MACHINE_CONFIG_START( fearless, igs_m027_state )
	407	MCFG_CPU_ADD("maincpu",ARM7, 50000000/2)
	408	MCFG_CPU_PROGRAM_MAP(igs_majhong_map)
395	409
	410	MCFG_CPU_VBLANK_INT_DRIVER("screen", igs_m027_state,  igs_majhong_interrupt)
	411
	412	MCFG_SCREEN_ADD("screen", RASTER)
	413	MCFG_SCREEN_REFRESH_RATE(60)
	414	MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
	415	MCFG_SCREEN_SIZE(512, 256)
	416	MCFG_SCREEN_VISIBLE_AREA(0, 512-1, 0, 256-1)
	417	MCFG_SCREEN_UPDATE_DRIVER(igs_m027_state, screen_update_igs_majhong)
	418
	419	MCFG_PALETTE_LENGTH(0x200)
	420
	421	/* sound hardware */
	422	MCFG_SPEAKER_STANDARD_MONO("mono")
	423	MCFG_ICS2115_ADD("ics", 0, sound_irq)
	424	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 5.0)
	425
	426	MACHINE_CONFIG_END
	427
	428
	429
	430
396	431	/***************************************************************************
397	432
398	433	ROMs Loading
r18915	r18916
772	807	ROM_LOAD( "haunted-h_sp.u3", 0x00000, 0x200000,  CRC(fe3fcddf) SHA1(ac57ab6d4e4883747c093bd19d0025cf6588cb2c) )
773	808	ROM_END
774	809
	810	// seems to be a bigger game with different video system
	811	ROM_START( fearless )
	812	ROM_REGION( 0x04000, "maincpu", 0 )
	813	/* Internal rom of IGS027A ARM based MCU */
	814	ROM_LOAD( "fearless_igs027a", 0x00000, 0x4000, NO_DUMP ) // sticker marked 'F1'
	815
	816	ROM_REGION( 0x80000, "user1", 0 ) // external ARM data / prg
	817	ROM_LOAD( "fearlessp_v-101us.u37", 0x000000, 0x80000, CRC(2522873c) SHA1(8db709877311b6d2796353fc9a44a820937e35c2) )
	818
	819	ROM_REGION( 0x10000, "plcc", 0 )
	820	ROM_LOAD( "fearlessp_07.u33", 0x000000, 0x10000, CRC(7dae4900) SHA1(bbf7ba7c9e95ff2ffeb1dc0fc7ccedd4da274d01) ) // MX10EXAQC (80C51 XA based MCU) marked 07, not read protected?
	821
	822	ROM_REGION( 0x800000, "gfx1", 0 ) // these all report FIXED BITS (0xxxxxxx), possibly just 7-bit colour data
	823	ROM_LOAD( "fearlessp_u6_cg-0h.u6",   0x000000, 0x800000, CRC(02d8bbbf) SHA1(7cf36c909a5d76096a725ffe0a697bcbafbcf985) )
	824	ROM_LOAD( "fearlessp_u7_cg-0l.u7",   0x000000, 0x800000, CRC(ca254db4) SHA1(f5670c2ff0720c84c9aff3cea95b118b6044e469) )
	825	ROM_LOAD( "fearlessp_u13_cg-1h.u13", 0x000000, 0x800000, CRC(c9d2a56d) SHA1(91d1665623bca743f68f15a27bbf433e2ffc0808) )
	826	ROM_LOAD( "fearlessp_u14_cg-1l.u14", 0x000000, 0x800000, CRC(7fe312d2) SHA1(c0add22d9fc4c0e32a03922cb709b947bfff429d) )
	827	ROM_LOAD( "fearlessp_u17_cg-2h.u17", 0x000000, 0x800000, CRC(756fe1f2) SHA1(48ee81c5fa4808406b57b2521b836db3ff5a7fa9) )
	828	ROM_LOAD( "fearlessp_u18_cg-2l.u18", 0x000000, 0x800000, CRC(07623d66) SHA1(041d5e44917bc16caa720ea98bdc0a4f5fb4b8e0) )
	829
	830	ROM_REGION( 0x800000, "ics", 0 )
	831	ROM_LOAD( "fearlessp_u25_music0.u25", 0x000000, 0x400000, CRC(a015b9b1) SHA1(7b129c59acd523dec82e58a75d873bbc5341fb28) )
	832	ROM_LOAD( "fearlessp_u26_music1.u26", 0x400000, 0x400000, CRC(9d5f18da) SHA1(42e5224c1af0898cc2e02b2e051ea8b629d5fb6d) )
	833	ROM_END
	834
	835
	836
775	837	static void pgm_create_dummy_internal_arm_region(running_machine &machine)
776	838	{
777	839	UINT16 *temp16 = (UINT16 *)machine.root_device().memregion("maincpu")->base();
r18915	r18916
797	859	}
798	860
799	861
800		static void sdwx_decrypt(running_machine &machine)
801		{
802
803		int i;
804		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
805
806		int rom_size = 0x80000;
807
808		for(i=0; i<rom_size/2; i++)
809		{
810		UINT16 x = src[i];
811
812		if((i & 0x000480) != 0x000080)  x ^= 0x0001;
813		if((i & 0x004008) == 0x004008)  x ^= 0x0002;
814		if((i & 0x000030) == 0x000010)  x ^= 0x0004;
815		if((i & 0x000242) != 0x000042)  x ^= 0x0008;
816		if((i & 0x008100) == 0x008000)  x ^= 0x0010;
817		if((i & 0x022004) != 0x000004)  x ^= 0x0020;
818		if((i & 0x011800) != 0x010000)  x ^= 0x0040;
819		if((i & 0x004820) == 0x004820)  x ^= 0x0080;
820
821		x ^= sdwx_tab[(i >> 1) & 0xff] << 8;
822
823		src[i] = x;
824		}
825		}
826
827
828		static const UINT8 hauntedh_tab[0x100] = {
829		0x49, 0x47, 0x53, 0x30, 0x32, 0x35, 0x34, 0x52, 0x44, 0x34, 0x30, 0x36, 0x30, 0x35, 0x32, 0x36,
830		0x6C, 0x65, 0x33, 0xFD, 0x7A, 0x71, 0x3D, 0xB8, 0x07, 0xF1, 0x86, 0x96, 0x19, 0x5A, 0xA2, 0x05,
831		0x49, 0xB1, 0xED, 0x2E, 0x7C, 0x7A, 0x65, 0x8B, 0xE1, 0xE3, 0xC8, 0xAA, 0x2B, 0x32, 0xEE, 0x3F,
832		0x10, 0x6C, 0x69, 0x70, 0x02, 0x47, 0x5B, 0x5D, 0x2D, 0x52, 0x97, 0xEF, 0xB1, 0x63, 0xFB, 0xE3,
833		0x21, 0x41, 0x0C, 0x17, 0x3C, 0x93, 0xD4, 0x13, 0xEB, 0x08, 0xF9, 0xDB, 0x7A, 0xC8, 0x1E, 0xF4,
834		0x1B, 0x1B, 0x7F, 0xB4, 0x98, 0x59, 0xC8, 0xCF, 0x58, 0x12, 0x36, 0x1F, 0x96, 0x7D, 0xF0, 0xB3,
835		0xDC, 0x26, 0xA8, 0x1C, 0xC6, 0xD4, 0x6E, 0xF3, 0xF5, 0xB9, 0xD4, 0xAF, 0x52, 0xDD, 0x48, 0xA5,
836		0x85, 0xCC, 0xAD, 0x60, 0xB4, 0x7F, 0x3C, 0x24, 0x80, 0x88, 0x9B, 0xBD, 0x3E, 0x82, 0x3B, 0x8D,
837		0x73, 0xB8, 0xF7, 0xD5, 0x92, 0x15, 0xeb, 0x43, 0xF9, 0x4C, 0x91, 0xBD, 0x29, 0x48, 0x22, 0x6D,
838		0x45, 0xD6, 0x2C, 0x0D, 0xCE, 0x91, 0x70, 0x74, 0x9D, 0x0E, 0xFE, 0x62, 0x22, 0x49, 0x94, 0x88,
839		0xDB, 0x50, 0x33, 0xDB, 0x18, 0x2E, 0x03, 0x1B, 0xED, 0x1A, 0x69, 0x9E, 0x78, 0xE1, 0x66, 0x62,
840		0x54, 0x91, 0x33, 0x52, 0x5E, 0x67, 0x1B, 0xD9, 0xA7, 0xFB, 0x98, 0xA5, 0xBA, 0xAA, 0xB1, 0xBD,
841		0x0F, 0x44, 0x93, 0xC6, 0xCF, 0xF7, 0x6F, 0x91, 0xCA, 0x7B, 0x93, 0xEA, 0xB6, 0x7F, 0xCC, 0x9C,
842		0xAB, 0x54, 0xFB, 0xC8, 0xDB, 0xD9, 0xF5, 0x68, 0x96, 0xA7, 0xA1, 0x1F, 0x7D, 0x7D, 0x4C, 0x43,
843		0x06, 0xED, 0x50, 0x2D, 0x30, 0x48, 0xE6, 0xC0, 0x88, 0xC8, 0x48, 0x38, 0x5D, 0xFC, 0x0a, 0x35,
844		0x3F, 0x79, 0xBA, 0x07, 0xBE, 0xBF, 0xB7, 0x3B, 0x61, 0x69, 0x4F, 0x67, 0xE5, 0x9A, 0x1D, 0x33
845		};
846
847		static void hauntedh_decrypt(running_machine &machine)
848		{
849		int i;
850		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
851
852		int rom_size = 0x080000;
853
854		for(i=0; i<rom_size/2; i++) {
855		UINT16 x = src[i];
856
857		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
858		//  if ((i & 0x104008) == 0x104008) x ^= 0x0002;
859		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
860		if ((i & 0x000042) != 0x000042) x ^= 0x0008;
861		//  if ((i & 0x048100) == 0x048000) x ^= 0x0010;
862		if ((i & 0x002004) != 0x000004) x ^= 0x0020;
863		if ((i & 0x001800) != 0x000000) x ^= 0x0040;
864		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
865
866		x ^= hauntedh_tab[(i>> 1) & 0xff] << 8;
867
868		src[i] = x;
869		}
870		}
871
872
873		static const UINT8 chessc2_tab[0x100] = {
874		0x49, 0x47, 0x53, 0x30, 0x30, 0x38, 0x32, 0x52, 0x44, 0x34, 0x30, 0x32, 0x31, 0x32, 0x31, 0x31,
875		0x28, 0xCA, 0x9C, 0xAD, 0xBB, 0x2D, 0xF0, 0x41, 0x6E, 0xCE, 0xAD, 0x73, 0xAE, 0x1C, 0xD1, 0x14,
876		0x6F, 0x9A, 0x75, 0x18, 0xA8, 0x91, 0x68, 0xe4, 0x09, 0xF4, 0x0F, 0xD7, 0xFF, 0x93, 0x7D, 0x1B,
877		0xEB, 0x84, 0xce, 0xAD, 0x9E, 0xCF, 0xC9, 0xAB, 0x18, 0x59, 0xb6, 0xde, 0x82, 0x13, 0x7C, 0x88,
878		0x69, 0x63, 0xFF, 0x6F, 0x3C, 0xD2, 0xB9, 0x29, 0x09, 0xF8, 0x97, 0xAA, 0x74, 0xA5, 0x16, 0x0D,
879		0xF9, 0x51, 0x9E, 0x9f, 0x63, 0xC6, 0x1E, 0x32, 0x8C, 0x0C, 0xE9, 0xA0, 0x56, 0x95, 0xD1, 0x9D,
880		0xEA, 0xA9, 0x82, 0xC3, 0x30, 0x15, 0x21, 0xD8, 0x8F, 0x10, 0x25, 0x61, 0xE6, 0x6D, 0x75, 0x6D,
881		0xCB, 0x08, 0xC3, 0x9B, 0x03, 0x6A, 0x28, 0x6D, 0x42, 0xBF, 0x00, 0xd2, 0x24, 0xFA, 0x08, 0xEE,
882		0x6B, 0x46, 0xB7, 0x2C, 0x7B, 0xB0, 0xDA, 0x86, 0x13, 0x14, 0x73, 0x14, 0x4D, 0x45, 0xD3, 0xD4,
883		0xD9, 0x80, 0xF5, 0xB8, 0x76, 0x13, 0x1E, 0xF6, 0xB1, 0x4A, 0xB3, 0x8B, 0xE2, 0x9A, 0x5A, 0x11,
884		0x64, 0x11, 0x55, 0xC3, 0x14, 0xFD, 0x1B, 0xCe, 0x0C, 0xDC, 0x38, 0xDA, 0xA1, 0x84, 0x66, 0xD9,
885		0x9b, 0x93, 0xED, 0x0F, 0xB4, 0x19, 0x38, 0x62, 0x53, 0x85, 0xB9, 0xE5, 0x89, 0xCd, 0xFE, 0x9E,
886		0x4D, 0xE2, 0x14, 0x9F, 0xF4, 0x53, 0x1C, 0x46, 0xf4, 0x40, 0x2C, 0xCC, 0xDa, 0x82, 0x69, 0x15,
887		0x88, 0x18, 0x62, 0xB7, 0xB4, 0xD5, 0xAF, 0x4B, 0x9E, 0x48, 0xCA, 0xF4, 0x11, 0xEC, 0x2D, 0x2C,
888		0x9D, 0x91, 0xAD, 0xDA, 0x13, 0x0A, 0x16, 0x86, 0x41, 0x18, 0x08, 0x01, 0xef, 0x97, 0x11, 0x1f,
889		0x1A, 0xE7, 0x0C, 0xC9, 0x6D, 0x9D, 0xB9, 0x49, 0x0B, 0x6B, 0x9E, 0xD4, 0x72, 0x4D, 0x1D, 0x59
890		};
891
892		static void chessc2_decrypt(running_machine &machine)
893		{
894		int i;
895		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
896
897		int rom_size = 0x80000;
898
899		for(i=0; i<rom_size/2; i++) {
900		UINT16 x = src[i];
901
902		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
903		if ((i & 0x004008) == 0x004008) x ^= 0x0002;
904		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
905		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
906		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
907		if ((i & 0x002004) != 0x000004) x ^= 0x0020; // correct??
908		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
909		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
910
911		x ^= chessc2_tab[(i>> 1) & 0xff] << 8;
912
913		src[i] = x;
914		}
915		}
916
917
918		static const UINT8 klxyj_tab[0x100] = {
919		0x49, 0x47, 0x53, 0x30, 0x30, 0x30, 0x38, 0x52, 0x44, 0x34, 0x30, 0x31, 0x30, 0x39, 0x32, 0x34,
920		0x3F, 0x0F, 0x66, 0x9A, 0xBF, 0x0D, 0x06, 0x55, 0x09, 0x01, 0xEB, 0x72, 0xEB, 0x9B, 0x89, 0xFA,
921		0x24, 0xD1, 0x5D, 0xCA, 0xE6, 0x8A, 0x8C, 0xE0, 0x92, 0x8D, 0xBF, 0xE4, 0xAF, 0xAA, 0x3E, 0xFA,
922		0x2B, 0x27, 0x4B, 0xC7, 0xD6, 0x6D, 0xC1, 0xC2, 0x1C, 0xF4, 0xED, 0xBD, 0x03, 0x6C, 0xAD, 0xB3,
923		0x65, 0x2D, 0xC7, 0xD3, 0x6E, 0xE0, 0x8C, 0xCE, 0x59, 0x6F, 0xAE, 0x5E, 0x66, 0x2B, 0x5E, 0x17,
924		0x20, 0x3D, 0xA9, 0x72, 0xCD, 0x4F, 0x14, 0x17, 0x35, 0x7B, 0x77, 0x6B, 0x98, 0x73, 0x17, 0x5A,
925		0xEA, 0xF2, 0x07, 0x66, 0x51, 0x64, 0xC1, 0xF0, 0xE2, 0xD1, 0x00, 0xC6, 0x97, 0x0F, 0xE0, 0xEE,
926		0x94, 0x28, 0x39, 0xB2, 0x9B, 0x0A, 0x38, 0xED, 0xCC, 0x6E, 0x40, 0x94, 0xA2, 0x0A, 0x00, 0x88,
927		0x2B, 0xFA, 0xD5, 0x9A, 0x87, 0x6C, 0x62, 0xDF, 0xA4, 0x8B, 0x6D, 0x37, 0x38, 0xAE, 0xFD, 0x18,
928		0xFF, 0xC2, 0xB2, 0xA0, 0x37, 0xF5, 0x64, 0xDB, 0x59, 0xA5, 0x00, 0x51, 0x19, 0x88, 0x9F, 0xD4,
929		0xA0, 0x1C, 0xE7, 0x88, 0x08, 0x51, 0xA7, 0x33, 0x19, 0x75, 0xAE, 0xC7, 0x42, 0x61, 0xEC, 0x2D,
930		0xDB, 0xE2, 0xCC, 0x54, 0x9A, 0x6A, 0xD1, 0x7A, 0x53, 0xF8, 0x6F, 0xBA, 0xF4, 0x45, 0x2C, 0xD7,
931		0xC0, 0x30, 0xF7, 0x47, 0xCC, 0x6B, 0xC8, 0x83, 0xB7, 0x67, 0x7A, 0x8E, 0xAD, 0x7E, 0xE5, 0xC4,
932		0x9F, 0x60, 0x40, 0xE5, 0xBC, 0xC0, 0xB5, 0x61, 0x33, 0x3F, 0x46, 0xE6, 0x2D, 0x98, 0xDF, 0x28,
933		0x05, 0x0E, 0xBC, 0xF0, 0xCA, 0x13, 0xFE, 0x68, 0xF7, 0x3A, 0x89, 0xA5, 0x71, 0x5F, 0x21, 0x76,
934		0xC2, 0x14, 0xC5, 0x6C, 0x95, 0x4f, 0x4f, 0x2A, 0x71, 0x52, 0x3C, 0xEE, 0xAA, 0xDB, 0xf1, 0x00
935		};
936
937		static void klxyj_decrypt(running_machine &machine)
938		{
939		int i;
940		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
941
942		int rom_size = 0x80000;
943
944		for(i=0; i<rom_size/2; i++) {
945		UINT16 x = src[i];
946
947		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
948		if ((i & 0x004008) == 0x004008) x ^= 0x0002;
949		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
950		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
951		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
952		if ((i & 0x002004) != 0x000004) x ^= 0x0020;
953		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
954		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
955
956		x ^= klxyj_tab[(i>> 1) & 0xff] << 8;
957
958		src[i] = x;
959		}
960		}
961
962		static const UINT8 big2_tab[0x100] = {
963		0x68, 0x56, 0xC2, 0x54, 0xA2, 0x8C, 0x7B, 0x4F, 0x37, 0xAC, 0x60, 0xF8, 0x24, 0xDF, 0x3E, 0x6B,
964		0xE2, 0x89, 0x3D, 0xF3, 0x31, 0x83, 0x4A, 0x65, 0x27, 0x98, 0xC5, 0xBF, 0x78, 0x3E, 0x6C, 0x02,
965		0x07, 0x96, 0x88, 0x4D, 0xAE, 0xA6, 0x56, 0x3A, 0x4A, 0xD5, 0xB8, 0x7E, 0x0B, 0xA7, 0x1D, 0xBC,
966		0xFA, 0xBA, 0xAD, 0xA9, 0xCB, 0x02, 0xBA, 0x66, 0xE5, 0x41, 0x63, 0x1A, 0xB0, 0xCA, 0x8A, 0xCF,
967		0x1E, 0x76, 0xF9, 0x8F, 0x7C, 0xE7, 0xD0, 0xC0, 0x7B, 0xFC, 0x32, 0xBC, 0x7A, 0x95, 0x2F, 0xB4,
968		0x16, 0x88, 0xF5, 0xC6, 0xF4, 0xE3, 0x33, 0x5D, 0xCE, 0x65, 0xCE, 0xCA, 0xBC, 0x37, 0xC8, 0x20,
969		0xC5, 0xEF, 0x6D, 0x55, 0xA6, 0xC7, 0xBF, 0x96, 0xE1, 0x1A, 0x24, 0xEA, 0x09, 0x20, 0x4E, 0x0B,
970		0x4D, 0xEB, 0x6B, 0x82, 0x44, 0xA1, 0x8F, 0x01, 0xF8, 0xFB, 0x5E, 0x05, 0x35, 0xFF, 0xFE, 0xAC,
971		0x13, 0xF9, 0x3C, 0xD4, 0xC1, 0xC0, 0xFD, 0x76, 0x95, 0x27, 0xE7, 0x41, 0x52, 0xC1, 0x51, 0x7A,
972		0xB8, 0xDA, 0x69, 0x13, 0x52, 0xB3, 0xA4, 0x0B, 0x7B, 0xFD, 0x6B, 0x05, 0xB2, 0x98, 0x04, 0x2C,
973		0x20, 0x8C, 0xBE, 0x46, 0x68, 0x48, 0x60, 0x17, 0xAE, 0x1B, 0xD4, 0xF8, 0xEA, 0xF1, 0x10, 0xB8,
974		0x6F, 0x4F, 0x45, 0xB3, 0xB6, 0x90, 0x4C, 0x31, 0x70, 0x61, 0x4D, 0x02, 0xCC, 0x7B, 0xB1, 0x57,
975		0x06, 0xA0, 0x4B, 0xE2, 0x31, 0xD9, 0xC2, 0x31, 0x45, 0xEE, 0x42, 0x48, 0x6B, 0x26, 0x63, 0x7E,
976		0x89, 0x40, 0x59, 0x9A, 0x09, 0xB1, 0x5E, 0x2D, 0xEF, 0x20, 0x5C, 0x32, 0x1B, 0x20, 0xDF, 0xE5,
977		0xDA, 0x2D, 0x3B, 0xE1, 0xB4, 0xE9, 0xFA, 0x7D, 0x71, 0x97, 0x88, 0x68, 0x6D, 0xD8, 0x22, 0x82,
978		0x1E, 0xA6, 0xFC, 0xFE, 0xE3, 0x8E, 0xB1, 0xB7, 0x0F, 0x32, 0xF1, 0xCF, 0x36, 0xFE, 0x65, 0x8E
979		};
980
981		static void big2_decrypt(running_machine &machine)
982		{
983		int i;
984		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
985
986		int rom_size = 0x80000;
987
988		for(i=0; i<rom_size/2; i++) {
989		UINT16 x = src[i];
990
991		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
992		if ((i & 0x004008) == 0x004008) x ^= 0x0002;
993		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
994		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
995		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
996		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
997		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
998		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
999
1000		x ^= big2_tab[(i>> 1) & 0xff] << 8;
1001
1002		src[i] = x;
1003		}
1004		}
1005
1006		static const UINT8 gonefsh2_tab[0x100] = {
1007		0x49, 0x47, 0x53, 0x30, 0x30, 0x38, 0x32, 0x52, 0x44, 0x34, 0x30, 0x32, 0x31, 0x32, 0x31, 0x31,
1008		0x28, 0xca, 0x9c, 0xAD, 0xbb, 0x2d, 0xf0, 0x41, 0x6e, 0xce, 0xad, 0x73, 0xae, 0x1c, 0xd1, 0x14,
1009		0x6f, 0x9a, 0x75, 0x18, 0xa8, 0x91, 0x68, 0xe4, 0x09, 0xf4, 0x0f, 0xd7, 0xff, 0x93, 0x7d, 0x1b,
1010		0xeb, 0x84, 0xce, 0xad, 0x9e, 0xcf, 0xc9, 0xab, 0x18, 0x59, 0xb6, 0xde, 0x82, 0x13, 0x7c, 0x88,
1011		0x69, 0x63, 0xff, 0x6f, 0x3c, 0xd2, 0xb9, 0x29, 0x09, 0xf8, 0x97, 0xaa, 0x74, 0xa5, 0x16, 0x0d,
1012		0xf9, 0x51, 0x9e, 0x9f, 0x63, 0xc6, 0x1e, 0x32, 0x8c, 0x0c, 0xe9, 0xa0, 0x56, 0x95, 0xd1, 0x9d,
1013		0xea, 0xa9, 0x82, 0xc3, 0x30, 0x15, 0x21, 0xd8, 0x8f, 0x10, 0x25, 0x61, 0xe6, 0x6d, 0x75, 0x6d,
1014		0xcb, 0x08, 0xc3, 0x9b, 0x03, 0x6a, 0x28, 0x6d, 0x42, 0xbf, 0x00, 0xd2, 0x24, 0xfa, 0x08, 0xee,
1015		0x6b, 0x46, 0xb7, 0x2c, 0x7b, 0xb0, 0xda, 0x86, 0x13, 0x14, 0x73, 0x14, 0x4d, 0x45, 0xd3, 0xd4,
1016		0xd9, 0x80, 0xf5, 0xb8, 0x76, 0x13, 0x1e, 0xf6, 0xb1, 0x4a, 0xb3, 0x8b, 0xe2, 0x9a, 0x5a, 0x11,
1017		0x64, 0x11, 0x55, 0xc3, 0x14, 0xfd, 0x1b, 0xce, 0x0c, 0xdc, 0x38, 0xda, 0xa1, 0x84, 0x66, 0xd9,
1018		0x9b, 0x93, 0xed, 0x0f, 0xb4, 0x19, 0x38, 0x62, 0x53, 0x85, 0xb9, 0xe4, 0x89, 0xcd, 0xfe, 0x9e,
1019		0x4d, 0xe2, 0x14, 0x9f, 0xf4, 0x53, 0x1c, 0x46, 0xf4, 0x40, 0x2c, 0xcc, 0xda, 0x82, 0x69, 0x15,
1020		0x88, 0x18, 0x62, 0xb7, 0xb4, 0xd5, 0xaf, 0x4b, 0x9e, 0x48, 0xca, 0xf4, 0x11, 0xec, 0x2d, 0x2e,
1021		0x9d, 0x91, 0xad, 0xda, 0x13, 0x0a, 0x16, 0x86, 0x41, 0x18, 0x08, 0x01, 0xEF, 0x97, 0x11, 0x1f,
1022		0x1a, 0xe7, 0x0c, 0xc9, 0x6f, 0x9d, 0xb9, 0x49, 0x0b, 0x6b, 0x9e, 0xd4, 0x72, 0x4d, 0x1d, 0x59
1023		};
1024
1025		static void gonefsh2_decrypt(running_machine &machine)
1026		{
1027		int i;
1028		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
1029
1030		int rom_size = 0x80000;
1031
1032		for(i=0; i<rom_size/2; i++) {
1033		UINT16 x = src[i];
1034
1035		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
1036		if ((i & 0x004008) == 0x004008) x ^= 0x0002;
1037		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
1038		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
1039		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
1040		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
1041		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1042		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
1043
1044		x ^= gonefsh2_tab[(i>> 1) & 0xff] << 8;
1045
1046		src[i] = x;
1047		}
1048		}
1049
1050		static const UINT8 sddz_tab[0x100] = {
1051		0xd7, 0x5f, 0xc8, 0x5b, 0xbf, 0xfa, 0x61, 0x0c, 0xdd, 0xab, 0xc3, 0x26, 0x3b, 0xd8, 0xbc, 0x1e,
1052		0xa6, 0x4b, 0xcf, 0xdc, 0x12, 0x61, 0x70, 0xd2, 0x76, 0xef, 0x44, 0xe8, 0x9a, 0x65, 0xf5, 0x13,
1053		0xb3, 0x1e, 0xcd, 0x00, 0xdf, 0x30, 0xa7, 0x9d, 0xb7, 0x49, 0xdf, 0xf6, 0xa7, 0x0b, 0x1a, 0x58,
1054		0x2a, 0xea, 0x0e, 0x92, 0x39, 0x96, 0x25, 0x5d, 0x1b, 0xda, 0x27, 0x63, 0x4f, 0xe0, 0xda, 0x04,
1055		0x7e, 0x10, 0x16, 0xbc, 0xff, 0x52, 0x73, 0x4a, 0x82, 0xd4, 0xba, 0xd8, 0x13, 0xb3, 0xe9, 0xfd,
1056		0x9a, 0x6c, 0x6c, 0xd6, 0xef, 0x63, 0x9d, 0xa2, 0xf6, 0x26, 0x94, 0x55, 0x25, 0x93, 0x21, 0x26,
1057		0x2a, 0xbf, 0x4b, 0xc8, 0x22, 0x18, 0x2d, 0x5d, 0xb6, 0x02, 0xba, 0x70, 0xcd, 0xae, 0xd5, 0xed,
1058		0x5f, 0x48, 0xca, 0xd5, 0x3d, 0x41, 0xd0, 0xee, 0xd7, 0xd9, 0xba, 0x01, 0x6c, 0x34, 0x58, 0x33,
1059		0xde, 0x44, 0x6d, 0xee, 0x95, 0x5c, 0x0f, 0x97, 0x98, 0xdc, 0xf0, 0x76, 0xc5, 0x73, 0x46, 0x51,
1060		0x1c, 0xe5, 0xe0, 0xda, 0x4b, 0x38, 0xb6, 0x08, 0x20, 0xfd, 0xa2, 0xbc, 0x0e, 0xcc, 0xa9, 0xac,
1061		0x84, 0xb8, 0x42, 0x5c, 0x5b, 0x14, 0x4f, 0xc3, 0xb0, 0x2b, 0xbd, 0x68, 0x42, 0xbc, 0x9c, 0x01,
1062		0x7e, 0xec, 0xd6, 0x3b, 0x20, 0x10, 0x07, 0x78, 0xdf, 0x18, 0xa5, 0xa2, 0x15, 0xa2, 0x7a, 0xa0,
1063		0x7c, 0xf1, 0xcb, 0x1a, 0x7d, 0x69, 0x47, 0xe9, 0xd9, 0xf6, 0xf7, 0x78, 0x41, 0x8f, 0x0f, 0x24,
1064		0xed, 0xb5, 0x04, 0x39, 0x09, 0xf0, 0x7b, 0x06, 0x14, 0xb4, 0xc1, 0xe2, 0xc5, 0xa0, 0x2d, 0x75,
1065		0xb9, 0xb7, 0xa8, 0x81, 0x03, 0x13, 0xce, 0x0e, 0x47, 0x45, 0x0f, 0xfe, 0xe5, 0x24, 0xf7, 0x77,
1066		0x4c, 0x87, 0xd2, 0x04, 0xe9, 0xc1, 0xea, 0x7b, 0xbe, 0x58, 0x4f, 0x35, 0x27, 0xfc, 0xf1, 0x11
1067		};
1068
1069		static void sddz_decrypt(running_machine &machine)
1070		{
1071		int i;
1072		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
1073
1074		int rom_size = 0x80000;
1075
1076		for(i=0; i<rom_size/2; i++) {
1077		UINT16 x = src[i];
1078
1079		if ((i & 0x040080) != 0x000080) x ^= 0x0001;
1080		if ((i & 0x004008) == 0x004008) x ^= 0x0002;
1081		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
1082		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
1083		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
1084		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
1085		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1086		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
1087
1088		x ^= sddz_tab[(i>> 1) & 0xff] << 8;
1089
1090		src[i] = x;
1091		}
1092		}
1093
1094		static const UINT8 lhzb3_tab[0x100] = {
1095		0x13, 0x45, 0x21, 0xA1, 0x69, 0x9A, 0x05, 0xDA, 0x7D, 0x10, 0xDA, 0x7F, 0x34, 0x9F, 0xF3, 0x64,
1096		0x35, 0xF9, 0x16, 0x1C, 0xD4, 0x60, 0x02, 0xF3, 0x42, 0xC7, 0x42, 0x29, 0xF3, 0x2C, 0x31, 0x71,
1097		0x50, 0x35, 0x4E, 0xAA, 0x9F, 0x09, 0xC3, 0xDD, 0x2F, 0x72, 0x30, 0x77, 0xC7, 0x30, 0xBC, 0xC8,
1098		0x51, 0xA0, 0x5E, 0xBB, 0xC3, 0x8E, 0x69, 0xD7, 0x4F, 0x57, 0x56, 0x77, 0xCB, 0x43, 0xD6, 0x46,
1099		0x62, 0x21, 0x18, 0xFD, 0x7D, 0x24, 0x58, 0x61, 0xEC, 0xFE, 0xA9, 0x77, 0x59, 0x3B, 0x03, 0x0A,
1100		0xEF, 0xDF, 0x90, 0x60, 0x46, 0x43, 0x33, 0x38, 0x92, 0x2D, 0x5A, 0x08, 0x0D, 0x2F, 0x05, 0x75,
1101		0x3E, 0x60, 0x87, 0x22, 0xB7, 0xBF, 0xD6, 0xF9, 0x17, 0x86, 0xEA, 0x02, 0xBE, 0x23, 0xBA, 0xD3,
1102		0xDD, 0x0D, 0x3E, 0x8C, 0x65, 0xA0, 0xF8, 0xD8, 0x2F, 0x35, 0xC6, 0x26, 0x6C, 0x81, 0xE6, 0x29,
1103		0x50, 0x30, 0x4A, 0x8E, 0xFA, 0xC2, 0x1E, 0xFD, 0xA7, 0xA5, 0x98, 0x53, 0x18, 0x94, 0xFF, 0x1D,
1104		0x41, 0x2F, 0xFF, 0x58, 0x33, 0xDC, 0x2B, 0x67, 0x4B, 0xDD, 0xD3, 0x56, 0x9C, 0xB2, 0x09, 0x4E,
1105		0x9B, 0xB1, 0xEE, 0x58, 0x0A, 0xE4, 0x42, 0x56, 0x26, 0x23, 0x2C, 0x3F, 0x14, 0x73, 0x46, 0x9A,
1106		0xA1, 0x42, 0x17, 0x12, 0xDB, 0xA2, 0xDD, 0x5D, 0x0C, 0xEC, 0xDC, 0xF7, 0xC1, 0x76, 0xE0, 0x24,
1107		0x65, 0xEF, 0x41, 0x83, 0x35, 0x38, 0x78, 0x0E, 0x65, 0x82, 0xE3, 0x55, 0x90, 0xA8, 0xD5, 0xF7,
1108		0x66, 0xCF, 0xE2, 0x61, 0x91, 0x3C, 0x69, 0xCB, 0xE7, 0x75, 0x62, 0x6F, 0xD7, 0x9B, 0x69, 0x0C,
1109		0x0D, 0x07, 0x0C, 0x9C, 0x68, 0x24, 0x51, 0x51, 0x1F, 0x8D, 0x8B, 0xD6, 0x2E, 0x67, 0x5F, 0xC3,
1110		0x07, 0x00, 0x12, 0x61, 0x77, 0xA8, 0x15, 0xA1, 0xD6, 0xD0, 0xD3, 0x57, 0x73, 0x62, 0xB9, 0xBB
1111		};
1112
1113		static void lhzb3_decrypt(running_machine &machine)
1114		{
1115		int i;
1116		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
1117
1118		int rom_size = 0x80000;
1119
1120		for(i=0; i<rom_size/2; i++) {
1121		UINT16 x = src[i];
1122
1123		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
1124		if ((i & 0x004008) == 0x004008) x ^= 0x0002;
1125		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
1126		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
1127		if ((i & 0x008100) == 0x008000) x ^= 0x0010;
1128		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
1129		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1130		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
1131
1132		x ^= lhzb3_tab[(i>> 1) & 0xff] << 8;
1133
1134		src[i] = x;
1135		}
1136		}
1137
1138		static const UINT8 mgfx_tab[0x100] = {
1139		0x49, 0x47, 0x53, 0x30, 0x30, 0x38, 0x33, 0x52, 0x44, 0x34, 0x30, 0x32, 0x31, 0x32, 0x31, 0x32,
1140		0x82, 0x6B, 0xCA, 0xBE, 0x9B, 0x9F, 0xC3, 0xA5, 0x8F, 0x2A, 0x9F, 0x0E, 0x26, 0x28, 0x4A, 0x9D,
1141		0xA2, 0x57, 0xFC, 0x43, 0xF3, 0x34, 0x05, 0x72, 0x1E, 0x59, 0xD9, 0xA0, 0xE7, 0x16, 0x5B, 0xFF,
1142		0xC6, 0x4F, 0x6E, 0x7A, 0x09, 0x96, 0xBA, 0xF3, 0x46, 0x89, 0xBB, 0xBC, 0x04, 0x6D, 0x11, 0x54,
1143		0xA9, 0x0B, 0x03, 0x63, 0xA6, 0xCB, 0x54, 0xF7, 0xE2, 0x0F, 0x4B, 0x01, 0x65, 0xD3, 0xFD, 0x0B,
1144		0x46, 0x82, 0xDE, 0x3C, 0xD7, 0x1B, 0x87, 0x8E, 0x0E, 0x84, 0xCA, 0x4D, 0x37, 0x2E, 0xF4, 0xD4,
1145		0xD8, 0xEB, 0x61, 0x84, 0xE5, 0x0C, 0x46, 0x05, 0x25, 0xBF, 0xBB, 0xC0, 0xE4, 0xA7, 0x07, 0x9D,
1146		0xDA, 0xBD, 0x31, 0xFA, 0x5B, 0x66, 0xC3, 0xEC, 0xC1, 0xD5, 0xE1, 0xB9, 0x17, 0xA4, 0x8B, 0x96,
1147		0x07, 0xAE, 0x2F, 0x9D, 0x06, 0x30, 0x73, 0x12, 0xBE, 0x1F, 0x40, 0xD7, 0xBB, 0xCC, 0x12, 0x2D,
1148		0x5A, 0xB6, 0x7F, 0xAD, 0xEF, 0xB0, 0x06, 0x86, 0x36, 0x34, 0x1A, 0xF8, 0xFC, 0x06, 0x6F, 0x11,
1149		0x0E, 0x0C, 0x84, 0xA7, 0x62, 0x6D, 0x71, 0x97, 0x84, 0xE9, 0xF3, 0x3C, 0x44, 0x79, 0xB5, 0x32,
1150		0x9E, 0x27, 0xE1, 0x4C, 0xEA, 0x30, 0xE7, 0xD4, 0x45, 0x57, 0x8D, 0x02, 0x3E, 0x8C, 0x38, 0xBF,
1151		0xC5, 0xBE, 0x79, 0x9B, 0x51, 0xFD, 0xDB, 0x0B, 0x51, 0xD5, 0xEC, 0xE8, 0xD6, 0xE6, 0x89, 0x26,
1152		0x7E, 0xC8, 0x6F, 0xD1, 0xA4, 0x1E, 0xFF, 0x4D, 0xC5, 0xF8, 0x51, 0xCE, 0x36, 0x6F, 0x7D, 0x16,
1153		0x04, 0x7B, 0x26, 0x6F, 0x2C, 0x18, 0x47, 0xE8, 0xFC, 0x99, 0x42, 0xD3, 0xC9, 0x4C, 0x26, 0x7F,
1154		0xD2, 0x4F, 0x40, 0x32, 0x74, 0xB2, 0xE6, 0x6B, 0x90, 0xCF, 0x7F, 0x56, 0x3A, 0xE5, 0xD7, 0x8F
1155		};
1156
1157		static void mgfx_decrypt(running_machine &machine)
1158		{
1159		int i;
1160		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
1161
1162		int rom_size = 0x80000;
1163
1164		for(i=0; i<rom_size/2; i++) {
1165		UINT16 x = src[i];
1166
1167		if ((i & 0x040080) != 0x000080) x ^= 0x0001;
1168		//  if ((i & 0x084008) == 0x084008) x ^= 0x0002;
1169		if ((i & 0x000030) == 0x000010) x ^= 0x0004;
1170		if ((i & 0x000242) != 0x000042) x ^= 0x0008;
1171		//  if ((i & 0x048100) == 0x048000) x ^= 0x0010;
1172		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
1173		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1174		if ((i & 0x004820) == 0x004820) x ^= 0x0080;
1175
1176		x ^= mgfx_tab[(i>> 1) & 0xff] << 8;
1177
1178		src[i] = x;
1179		}
1180		}
1181
1182		static const UINT8 lhzb4_tab[0x100] = {
1183		0x49, 0x47, 0x53, 0x30, 0x31, 0x36, 0x39, 0x52, 0x44, 0x32, 0x30, 0x34, 0x30, 0x37, 0x33, 0x30,
1184		0x87, 0xA5, 0x22, 0x6E, 0x2F, 0x89, 0xC6, 0x3B, 0xF3, 0x4D, 0x29, 0xD5, 0x46, 0x17, 0x9C, 0x38,
1185		0xC2, 0xE4, 0x16, 0x4B, 0x36, 0xFD, 0xE0, 0x7F, 0xF2, 0xBE, 0x83, 0xA6, 0x52, 0x87, 0xF2, 0x11,
1186		0x88, 0x03, 0xF4, 0xEE, 0xAF, 0x98, 0xD5, 0xE0, 0x0E, 0x2F, 0x4D, 0xDF, 0xA9, 0x26, 0xB1, 0x53,
1187		0x0E, 0x92, 0x58, 0x6C, 0x5E, 0xB9, 0x50, 0xC5, 0x99, 0xCF, 0x42, 0x39, 0x2F, 0xF1, 0xA3, 0x04,
1188		0xC5, 0x60, 0x1D, 0x1E, 0x44, 0xFF, 0x3D, 0xD5, 0x28, 0x0E, 0x5D, 0xA9, 0x08, 0x29, 0xD4, 0x6C,
1189		0x61, 0x7C, 0x5D, 0x9B, 0xA7, 0x48, 0xC5, 0xF7, 0x8E, 0x9B, 0xD9, 0x67, 0x95, 0x4B, 0x8F, 0x12,
1190		0xD4, 0x35, 0x74, 0xB8, 0x07, 0xB4, 0x55, 0x52, 0xDC, 0x64, 0x32, 0xEA, 0x7A, 0x18, 0x5F, 0xBC,
1191		0x52, 0x19, 0xFC, 0x8E, 0x2A, 0xA2, 0x98, 0x4D, 0x66, 0x99, 0x21, 0xE9, 0x9A, 0x8E, 0x0F, 0x72,
1192		0x4D, 0xF9, 0xD1, 0x74, 0x10, 0xB0, 0x77, 0x8F, 0xC0, 0xA7, 0xA2, 0x5B, 0x17, 0xED, 0xA9, 0x7B,
1193		0x7A, 0xE3, 0x0D, 0xFF, 0xFE, 0xBE, 0x1F, 0xFF, 0xBB, 0x40, 0xF0, 0x76, 0x56, 0xB2, 0x79, 0x5D,
1194		0xC9, 0x26, 0x0C, 0x08, 0x76, 0xEB, 0xFA, 0xC5, 0x6C, 0x51, 0x86, 0xB2, 0xF9, 0x9E, 0x0A, 0xDF,
1195		0x70, 0x50, 0x68, 0xA5, 0x3C, 0x96, 0xB4, 0x46, 0x25, 0x09, 0x1F, 0xC6, 0xE2, 0xAF, 0x26, 0x09,
1196		0xE0, 0x32, 0xFD, 0x2E, 0x52, 0x5D, 0x36, 0x2B, 0x79, 0xD8, 0xB6, 0xA9, 0x35, 0x24, 0xDA, 0x22,
1197		0xCD, 0xDA, 0xE5, 0x39, 0xFB, 0x20, 0xAD, 0x59, 0x3C, 0x6C, 0x86, 0x92, 0x56, 0x7D, 0x6F, 0xB0,
1198		0x29, 0x96, 0x7C, 0x9D, 0xBB, 0xFD, 0x83, 0xF9, 0x7F, 0xB5, 0x0A, 0xF8, 0xE6, 0x77, 0x71, 0x7B
1199		};
1200
1201		static void lhzb4_decrypt(running_machine &machine)
1202		{
1203		int i;
1204		UINT16 *src = (UINT16 *) machine.root_device().memregion("user1")->base();
1205
1206		int rom_size = 0x80000;
1207
1208		for(i=0; i<rom_size/2; i++) {
1209		UINT16 x = src[i];
1210
1211		if ((i & 0x040480) != 0x000080) x ^= 0x0001;
1212		//  if ((i & 0x084008) == 0x084008) x ^= 0x0002;
1213		//  if ((i & 0x080030) == 0x080010) x ^= 0x0004;
1214		if ((i & 0x000042) != 0x000042) x ^= 0x0008;
1215		//  if ((i & 0x048100) == 0x048000) x ^= 0x0010;
1216		if ((i & 0x022004) != 0x000004) x ^= 0x0020;
1217		if ((i & 0x011800) != 0x010000) x ^= 0x0040;
1218		if ((i & 0x000820) == 0x000820) x ^= 0x0080;
1219
1220		x ^= lhzb4_tab[(i>> 1) & 0xff] << 8;
1221
1222		src[i] = x;
1223		}
1224		}
1225
1226
1227	862	/*
1228	863	DRIVER_INIT_MEMBER(igs_m027_state,igs_m027)
1229	864	{
r18915	r18916
1259	894	pgm_create_dummy_internal_arm_region(machine());
1260	895	}
1261	896
	897	DRIVER_INIT_MEMBER(igs_m027_state,fearless)
	898	{
	899	fearless_decrypt(machine());
	900	//sdwx_gfx_decrypt(machine());
	901	pgm_create_dummy_internal_arm_region(machine());
	902	}
	903
	904
1262	905	DRIVER_INIT_MEMBER(igs_m027_state,lhzb4)
1263	906	{
1264	907	lhzb4_decrypt(machine());
r18915	r18916
1307	950
1308	951	***************************************************************************/
1309	952
1310		GAME( 2002,  sdwx,      0, igs_majhong, sdwx, igs_m027_state, sdwx,        ROT0, "IGS", "Sheng Dan Wu Xian", GAME_NO_SOUND | GAME_NOT_WORKING ) // aka Christmas 5 Line?
1311		GAME( 200?,  sddz,      0, igs_majhong, sdwx, igs_m027_state, sddz,        ROT0, "IGS", "Super Dou Di Zhu",  GAME_NO_SOUND | GAME_NOT_WORKING )
1312		GAME( 2000,  bigd2,      0, igs_majhong, sdwx, igs_m027_state, bigd2,       ROT0, "IGS", "Big D2",  GAME_NO_SOUND | GAME_NOT_WORKING )
1313		GAME( 200?,  lhzb3,      0, igs_majhong, sdwx, igs_m027_state, lhzb3,       ROT0, "IGS", "Long Hu Zheng Ba 3", GAME_NO_SOUND | GAME_NOT_WORKING )
1314		GAME( 200?,  lhzb4,      0, igs_majhong, sdwx, igs_m027_state, lhzb4,       ROT0, "IGS", "Long Hu Zheng Ba 4", GAME_NO_SOUND | GAME_NOT_WORKING )
1315		GAME( 200?,  klxyj,      0, igs_majhong, sdwx, igs_m027_state, klxyj,       ROT0, "IGS", "Kuai Le Xi You Ji",  GAME_NO_SOUND | GAME_NOT_WORKING )
1316		GAME( 2000,  mgfx,      0, igs_majhong, sdwx, igs_m027_state, mgfx,        ROT0, "IGS", "Man Guan Fu Xing",   GAME_NO_SOUND | GAME_NOT_WORKING )
1317		GAME( 200?,  gonefsh2,   0, igs_majhong, sdwx, igs_m027_state, gonefsh2,    ROT0, "IGS", "Gone Fishing 2",   GAME_NO_SOUND | GAME_NOT_WORKING )
1318		GAME( 200?,  chessc2,   0, igs_majhong, sdwx, igs_m027_state, chessc2,     ROT0, "IGS", "Chess Challenge 2",   GAME_NO_SOUND | GAME_NOT_WORKING )
1319		GAME( 200?,  haunthig,   0, igs_majhong, sdwx, igs_m027_state, hauntedh,    ROT0, "IGS", "Haunted House (IGS)",   GAME_NO_SOUND | GAME_NOT_WORKING )
	953	GAME( 2002,  sdwx,      0, igs_majhong, sdwx, igs_m027_state, sdwx,        ROT0, "IGS", "Sheng Dan Wu Xian", GAME_IS_SKELETON ) // aka Christmas 5 Line?
	954	GAME( 200?,  sddz,      0, igs_majhong, sdwx, igs_m027_state, sddz,        ROT0, "IGS", "Super Dou Di Zhu",  GAME_IS_SKELETON )
	955	GAME( 2000,  bigd2,      0, igs_majhong, sdwx, igs_m027_state, bigd2,       ROT0, "IGS", "Big D2",  GAME_IS_SKELETON )
	956	GAME( 200?,  lhzb3,      0, igs_majhong, sdwx, igs_m027_state, lhzb3,       ROT0, "IGS", "Long Hu Zheng Ba 3", GAME_IS_SKELETON )
	957	GAME( 200?,  lhzb4,      0, igs_majhong, sdwx, igs_m027_state, lhzb4,       ROT0, "IGS", "Long Hu Zheng Ba 4", GAME_IS_SKELETON )
	958	GAME( 200?,  klxyj,      0, igs_majhong, sdwx, igs_m027_state, klxyj,       ROT0, "IGS", "Kuai Le Xi You Ji",  GAME_IS_SKELETON )
	959	GAME( 2000,  mgfx,      0, igs_majhong, sdwx, igs_m027_state, mgfx,        ROT0, "IGS", "Man Guan Fu Xing",   GAME_IS_SKELETON )
	960	GAME( 200?,  gonefsh2,   0, igs_majhong, sdwx, igs_m027_state, gonefsh2,    ROT0, "IGS", "Gone Fishing 2",   GAME_IS_SKELETON )
	961	GAME( 200?,  chessc2,   0, igs_majhong, sdwx, igs_m027_state, chessc2,     ROT0, "IGS", "Chess Challenge 2",   GAME_IS_SKELETON )
	962	GAME( 200?,  haunthig,   0, igs_majhong, sdwx, igs_m027_state, hauntedh,    ROT0, "IGS", "Haunted House (IGS)",   GAME_IS_SKELETON )
	963	GAME( 2006,  fearless,   0, fearless,    sdwx, igs_m027_state, fearless,    ROT0, "IGS", "Fearless Pinocchio (V101US)",   GAME_IS_SKELETON )

trunk/src/mame/drivers/pgm.c

r18915	r18916
1982	1982	ROM_START( puzlstar )
1983	1983	ROM_REGION( 0x600000, "maincpu", 0 ) /* 68000 Code */
1984	1984	PGM_68K_BIOS
1985		ROM_LOAD16_BYTE( "v100mg.u1",     0x100001, 0x080000, CRC(5788b77d) SHA1(7770aae6e686da92b2623c977d1bc8f019f48267) )
1986		ROM_LOAD16_BYTE( "v100mg.u2",     0x100000, 0x080000, CRC(4c79d979) SHA1(3b92052a35994f2b3dd164930154184c45d5e2d0) )
	1985	ROM_LOAD16_BYTE( "v100mg.u1",     0x100000, 0x080000, CRC(5788b77d) SHA1(7770aae6e686da92b2623c977d1bc8f019f48267) )
	1986	ROM_LOAD16_BYTE( "v100mg.u2",     0x100001, 0x080000, CRC(4c79d979) SHA1(3b92052a35994f2b3dd164930154184c45d5e2d0) )
1987	1987
1988	1988	ROM_REGION( 0x4000, "prot", 0 ) /* ARM protection ASIC - internal rom */
1989	1989	ROM_LOAD( "puzlstar_igs027a.bin", 0x000000, 0x04000, NO_DUMP )
r18915	r18916
2665	2665	ROM_START( puzzli2 )
2666	2666	ROM_REGION( 0x600000, "maincpu", 0 ) /* 68000 Code */
2667	2667	PGM_68K_BIOS
2668		ROM_LOAD( "v100.u5",     0x100000, 0x200000, CRC(1abb4595) SHA1(860bb49efc3cb55b6b9846f5ab787d6fd586432d) )
	2668	ROM_LOAD16_WORD_SWAP( "v100.u5",     0x100000, 0x200000, CRC(1abb4595) SHA1(860bb49efc3cb55b6b9846f5ab787d6fd586432d) )
2669	2669
2670	2670	ROM_REGION( 0x4000, "prot", ROMREGION_ERASEFF ) /* ARM protection ASIC - internal rom */
2671	2671	ROM_LOAD( "puzzli2_igs027a.bin", 0x000000, 0x04000, NO_DUMP )
r18915	r18916
2690	2690	ROM_START( puzzli2s )
2691	2691	ROM_REGION( 0x600000, "maincpu", 0 ) /* 68000 Code */
2692	2692	PGM_68K_BIOS
2693		ROM_LOAD16_BYTE( "2sp_v200.u3",     0x100001, 0x080000, CRC(2a5ba8a6) SHA1(4c87b849fd6f39152e3e2ef699b78ce24b3fb6d0) )
2694		ROM_LOAD16_BYTE( "2sp_v200.u4",     0x100000, 0x080000, CRC(fa5c86c1) SHA1(11c219722b891b775c0f7f9bc8276cdd8f74d657) )
	2693	ROM_LOAD16_BYTE( "2sp_v200.u3",     0x100000, 0x080000, CRC(2a5ba8a6) SHA1(4c87b849fd6f39152e3e2ef699b78ce24b3fb6d0) )
	2694	ROM_LOAD16_BYTE( "2sp_v200.u4",     0x100001, 0x080000, CRC(fa5c86c1) SHA1(11c219722b891b775c0f7f9bc8276cdd8f74d657) )
2695	2695
2696	2696	ROM_REGION( 0x4000, "prot", ROMREGION_ERASEFF ) /* ARM protection ASIC - internal rom */
2697	2697	ROM_LOAD( "puzzli2_igs027a.bin", 0x000000, 0x04000, NO_DUMP )

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team