WebSVN – Kolibri OS – Blame – /drivers/devman/acpica/tests/misc/grammar.asl

Rev	Author	Line No.	Line
1498	serge	1	/*
2216	Serge	2	* Some or all of this work - Copyright (c) 2006 - 2011, Intel Corp.
1498	serge	3	* All rights reserved.
		4	*
		5	* Redistribution and use in source and binary forms, with or without modification,
		6	* are permitted provided that the following conditions are met:
		7	*
		8	* Redistributions of source code must retain the above copyright notice,
		9	* this list of conditions and the following disclaimer.
		10	* Redistributions in binary form must reproduce the above copyright notice,
		11	* this list of conditions and the following disclaimer in the documentation
		12	* and/or other materials provided with the distribution.
		13	* Neither the name of Intel Corporation nor the names of its contributors
		14	* may be used to endorse or promote products derived from this software
		15	* without specific prior written permission.
		16	*
		17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		18	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		20	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
		21	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
		23	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		25	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
		26	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*/
		28
		29	//
		30	//
		31	// Grammar.asl - Minimally excercises most ASL constructs
		32	//
		33	// NOTE -- use: iasl -f -of grammar.asl to compile
		34	//
		35	// This 1) Ignores errors (checks compiler error handling)
		36	// 2) Disables constant folding
		37	//
		38	//
		39
		40	/*******************************************************************************
		41	Compilation should look like this:
		42
		43	C:\acpica\tests\misc>iasl -f -of grammar.asl
		44
		45	Intel ACPI Component Architecture
		46	ASL Optimizing Compiler version 20090422 [Apr 22 2009]
		47	Copyright (C) 2000 - 2009 Intel Corporation
		48	Supports ACPI Specification Revision 3.0a
		49
		50	grammar.asl 187: Name (_NPK, Package (8)
		51	Warning 1098 - ^ Unknown reserved name (_NPK)
		52
		53	grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn")
		54	Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
		55
		56	grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn")
		57	Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
		58
		59	grammar.asl 601: Method (RCIV, 1)
		60	Warning 1087 - ^ Not all control paths return a value (RCIV)
		61
		62	grammar.asl 608: RCIV (Subtract (Arg0, 1))
		63	Remark 5073 - ^ Recursive method call (RCIV)
		64
		65	grammar.asl 937: Method (_ERR, 2)
		66	Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3)
		67
		68	grammar.asl 1377: Store (0x1234567887654321, QWD2)
		69	Warning 1032 - ^ 64-bit integer in 32-bit table, truncating
		70
		71	grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321))
		72	Warning 1032 - 64-bit integer in 32-bit table, truncating ^
		73
		74	grammar.asl 1459: SizeOf (BUFO)
		75	Warning 1105 - ^ Result is not used, operator has no effect
		76
		77	grammar.asl 1485: Acquire (MTX2, 1)
		78	Warning 1104 - ^ Possible operator timeout is ignored
		79
		80	grammar.asl 1633: Add (Local0, Local1)
		81	Warning 1105 - ^ Result is not used, operator has no effect
		82
		83	grammar.asl 1804: Method (COND)
		84	Warning 1087 - ^ Not all control paths return a value (COND)
		85
		86	grammar.asl 6010: Name (_HID, "*PNP0A06")
		87	Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06)
		88
		89	grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
		90	Warning 1038 - Invalid or unknown escape sequence ^
		91
		92	grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1
		93	Error 4050 - ^ Method local variable is not initialized (Local0)
		94
		95	grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID
		96	Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A)
		97
		98	ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
		99	AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
		100
		101	Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
		102
		103	***************************************************************************************************/
		104
		105	DefinitionBlock (
		106	"grammar.aml", //Output filename
		107	"DSDT", //Signature
		108	0x01, //DSDT Revision ---> 32-bit table
		109	"Intel", //OEMID
		110	"GRMTEST", //TABLE ID
		111	0x20090511 //OEM Revision
		112	)
		113	{
		114
		115	External (\ABCD, UnknownObj)
		116
		117
		118	/* Device with _STA and _INI */
		119
		120	Device (A1)
		121	{
		122	Method (_STA)
		123	{
		124	Return (0x0F)
		125	}
		126
		127	Method (_INI)
		128	{
		129	Return
		130	}
		131	}
		132
		133	/* Device with no _STA, has _INI */
		134
		135	Device (A2)
		136	{
		137	Method (_INI)
		138	{
		139	Return
		140	}
		141	}
		142
		143	/* Device with _STA, no _INI */
		144
		145	Device (A3)
		146	{
		147	Method (_STA)
		148	{
		149	Return (0x0F)
		150	}
		151	}
		152
		153	/* Device with _STA and _INI, but not present */
		154
		155	Device (A4)
		156	{
		157	Method (_STA)
		158	{
		159	Return (Zero)
		160	}
		161
		162	Method (_INI)
		163	{
		164	Return
		165	}
		166	}
		167
		168
		169	/* Resource descriptors */
		170
		171	Device (IRES)
		172	{
		173	Name (PRT0, ResourceTemplate ()
		174	{
		175	IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
		176
		177	StartDependentFn (1,1)
		178	{
		179	IRQNoFlags () {0,1,2}
		180	}
		181	EndDependentFn ()
		182	})
		183
		184	Method (_CRS, 0, NotSerialized)
		185	{
		186	Store ("_CRS:", Debug)
		187	Store (PRT0, Debug)
		188	Return (PRT0)
		189	}
		190
		191	Method (_SRS, 1, Serialized)
		192	{
		193	Store ("_SRS:", Debug)
		194	Store (Arg0, Debug)
		195	Return (Zero)
		196	}
		197	}
		198
		199	Name (_NPK, Package ()
		200	{
		201	0x1111,
		202	0x2222,
		203	0x3333,
		204	0x4444
		205	})
		206
		207
		208	Device (RES)
		209	{
		210	Name (_PRT, Package (0x04)
		211	{
		212	Package (0x04)
		213	{
		214	0x0002FFFF,
		215	Zero,
		216	Zero,
		217	Zero
		218	},
		219
		220	Package (0x04)
		221	{
		222	0x0002FFFF,
		223	One,
		224	Zero,
		225	Zero
		226	},
		227
		228	Package (0x04)
		229	{
		230	0x000AFFFF,
		231	Zero,
		232	Zero,
		233	Zero
		234	},
		235
		236	Package (0x04)
		237	{
		238	0x000BFFFF,
		239	Zero,
		240	Zero,
		241	Zero
		242	}
		243	})
		244
		245	Method (_CRS, 0, NotSerialized)
		246	{
		247	Name (PRT0, ResourceTemplate ()
		248	{
		249	WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
		250	0x0000, // Address Space Granularity
		251	0xFFF2, // Address Range Minimum
		252	0xFFF3, // Address Range Maximum
		253	0x0032, // Address Translation Offset
		254	0x0002,,,)
		255	WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
		256	0x0000, // Address Space Granularity
		257	0x0000, // Address Range Minimum
		258	0x00FF, // Address Range Maximum
		259	0x0000, // Address Translation Offset
		260	0x0100,,,)
		261	WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
		262	0x0000, // Address Space Granularity
		263	0xA000, // Address Range Minimum
		264	0xBFFF, // Address Range Maximum
		265	0x0000, // Address Translation Offset
		266	0x2000,,,)
		267	IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)
		268	WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		269	0x0000, // Address Space Granularity
		270	0x0000, // Address Range Minimum
		271	0x0CF7, // Address Range Maximum
		272	0x0000, // Address Translation Offset
		273	0x0CF8,,,
		274	, TypeStatic)
		275	WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		276	0x0000, // Address Space Granularity
		277	0x0D00, // Address Range Minimum
		278	0xFFFF, // Address Range Maximum
		279	0x0000, // Address Translation Offset
		280	0xF300,,,
		281	, TypeStatic)
		282	DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		283	0x00000000, // Address Space Granularity
		284	0x00000000, // Address Range Minimum
		285	0x00000CF7, // Address Range Maximum
		286	0x00000000, // Address Translation Offset
		287	0x00000CF8,,,
		288	, TypeStatic)
		289	DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
		290	0x00000000, // Address Space Granularity
		291	0x000C8000, // Address Range Minimum
		292	0x000EFFFF, // Address Range Maximum
		293	0x00000000, // Address Translation Offset
		294	0x00028000,,,
		295	, AddressRangeMemory, TypeStatic)
		296	DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
		297	0x00000000, // Address Space Granularity
		298	0x000C8000, // Address Range Minimum
		299	0x000EFFFF, // Address Range Maximum
		300	0x00000000, // Address Translation Offset
		301	0x00028000,,,)
		302	QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		303	0x0000000000000000, // Address Space Granularity
		304	0x0000000000000000, // Address Range Minimum
		305	0x0000000000000CF7, // Address Range Maximum
		306	0x0000000000000000, // Address Translation Offset
		307	0x0000000000000CF8, 0x44, "This is a ResouceSource string",
		308	, TypeStatic)
		309	QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		310	0x0000000000000000, // Address Space Granularity
		311	0x0000000000000000, // Address Range Minimum
		312	0x0000000000000CF7, // Address Range Maximum
		313	0x0000000000000000, // Address Translation Offset
		314	0x0000000000000CF8,,,
		315	, TypeStatic)
		316	QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
		317	0x0000000000000000, // Address Space Granularity
		318	0x0000000000100000, // Address Range Minimum
		319	0x00000000FFDFFFFF, // Address Range Maximum
		320	0x0000000000000000, // Address Translation Offset
		321	0x00000000FFD00000,,,
		322	, AddressRangeMemory, TypeStatic)
		323	QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
		324	0x0000000000000000, // Address Space Granularity
		325	0x0000000000000000, // Address Range Minimum
		326	0x0000000000000CF7, // Address Range Maximum
		327	0x0000000000000000, // Address Translation Offset
		328	0x0000000000000CF8,,,)
		329	ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		330	0x0000000000000000, // Address Space Granularity
		331	0x0000000000000000, // Address Range Minimum
		332	0x0000000000000CF7, // Address Range Maximum
		333	0x0000000000000000, // Address Translation Offset
		334	0x0000000000000CF8, // Address Length
		335	0x0000000000000000, // Type Specific Attributes
		336	, TypeStatic)
		337	ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
		338	0x0000000000000000, // Address Space Granularity
		339	0x0000000000100000, // Address Range Minimum
		340	0x00000000FFDFFFFF, // Address Range Maximum
		341	0x0000000000000000, // Address Translation Offset
		342	0x00000000FFD00000, // Address Length
		343	0x0000000000000000, // Type Specific Attributes
		344	, AddressRangeMemory, TypeStatic)
		345	ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
		346	0x0000000000000000, // Address Space Granularity
		347	0x0000000000100000, // Address Range Minimum
		348	0x00000000FFDFFFFF, // Address Range Maximum
		349	0x0000000000000000, // Address Translation Offset
		350	0x00000000FFD00000, // Address Length
		351	0x0000000000000000) // Type Specific Attributes
		352	IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)
		353	IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)
		354	FixedIO (0x0061, 0x01)
		355	IRQNoFlags () {2}
		356	DMA (Compatibility, BusMaster, Transfer8_16) {4}
		357	DMA (Compatibility, BusMaster, Transfer8) {2,5,7}
		358	Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
		359	Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
		360	Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)
		361	Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)
		362	Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")
		363	{
		364	0x00000E01,
		365	}
		366	Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
		367	{
		368	0x00000601,
		369	0x00000003,
		370	0x00000002,
		371	0x00000001,
		372	}
		373	Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
		374	{
		375	0xFFFF0000,
		376	0x00000003,
		377	0x00000002,
		378	0x00000001,
		379	0x00000005,
		380	0x00000007,
		381	0x00000009,
		382	}
		383	VendorShort () {0x01, 0x02, 0x03}
		384	VendorLong ()
		385	{
		386	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
		387	0x09
		388	}
		389	Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
		390	Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
		391	StartDependentFnNoPri ()
		392	{
		393	IRQNoFlags () {0,1,2}
		394	IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
		395	}
		396	EndDependentFn ()
		397	})
		398	CreateWordField (PRT0, 0x08, BMIN)
		399	CreateByteField (PRT0, R000._ASZ, RSIZ)
		400	Store (0x03, BMIN)
		401	Return (PRT0)
		402	}
		403
		404	Method (_PRS, 0, NotSerialized)
		405	{
		406	Name (BUF0, ResourceTemplate ()
		407	{
		408	StartDependentFn (0x01, 0x02)
		409	{
		410	IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
		411	IRQNoFlags () {4}
		412	}
		413	StartDependentFn (0x02, 0x01)
		414	{
		415	IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
		416	IRQNoFlags () {4}
		417	}
		418	StartDependentFn (0x00, 0x02)
		419	{
		420	IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
		421	IRQNoFlags () {3}
		422	}
		423	StartDependentFn (0x00, 0x02)
		424	{
		425	IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
		426	IRQNoFlags () {3}
		427	}
		428	StartDependentFn (0x02, 0x00)
		429	{
		430	IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
		431	IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
		432	}
		433	EndDependentFn ()
		434	})
		435	Return (BUF0)
		436	}
		437
		438	Method (_SRS, 1, Serialized)
		439	{
		440	Return (Zero)
		441	}
		442	}
		443
		444
		445	Name(\_S0,Package(0x04){
		446	0x00,
		447	0x00,
		448	0x00,
		449	0x00
		450	})
		451	Name(\_S3,Package(0x04){
		452	0x05,
		453	0x05,
		454	0x00,
		455	0x00
		456	})
		457	Name(\_S4,Package(0x04){
		458	0x06,
		459	0x06,
		460	0x00,
		461	0x00
		462	})
		463	Name(\_S5,Package(0x04){
		464	0x07,
		465	0x07,
		466	0x00,
		467	0x00
		468	})
		469
		470	/* Examine this table header (DSDT) */
		471
		472	/*
		473	DataTableRegion (HDR, "DSDT", "", "")
		474	Field (HDR, AnyAcc, NoLock, Preserve)
		475	{
		476	SIG, 32,
		477	LENG, 32,
		478	REV, 8,
		479	SUM, 8,
		480	OID, 48,
		481	OTID, 64,
		482	OREV, 32,
		483	CID, 32,
		484	CREV, 32
		485	}
		486
		487	Method (SIZE)
		488	{
		489	If (LLess (REV, 2))
		490	{
		491	Store ("32-bit table", Debug)
		492	}
		493	else
		494	{
		495	Store ("64-bit table", Debug)
		496	}
		497	Return (0)
		498	}
		499
		500	*/
		501	Name (SIZE, 0)
		502
		503	/* Custom operation region */
		504
		505	OperationRegion(MYOP,0x80,0xFD60,0x6)
		506	Field(MYOP,ByteAcc,NoLock,Preserve)
		507	{
		508	MFLD,8
		509	}
		510
		511	Method (TCOP)
		512	{
		513	Name (_STR, Unicode ("test"))
		514	Store (4, MFLD)
		515	Store (MFLD, Local0)
		516	}
		517
		518	Name (ERRS, 0x0)
		519
		520	/* Warning should be issued for premature string termination */
		521
		522	NAME (ESC1, "abcdefg\x00hijklmn")
		523	NAME (ESC2, "abcdefg\000hijklmn")
		524	Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432")
		525
		526
		527	Name(CRSA,ResourceTemplate()
		528	{
		529	WORDBusNumber(ResourceProducer,MinFixed,MaxFixed,PosDecode,0x0000,0x0019,0x001D,0x0000,0x0005)
		530	WORDIO(ResourceProducer,MinFixed,MaxFixed,PosDecode,NonISAOnlyRanges,0x0000,0xC000,0xCFFF,0x0000,0x1000)
		531	DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
		532
		533	})
		534	Name(CRSB,ResourceTemplate()
		535	{
		536	DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
		537
		538	})
		539
		540	Name(CRSC,ResourceTemplate()
		541	{
		542	VendorShort () {0x1, 0x2, 0x3}
		543	})
		544	Name(CRSD,ResourceTemplate()
		545	{
		546	VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
		547	})
		548
		549	Name(CRSE,ResourceTemplate()
		550	{
		551	IRQNoFlags(){3,4,10,11}
		552	IRQNoFlags(xxxt){3,4,10,11}
		553	})
		554	Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){})
		555	Method(_CRS,0,NotSerialized)
		556	{
		557	Return(CRSR)
		558	}
		559
		560
		561	//
		562	// Unnamed scope
		563	//
		564	Scope (\)
		565	{
		566	Name(Bxxx,0xFFFFFFFF)
		567	}
		568
		569	Name (LANS, 0x0)
		570
		571	PowerResource(LANP,1,0)
		572	{
		573	Method(_STA){
		574	If(LEqual(And(LANS,0x30),0x30)){
		575	Return(One)
		576	} Else {
		577	Return(Zero)
		578	}
		579	}
		580	Method(_ON){
		581	If(LNot(_STA())){
		582	Store (0x30, LANS)
		583	}
		584	}
		585	Method(_OFF){
		586	If(_STA()){
		587	Store (0, LANS)
		588	}
		589	}
		590	}
		591
		592
		593	/* Can a method define another method? */
		594
		595	/**********************************
		596	Method (TASK, 2, SERIALIZED)
		597	{
		598	Sleep (100)
		599
		600	Method (TAS2)
		601	{
		602	Sleep (100)
		603	}
		604
		605	TAS2()
		606	Return
		607
		608	}
		609	************************************/
		610
		611	/* A recursive method */
		612
		613	Method (RCIV, 1)
		614	{
		615	Store (Arg0, Debug)
		616	If (Lequal (Arg0, 0))
		617	{
		618	Return ()
		619	}
		620	RCIV (Subtract (Arg0, 1))
		621	}
		622
		623	Method (RTOP)
		624	{
		625	RCIV (100)
		626	}
		627
		628
		629	Scope(\_PR)
		630	{
		631	Processor(CPU0,0x0,0xFFFFFFFF,0x0) {}
		632	}
		633
		634	Name(B1TP,0xFFFFFFFF)
		635
		636	Name(B2TP,0xFFFFFFFF)
		637	Name(ADPS,0xFFFFFFFF)
		638	Name(B1PS,0xFFFFFFFF)
		639	Name(B1RS,0xFFFFFFFF)
		640	Name(B1CS,0xFFFFFFFF)
		641	Name(B2PS,0xFFFFFFFF)
		642	Name(B2RS,0xFFFFFFFF)
		643	Name(B2CS,0xFFFFFFFF)
		644	Name(B1DC,3000)
		645	Name(B2DC,2600)
		646	Name(B1LF,3000)
		647	Name(B2LF,2600)
		648	Name(BPIF,0)
		649	Name(PBLL,0)
		650
		651	Name(RBIF,Package()
		652	{
		653	0x1,
		654	2200,
		655	2200,
		656	0x1,
		657	10800,
		658	0,
		659	0,
		660	1,
		661	1,
		662	"CA54200-5003/5",
		663	"1",
		664	"LION",
		665	"Fujitsu"
		666	})
		667
		668	Method(SMWE, 4)
		669	{
		670	return(ONES)
		671	}
		672
		673	Method(SMRE, 4)
		674	{
		675	return(ONES)
		676	}
		677
		678	/*
		679	Method(RDBT,0,Serialized){
		680	If(LNot(SMWE(0x09,0x15,1,1))){
		681	Store(0x18,Local2)
		682	}
		683	}
		684	*/
		685	Scope(_SB)
		686	{
		687
		688	Name (SBUF, Buffer (128) {})
		689
		690	CreateBitField (SBUF, 3, BITY)
		691	CreateByteField (SBUF, 1, BYTY)
		692	CreateWordField (SBUF, 2, WRDZ)
		693	CreateDwordField (SBUF, 4, DWDZ)
		694	CreateQwordField (SBUF, 8, QWDZ)
		695	CreateField (SBUF, 128, 12, FLDZ)
		696	CreateField (SBUF, 148, 96, FLDY)
		697	CreateField (SBUF, 148, 96, \_SB_.FLDW)
		698
		699	Method (_INI)
		700	{
		701	CreateField (\_SB_.SBUF, 148, 96, FLDV)
		702	}
		703
		704
		705	Device(PCI0)
		706	{
		707	Name(_HID,EISAID("PNP0A03"))
		708	Name(_ADR,0x0)
		709
		710	Method(_CRS)
		711	{
		712	Name(PRT0, ResourceTemplate() {
		713	WORDBusNumber( // Bus number resource(0)
		714	ResourceConsumer, // bit 0 of general flags is 1
		715	MinFixed, // Range is notfixed
		716	MaxFixed, // Range is not fixed
		717	SubDecode, // SubDecode
		718	0x0000, // Granularity
		719	0xfff1, // Min
		720	0xfff2, // Max
		721	0x0032, // Translation
		722	0x0002,,, // Range Length
		723	BUS0
		724	) } )// PRT0
		725
		726	CreateWordField(PRT0, BUS0._MIN, BMIN) //Minimum bus number suported under this bridge.
		727
		728	Store(3, BMIN)
		729	Return(PRT0)
		730
		731	} // _CRS
		732
		733	Method(_SRS)
		734	{
		735	Return ()
		736	}
		737
		738	Device(EIO)
		739	{
		740	OperationRegion(FJIO,SystemIO,0xFD60,0x6)
		741	Field(FJIO,ByteAcc,NoLock,Preserve)
		742	{
		743	GIDX,8,
		744
		745	GDTA,8,
		746
		747	PIDX,8,
		748
		749	PDTA,8,
		750
		751	SIDX,8,
		752
		753	SDTA,8
		754	}
		755	IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve)
		756	{
		757	Offset(0x2),
		758	,5,
		759	VGAS,2,
		760	Offset(0x4),
		761	,4,
		762	DCKE,1,
		763	Offset(0x5),
		764	,6,
		765	ACPW,1,
		766
		767	Offset(0xA),
		768	B1P,1,
		769
		770	B2P,1,
		771
		772	B1C,1,
		773
		774	B2C,1,
		775
		776	B1ER,1,
		777
		778	B2ER,1,
		779
		780	Offset(0xB),
		781	B1CP,8,
		782
		783	B2CP,8,
		784
		785	BCP,8,
		786
		787	B1VH,8,
		788
		789	B1VL,8,
		790
		791	B2VH,8,
		792
		793	B2VL,8,
		794
		795	B1TM,8,
		796
		797	B2TM,8,
		798
		799	B1CH,8,
		800
		801	B1CL,8,
		802
		803	B2CH,8,
		804
		805	B2CL,8
		806	}
		807	}
		808	}
		809	}
		810
		811	Method(RDBT,3,Serialized){
		812	Store(0x1FFF,Local1)
		813	If( Arg0 ){
		814	Store(0x2FFF,Local1)
		815	}
		816	Store(0x18,Local2)
		817	If( Arg1 ){
		818	Store(0x10,Local2)
		819	}
		820	If(LNot(SMRE(0x09,0x15,1,RefOf(Local0)))){
		821	If(LNot(SMWE(0x08,0x14,1,Local1))){
		822	If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){
		823	Store(Local1,Arg2)
		824	}
		825	}
		826	Or(Local0,0xFFF,Local0)
		827	SMWE(0x08,0x14,1,Local0)
		828	}
		829	}
		830	Method(MKWD,2)
		831	{
		832	If(And(Arg1,0x80)) {
		833	Or(0xFFFF0000,Arg0,Local0)
		834	Or(Local0,ShiftLeft(Arg1,8),Local0)
		835	Subtract(Zero,Local0,Local0)
		836	} else {
		837	Store(Arg0,Local0)
		838	Or(Local0,ShiftLeft(Arg1,8),Local0)
		839	}
		840	Return(Local0)
		841	}
		842
		843	Device(CMB1)
		844	{
		845	Name(_HID,EISAID("PNP0C0A"))
		846	Name(_UID,0x1)
		847	Alias(\_SB.PCI0.EIO.B1P,\_SB_.PCI0.XXXX)
		848	Alias(\_SB.PCI0.EIO.B1P,B1P)
		849	Alias(\_SB.PCI0.EIO.B1C,B1C)
		850	Alias(\_SB.PCI0.EIO.B1CH,B1CH)
		851	Alias(\_SB.PCI0.EIO.B1CL,B1CL)
		852	Alias(\_SB.PCI0.EIO.B1VH,B1VH)
		853	Alias(\_SB.PCI0.EIO.B1VL,B1VL)
		854	Alias(\_SB.PCI0.EIO.B1CP,B1CP)
		855
		856	Method(_INI)
		857	{
		858	Store(B1P, B1PS)
		859	Store(B1CP,B1RS)
		860	Store(B1C, B1CS)
		861	}
		862
		863	Method(_BIF){
		864	RDBT(Zero,Zero,RefOf(B1DC))
		865	RDBT(Zero,One,RefOf(B1LF))
		866	Store(B1DC,Index(RBIF,1))
		867	Store(B1LF,Index(RBIF,2))
		868	Store("CA54200-5003/5",Index(RBIF,9))
		869	Store("1",Index(RBIF,10))
		870	Return(RBIF)
		871	}
		872
		873	Method(_BST) {
		874
		875	_INI()
		876
		877	Store(Zero,Local0)
		878
		879	if (LAnd(B1P,LNot(B1C))){
		880	Or(Local0,1,Local0)
		881	}
		882
		883	if (LAnd(B1P,B1C)) {
		884	Or(Local0,2,Local0)
		885	}
		886
		887	if (LLessEqual(B1CP,1)) {
		888	Or(Local0,4,Local0)
		889	}
		890
		891	Store(MKWD(B1CL,B1CH),Local1)
		892
		893	Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2)
		894
		895	Store(MKWD(B1VL,B1VH),Local3)
		896
		897	Name(STAT,Package(4){})
		898	Store(Local0,Index(STAT,0))
		899	Store(Local1,Index(STAT,1))
		900	Store(Local2,Index(STAT,2))
		901	Store(Local3,Index(STAT,3))
		902
		903	If(LNot(BPIF)){
		904	// \_SB.PCI0.EIO.EC0.IECT()
		905	// \_SB.PCI0.EIO.EC0.SECT()
		906	Store(One,BPIF)
		907	}
		908	return(STAT)
		909	}
		910
		911	}
		912
		913	Device (DEV1)
		914	{
		915	}
		916
		917	Scope(\_TZ)
		918	{
		919	ThermalZone(TZ1)
		920	{
		921	Name(_PSL,Package()
		922	{
		923	\_PR.CPU0
		924	})
		925	}
		926	}
		927
		928	Method (TZ2, 0, SERIALIZED)
		929	{
		930	Name(_PSL,Package()
		931	{
		932	\_PR.CPU0
		933	})
		934
		935	Return (_PSL)
		936	}
		937
		938	ThermalZone (THM1)
		939	{
		940	}
		941
		942	Method (NOTI)
		943	{
		944	Notify (\DEV1, 0)
		945	Notify (\THM1, 0)
		946	Notify (\_PR.CPU0, 0)
		947	}
		948
		949	Method (_ERR, 2)
		950	{
		951	Increment (ERRS)
		952	Store ("Run-time exception:", Debug)
		953	Store (Arg0, Debug)
		954	Store (Arg1, Debug)
		955
		956	Return (0) // Map error to AE_OK
		957	}
		958
		959	Method (DIV0)
		960	{
		961	Store (1, Local0)
		962	Store (0, Local1)
		963	Divide (Local0, Local1, Local3)
		964
		965	Store ("DIV0 - noabort", Debug)
		966	}
		967
		968	Method (ERR_, 1)
		969	{
		970	if (LEqual (Arg0, 0))
		971	{
		972	Store ("++++ MTHD_ERROR: Results not equal!", Debug)
		973	}
		974	if (LEqual (Arg0, 1))
		975	{
		976	Store ("++++ MTHD_ERROR: Numeric result is incorrect!", Debug)
		977	}
		978	if (LEqual (Arg0, 2))
		979	{
		980	Store ("++++ MTHD_ERROR: Operand was clobbered!", Debug)
		981	}
		982
		983	Notify (DEV1, Arg0)
		984	Increment (ERRS)
		985	}
		986
		987	Method (R226, 2)
		988	{
		989	}
		990	Method (R225, 2)
		991	{
		992	R226 (Arg0, Arg1)
		993	}
		994	Method (R224, 2)
		995	{
		996	R225 (Arg1, Arg0)
		997	}
		998	Method (R223, 2)
		999	{
		1000	R224 (Arg0, Arg1)
		1001	}
		1002	Method (R222, 2)
		1003	{
		1004	R223 (Arg1, Arg0)
		1005	}
		1006	Method (R111)
		1007	{
		1008	Store (0x01010101, Local0)
		1009	R222 (0xABAB, Local0)
		1010	Store (Local0, Local1)
		1011	}
		1012
		1013	Method (MAIN)
		1014	{
		1015
		1016	// SIZE()
		1017	Store (NUM1(), Local0)
		1018	\CMB1._BST()
		1019	RDBT(1,2,3)
		1020	OBJ1(1)
		1021	OBJ2(2)
		1022	CHEK()
		1023	RETZ()
		1024	BITZ()
		1025	LOGS()
		1026	REFS()
		1027	COND()
		1028	TZ2()
		1029
		1030	//
		1031	// iPCO tests added
		1032	//
		1033	Store (\IFEL.TEST(), Local0)
		1034	if (LGreater (Local0, 0))
		1035	{
		1036	ERR_ (1)
		1037	Return(Local0)
		1038	}
		1039
		1040	Store (\NOSV.TEST(), Local0)
		1041	if (LGreater (Local0, 0))
		1042	{
		1043	ERR_ (1)
		1044	Return(Local0)
		1045	}
		1046
		1047	Store (\IDXF.TEST(), Local0)
		1048	if (LGreater (Local0, 0))
		1049	{
		1050	ERR_ (1)
		1051	Return(Local0)
		1052	}
		1053
		1054	Store (\_SB_.NSTL.TEST(), Local0)
		1055	if (LGreater (Local0, 0))
		1056	{
		1057	ERR_ (1)
		1058	Return(Local0)
		1059	}
		1060
		1061	Store (\RTBF.TEST(), Local0)
		1062	if (LGreater (Local0, 0))
		1063	{
		1064	ERR_ (1)
		1065	Return(Local0)
		1066	}
		1067
		1068	Store (\_SB_.RTLV.TEST(), Local0)
		1069	if (LGreater (Local0, 0))
		1070	{
		1071	ERR_ (1)
		1072	Return(Local0)
		1073	}
		1074
		1075	Store (\_SB_.RETP.TEST(), Local0)
		1076	if (LGreater (Local0, 0))
		1077	{
		1078	ERR_ (1)
		1079	Return(Local0)
		1080	}
		1081
		1082	Store (\WHLR.TEST(), Local0)
		1083	if (LGreater (Local0, 0))
		1084	{
		1085	ERR_ (1)
		1086	Return(Local0)
		1087	}
		1088
		1089	Store (\ANDO.TEST(), Local0)
		1090	if (LGreater (Local0, 0))
		1091	{
		1092	ERR_ (1)
		1093	Return(Local0)
		1094	}
		1095
		1096	Store (\BRKP.TEST(), Local0)
		1097	if (LGreater (Local0, 0))
		1098	{
		1099	ERR_ (1)
		1100	Return(Local0)
		1101	}
		1102
		1103	Store (\ADSU.TEST(), Local0)
		1104	if (LGreater (Local0, 0))
		1105	{
		1106	ERR_ (1)
		1107	Return(Local0)
		1108	}
		1109
		1110	Store (\INDC.TEST(), Local0)
		1111	if (LGreater (Local0, 0))
		1112	{
		1113	ERR_ (1)
		1114	Return(Local0)
		1115	}
		1116
		1117	Store (\LOPS.TEST(), Local0)
		1118	if (LGreater (Local0, 0))
		1119	{
		1120	ERR_ (1)
		1121	Return(Local0)
		1122	}
		1123
		1124	Store (\FDSO.TEST(), Local0)
		1125	if (LGreater (Local0, 0))
		1126	{
		1127	ERR_ (1)
		1128	Return(Local0)
		1129	}
		1130
		1131	Store (\MLDV.TEST(), Local0)
		1132	if (LGreater (Local0, 0))
		1133	{
		1134	ERR_ (1)
		1135	Return(Local0)
		1136	}
		1137
		1138	Store (\NBIT.TEST(), Local0)
		1139	if (LGreater (Local0, 0))
		1140	{
		1141	ERR_ (1)
		1142	Return(Local0)
		1143	}
		1144
		1145	Store (\SHFT.TEST(), Local0)
		1146	if (LGreater (Local0, 0))
		1147	{
		1148	ERR_ (1)
		1149	Return(Local0)
		1150	}
		1151
		1152	Store (\XORD.TEST(), Local0)
		1153	if (LGreater (Local0, 0))
		1154	{
		1155	ERR_ (1)
		1156	Return(Local0)
		1157	}
		1158
		1159	Store (\CRBF.TEST(), Local0)
		1160	if (LGreater (Local0, 0))
		1161	{
		1162	ERR_ (1)
		1163	Return(Local0)
		1164	}
		1165
		1166	Store (\IDX4.TEST(), Local0)
		1167	if (LGreater (Local0, 0))
		1168	{
		1169	ERR_ (1)
		1170	Return(Local0)
		1171	}
		1172
		1173	Store (\EVNT.TEST(), Local0)
		1174	if (LGreater (Local0, 0))
		1175	{
		1176	ERR_ (1)
		1177	Return(Local0)
		1178	}
		1179
		1180	Store (\SZLV.TEST(), Local0)
		1181	if (LGreater (Local0, 0))
		1182	{
		1183	ERR_ (1)
		1184	Return(Local0)
		1185	}
		1186
		1187	Store (\_SB_.BYTF.TEST(), Local0)
		1188	if (LGreater (Local0, 0))
		1189	{
		1190	ERR_ (1)
		1191	Return(Local0)
		1192	}
		1193
		1194	Store (\DWDF.TEST(), Local0)
		1195	if (LGreater (Local0, 0))
		1196	{
		1197	ERR_ (1)
		1198	Return(Local0)
		1199	}
		1200
		1201	Store (\DVAX.TEST(), Local0)
		1202	if (LGreater (Local0, 0))
		1203	{
		1204	ERR_ (1)
		1205	Return(Local0)
		1206	}
		1207
		1208	Store (\IDX6.TEST(), Local0)
		1209	if (LGreater (Local0, 0))
		1210	{
		1211	ERR_ (1)
		1212	Return(Local0)
		1213	}
		1214
		1215	Store (\IDX5.TEST(), Local0)
		1216	if (LGreater (Local0, 0))
		1217	{
		1218	ERR_ (1)
		1219	Return(Local0)
		1220	}
		1221
		1222	Store (\_SB_.IDX0.TEST(), Local0)
		1223	if (LGreater (Local0, 0))
		1224	{
		1225	ERR_ (1)
		1226	Return(Local0)
		1227	}
		1228
		1229	Store (\_SB_.IDX3.TEST(), Local0)
		1230	if (LGreater (Local0, 0))
		1231	{
		1232	ERR_ (1)
		1233	Return(Local0)
		1234	}
		1235
		1236	Store (\IDX7.TEST(), Local0)
		1237	if (LGreater (Local0, 0))
		1238	{
		1239	ERR_ (1)
		1240	Return(Local0)
		1241	}
		1242
		1243	Store (\MTCH.TEST(), Local0)
		1244	if (LGreater (Local0, 0))
		1245	{
		1246	ERR_ (1)
		1247	Return(Local0)
		1248	}
		1249
		1250	Store (\WHLB.TEST(), Local0)
		1251	if (LGreater (Local0, 0))
		1252	{
		1253	ERR_ (1)
		1254	Return(Local0)
		1255	}
		1256
		1257	Store (\_SB_.IDX2.TEST(), Local0)
		1258	if (LGreater (Local0, 0))
		1259	{
		1260	ERR_ (1)
		1261	Return(Local0)
		1262	}
		1263
		1264	Store (\SIZO.TEST(), Local0)
		1265	if (LGreater (Local0, 0))
		1266	{
		1267	ERR_ (1)
		1268	Return(Local0)
		1269	}
		1270
		1271	Store (\_SB_.SMIS.TEST(), Local0)
		1272	if (LGreater (Local0, 0))
		1273	{
		1274	ERR_ (1)
		1275	Return(Local0)
		1276	}
		1277
		1278	if (LGreater (ERRS, 0))
		1279	{
		1280	Store ("**** There were errors during the execution of the test ****", Debug)
		1281	}
		1282
		1283	//
		1284	// Last Test
		1285	//
		1286
		1287	Return(0) // Success
		1288	}
		1289
		1290
		1291	Method (OBJ1, 1, SERIALIZED)
		1292	{
		1293
		1294	Store (3, Local0)
		1295	Name(BUFR, Buffer (Local0) {})
		1296	Name(BUF1, Buffer (4) {1,2,3,4})
		1297	Name(BUF2, Buffer (4) {})
		1298
		1299	Store (BUF1, BUF2)
		1300	Mutex (MTX1, 4)
		1301
		1302	Alias (MTX1, MTX2)
		1303	}
		1304
		1305
		1306	Mutex (MTXT, 0)
		1307	Mutex (MTXX, 0)
		1308
		1309	/*
		1310	* Field Creation
		1311	*/
		1312
		1313	Method (FLDS)
		1314	{
		1315	Store ("++++++++ Creating BufferFields", Debug)
		1316	Name (BUF2, Buffer (128) {})
		1317
		1318	CreateBitField (BUF2, 3, BIT2)
		1319	CreateByteField (BUF2, 1, BYT2)
		1320	CreateWordField (BUF2, 2, WRD2)
		1321	CreateDwordField (BUF2, 4, DWD2)
		1322	CreateQwordField (BUF2, 8, QWD2)
		1323	CreateField (BUF2, 128, 12, FLD2)
		1324	CreateField (BUF2, 148, 96, FLD3)
		1325
		1326	Store (0x1, BIT2)
		1327	Store (BIT2, Local0)
		1328	if (LNotEqual (Local0, 0x1))
		1329	{
		1330	ERR_ (1)
		1331	}
		1332	else
		1333	{
		1334	Store (DerefOf (Index (BUF2, 0)), Local0)
		1335	if (LNotEqual (Local0, 0x08))
		1336	{
		1337	ERR_ (1)
		1338	}
		1339	else
		1340	{
		1341	Store ("++++++++ Bit BufferField I/O PASS", Debug)
		1342	}
		1343	}
		1344
		1345	Store (0x1A, BYT2)
		1346	Store (BYT2, Local0)
		1347	if (LNotEqual (Local0, 0x1A))
		1348	{
		1349	ERR_ (1)
		1350	}
		1351	else
		1352	{
		1353	Store ("++++++++ Byte BufferField I/O PASS", Debug)
		1354	}
		1355
		1356	Store (0x1234, WRD2)
		1357	Store (WRD2, Local0)
		1358	if (LNotEqual (Local0, 0x1234))
		1359	{
		1360	ERR_ (1)
		1361	}
		1362	else
		1363	{
		1364	Store ("++++++++ Word BufferField I/O PASS", Debug)
		1365	}
		1366
		1367	Store (0x123, FLD2)
		1368	Store (FLD2, Local0)
		1369	if (LNotEqual (Local0, 0x123))
		1370	{
		1371	ERR_ (1)
		1372	}
		1373	else
		1374	{
		1375	Store ("++++++++ 12-bit BufferField I/O PASS", Debug)
		1376	}
		1377
		1378	Store (0x12345678, DWD2)
		1379	Store (DWD2, Local0)
		1380	if (LNotEqual (Local0, 0x12345678))
		1381	{
		1382	ERR_ (1)
		1383	}
		1384	else
		1385	{
		1386	Store ("++++++++ Dword BufferField I/O PASS", Debug)
		1387	}
		1388
		1389	Store (0x1234567887654321, QWD2)
		1390	Store (QWD2, Local0)
		1391	if (LNotEqual (Local0, 0x1234567887654321))
		1392	{
		1393	ERR_ (1)
		1394	}
		1395	else
		1396	{
		1397	Store ("++++++++ Qword BufferField I/O PASS", Debug)
		1398	}
		1399	}
		1400
		1401
		1402	/* Field execution */
		1403
		1404	Method (FLDX)
		1405	{
		1406	Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
		1407	{ // Field: SMEM overlay using 32-bit field elements
		1408	SMD0, 32, // 32-bits
		1409	SMD1, 32, // 32-bits
		1410	SMD2, 32, // 32-bits
		1411	SMD3, 32 // 32-bits
		1412	} // Field: SMEM overlay using 32-bit field elements
		1413	Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
		1414	{ // Field: SMEM overlay using greater than 32-bit field elements
		1415	SME0, 69, // larger than an integer (32 or 64)
		1416	SME1, 97 // larger than an integer
		1417	} // Field: SMEM overlay using greater than 32-bit field elements
		1418	}
		1419
		1420
		1421	Method (MTX_, )
		1422	{
		1423	/* Test "Force release" of mutex on method exit */
		1424
		1425	Acquire (MTXT, 0xFFFF)
		1426	Acquire (MTXX, 0xFFFF)
		1427
		1428	Store ("++++++++ Acquiring Mutex MTX2", Debug)
		1429	Acquire (_GL_, 0xFFFF)
		1430
		1431
		1432	Store ("++++++++ Releasing Mutex MTX2", Debug)
		1433	Release (_GL_)
		1434	}
		1435
		1436
		1437	Method (OBJ2, 1)
		1438	{
		1439	Store ("++++++++ Creating Buffer BUFO", Debug)
		1440	Name (BUFO, Buffer (32) {})
		1441
		1442	Store ("++++++++ Creating OpRegion OPR2", Debug)
		1443	OperationRegion (OPR2, SystemMemory, Arg0, 256)
		1444
		1445	Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug)
		1446	Field (OPR2, ByteAcc, NoLock, Preserve)
		1447	{
		1448	IDX2, 8,
		1449	DAT2, 8,
		1450	BNK2, 4
		1451	}
		1452
		1453	Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug)
		1454	//
		1455	// mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1
		1456	//
		1457	BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve)
		1458	{
		1459	FET0, 4,
		1460	FET1, 3
		1461	}
		1462
		1463	Store ("++++++++ Creating IndexField", Debug)
		1464	IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
		1465	{
		1466	FET2, 4,
		1467	FET3, 3
		1468	}
		1469
		1470	Store ("++++++++ SizeOf (BUFO)", Debug)
		1471	SizeOf (BUFO)
		1472
		1473	Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug)
		1474	Store (SizeOf (BUFO), Local0)
		1475
		1476	Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug)
		1477	Concatenate ("abd", "def", Local0)
		1478	Store (Local0, Debug)
		1479
		1480	Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug)
		1481	Concatenate ("abd", 0x7B, Local0)
		1482	Store (Local0, Debug)
		1483
		1484	Store ("++++++++ Creating Event EVT2", Debug)
		1485	Event (EVT2)
		1486
		1487	Store ("++++++++ Creating Mutex MTX2", Debug)
		1488	Mutex (MTX2, 0)
		1489
		1490	Store ("++++++++ Creating Alias MTXA to MTX2", Debug)
		1491	Alias (MTX2, MTXA)
		1492
		1493	Store ("++++++++ Acquiring Mutex MTX2", Debug)
		1494	Acquire (MTX2, 0xFFFF)
		1495
		1496	Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug)
		1497	Acquire (MTX2, 1)
		1498
		1499	Store ("++++++++ Releasing Mutex MTX2", Debug)
		1500	Release (MTX2)
		1501
		1502	// Type 1 opcodes
		1503
		1504	Store ("++++++++ Signalling Event EVT2", Debug)
		1505	Signal (EVT2)
		1506
		1507	Store ("++++++++ Resetting Event EVT2", Debug)
		1508	Reset (EVT2)
		1509
		1510	Store ("++++++++ Signalling Event EVT2", Debug)
		1511	Signal (EVT2)
		1512
		1513	Store ("++++++++ Waiting Event EVT2", Debug)
		1514	Wait (EVT2, 0xFFFF)
		1515
		1516	Store ("++++++++ Sleep", Debug)
		1517	Sleep (100)
		1518
		1519	Store ("++++++++ Stall", Debug)
		1520	Stall (254)
		1521
		1522	Store ("++++++++ NoOperation", Debug)
		1523	Noop
		1524
		1525	// Type 2 Opcodes
		1526
		1527	Store ("++++++++ Return from Method OBJ2", Debug)
		1528	return (4)
		1529	}
		1530
		1531
		1532	Method (NUM1, 0)
		1533	{
		1534	/* ADD */
		1535
		1536	Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug)
		1537	Add (0x12345678, 0x11111111, Local0)
		1538
		1539	Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug)
		1540	Store (Add (0x12345678, 0x11111111), Local1)
		1541
		1542	Store ("++++++++ Checking result from ADD", Debug)
		1543	if (LNotEqual (Local0, Local1))
		1544	{
		1545	ERR_ (0)
		1546	}
		1547
		1548
		1549	/* SUBTRACT */
		1550
		1551	Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug)
		1552	Subtract (0x87654321, 0x11111111, Local4)
		1553
		1554	Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug)
		1555	Store (Subtract (0x87654321, 0x11111111), Local5)
		1556
		1557	Store ("++++++++ Checking result from SUBTRACT", Debug)
		1558	if (LNotEqual (Local4, Local5))
		1559	{
		1560	ERR_ (0)
		1561	}
		1562
		1563
		1564	/* MULTIPLY */
		1565
		1566	Store ("++++++++ Multiply (33, 10, Local6)", Debug)
		1567	Multiply (33, 10, Local6)
		1568
		1569	Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug)
		1570	Store (Multiply (33, 10), Local7)
		1571
		1572
		1573	Store ("++++++++ Checking result from MULTIPLY", Debug)
		1574	if (LNotEqual (Local6, Local7))
		1575	{
		1576	ERR_ (0)
		1577	}
		1578
		1579
		1580	/* DIVIDE */
		1581
		1582	Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug)
		1583	Divide (100, 9, Local1, Local2)
		1584
		1585	Store ("++++++++ Store (Divide (100, 9), Local3)", Debug)
		1586	Store (Divide (100, 9), Local3)
		1587
		1588	Store ("++++++++ Checking (quotient) result from DIVIDE", Debug)
		1589	if (LNotEqual (Local2, Local3))
		1590	{
		1591	ERR_ (0)
		1592	}
		1593
		1594
		1595	/* INCREMENT */
		1596
		1597	Store ("++++++++ Increment (Local0)", Debug)
		1598	Store (1, Local0)
		1599	Store (2, Local1)
		1600	Increment (Local0)
		1601
		1602	Store ("++++++++ Checking result from INCREMENT", Debug)
		1603	if (LNotEqual (Local0, Local1))
		1604	{
		1605	ERR_ (0)
		1606	}
		1607
		1608
		1609	/* DECREMENT */
		1610
		1611	Store ("++++++++ Decrement (Local0)", Debug)
		1612	Store (2, Local0)
		1613	Store (1, Local1)
		1614	Decrement (Local0)
		1615
		1616	Store ("++++++++ Checking result from DECREMENT", Debug)
		1617	if (LNotEqual (Local0, Local1))
		1618	{
		1619	ERR_ (0)
		1620	}
		1621
		1622
		1623	/* TOBCD */
		1624	/* FROMBCD */
		1625
		1626	Store ("++++++++ ToBCD (0x1234, Local5)", Debug)
		1627	ToBCD (0x1234, Local5)
		1628
		1629	Store ("++++++++ FromBCD (Local5, Local6)", Debug)
		1630	FromBCD (Local5, Local6)
		1631
		1632	Store ("++++++++ Return (Local6)", Debug)
		1633	Return (Local6)
		1634	}
		1635
		1636
		1637	Method (CHEK)
		1638	{
		1639
		1640	Store (3, Local0)
		1641	Store (3, Debug)
		1642	Store (Local0, Debug)
		1643	Store (7, Local1)
		1644
		1645	Add (Local0, Local1)
		1646	if (LNotEqual (Local0, 3))
		1647	{
		1648	ERR_ (2)
		1649	}
		1650	if (LNotEqual (Local1, 7))
		1651	{
		1652	ERR_ (2)
		1653	}
		1654
		1655
		1656	Add (Local0, Local1, Local2)
		1657	if (LNotEqual (Local0, 3))
		1658	{
		1659	ERR_ (2)
		1660	}
		1661	if (LNotEqual (Local1, 7))
		1662	{
		1663	ERR_ (2)
		1664	}
		1665	}
		1666
		1667
		1668	Method (RET1)
		1669	{
		1670	Store (3, Local0)
		1671	Return (Local0)
		1672	}
		1673
		1674	Method (RET2)
		1675	{
		1676	Return (RET1())
		1677	}
		1678
		1679	Method (RETZ)
		1680	{
		1681	RET2 ()
		1682	}
		1683
		1684
		1685	Method (BITZ)
		1686	{
		1687	Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug)
		1688	FindSetLeftBit (0x00100100, Local0)
		1689	if (LNotEqual (Local0, 21))
		1690	{
		1691	ERR_ (1)
		1692	}
		1693
		1694	Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug)
		1695	FindSetRightBit (0x00100100, Local1)
		1696	if (LNotEqual (Local1, 9))
		1697	{
		1698	ERR_ (1)
		1699	}
		1700
		1701	Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug)
		1702	And (0xF0F0F0F0, 0x11111111, Local2)
		1703	if (LNotEqual (Local2, 0x10101010))
		1704	{
		1705	ERR_ (1)
		1706	}
		1707
		1708	Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug)
		1709	NAnd (0xF0F0F0F0, 0x11111111, Local3)
		1710	if (LNotEqual (Local3, 0xEFEFEFEF))
		1711	{
		1712	ERR_ (1)
		1713	}
		1714
		1715	Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug)
		1716	Or (0x11111111, 0x22222222, Local4)
		1717	if (LNotEqual (Local4, 0x33333333))
		1718	{
		1719	ERR_ (1)
		1720	}
		1721
		1722	Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug)
		1723	NOr (0x11111111, 0x22222222, Local5)
		1724	if (LNotEqual (Local5, 0xCCCCCCCC))
		1725	{
		1726	ERR_ (1)
		1727	}
		1728
		1729	Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug)
		1730	XOr (0x11113333, 0x22222222, Local6)
		1731	if (LNotEqual (Local6, 0x33331111))
		1732	{
		1733	ERR_ (1)
		1734	}
		1735
		1736	Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug)
		1737	ShiftLeft (0x11112222, 2, Local7)
		1738	if (LNotEqual (Local7, 0x44448888))
		1739	{
		1740	ERR_ (1)
		1741	}
		1742
		1743	Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug)
		1744	ShiftRight (Local7, 2, Local7)
		1745	if (LNotEqual (Local7, 0x11112222))
		1746	{
		1747	ERR_ (1)
		1748	}
		1749
		1750
		1751	Store ("++++++++ Not (Local0, Local1)", Debug)
		1752	Store (0x22224444, Local0)
		1753	Not (Local0, Local1)
		1754	if (LNotEqual (Local0, 0x22224444))
		1755	{
		1756	ERR_ (2)
		1757	}
		1758
		1759	if (LNotEqual (Local1, 0xDDDDBBBB))
		1760	{
		1761	ERR_ (1)
		1762	}
		1763
		1764	Return (Local7)
		1765	}
		1766
		1767
		1768	Method (LOGS)
		1769	{
		1770
		1771	Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug)
		1772	Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)
		1773
		1774	Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug)
		1775	Store (LEqual (0xFFFFFFFF, 0x11111111), Local1)
		1776
		1777	Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug)
		1778	Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)
		1779
		1780	Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug)
		1781	Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)
		1782
		1783	Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug)
		1784	Store (LLess (0xFFFFFFFF, 0x11111111), Local4)
		1785
		1786	Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug)
		1787	Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)
		1788
		1789	Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug)
		1790	Store (0x00001111, Local6)
		1791	Store (LNot (Local6), Local7)
		1792	if (LNotEqual (Local6, 0x00001111))
		1793	{
		1794	ERR_ (2)
		1795	}
		1796
		1797	if (LNotEqual (Local7, 0x0))
		1798	{
		1799	ERR_ (1)
		1800	}
		1801
		1802
		1803	Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug)
		1804	Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)
		1805
		1806	Store ("++++++++ Lor (0x0, 0x1)", Debug)
		1807	if (Lor (0x0, 0x1))
		1808	{
		1809	Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug)
		1810	}
		1811
		1812	return (Local7)
		1813	}
		1814
		1815
		1816	Method (COND)
		1817	{
		1818	Store ("++++++++ Store (0x4, Local0)", Debug)
		1819	Store (0x4, Local0)
		1820
		1821	Store ("++++++++ While (Local0)", Debug)
		1822	While (Local0)
		1823	{
		1824	Store ("++++++++ Decrement (Local0)", Debug)
		1825	Decrement (Local0)
		1826	}
		1827
		1828
		1829	Store ("++++++++ Store (0x3, Local6)", Debug)
		1830	Store (0x3, Local6)
		1831
		1832	Store ("++++++++ While (Subtract (Local6, 1))", Debug)
		1833	While (Subtract (Local6, 1))
		1834	{
		1835	Store ("++++++++ Decrement (Local6)", Debug)
		1836	Decrement (Local6)
		1837	}
		1838
		1839
		1840	Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
		1841	If (LGreater (0x2, 0x1))
		1842	{
		1843	Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
		1844	If (LEqual (0x11111111, 0x22222222))
		1845	{
		1846	Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
		1847	}
		1848
		1849	else
		1850	{
		1851	Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
		1852	If (LNot (0x0))
		1853	{
		1854	Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
		1855	If (LAnd (0xEEEEEEEE, 0x2))
		1856	{
		1857	Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
		1858	If (LLess (0x44444444, 0x3))
		1859	{
		1860	Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
		1861	}
		1862
		1863	else
		1864	{
		1865	Store ("++++++++ Exiting from nested IF/ELSE statements", Debug)
		1866	}
		1867	}
		1868	}
		1869	}
		1870	}
		1871
		1872
		1873	Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
		1874	If (LGreater (0x2, 0x1))
		1875	{
		1876	Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
		1877	If (LEqual (0x11111111, 0x22222222))
		1878	{
		1879	Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
		1880	}
		1881
		1882	else
		1883	{
		1884	Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
		1885	If (LNot (0x0))
		1886	{
		1887	Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
		1888	If (LAnd (0xEEEEEEEE, 0x2))
		1889	{
		1890	Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
		1891	If (LLess (0x44444444, 0x3))
		1892	{
		1893	Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
		1894	}
		1895
		1896	else
		1897	{
		1898	Store ("++++++++ Returning from nested IF/ELSE statements", Debug)
		1899	Return (Local6)
		1900	}
		1901	}
		1902	}
		1903	}
		1904	}
		1905
		1906	}
		1907
		1908
		1909	Method (REFS)
		1910	{
		1911	Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7})
		1912
		1913	Name (NEST, Package ()
		1914	{
		1915	Package ()
		1916	{
		1917	0x01, 0x02, 0x03, 0x04, 0x05, 0x06
		1918	},
		1919	Package ()
		1920	{
		1921	0x11, 0x12, 0x12, 0x14, 0x15, 0x16
		1922	}
		1923	})
		1924
		1925	/* Parser thinks this is a method invocation!! */
		1926
		1927	Store (RefOf (MAIN), Local5)
		1928
		1929	// For this to work, ABCD must NOT exist.
		1930
		1931	Store (CondRefOf (ABCD, Local0), Local1)
		1932	if (LNotEqual (Local1, 0))
		1933	{
		1934	ERR_ (2)
		1935	}
		1936
		1937	Store (CondRefOf (BBUF, Local0), Local1)
		1938	if (LNotEqual (Local1, Ones))
		1939	{
		1940	ERR_ (2)
		1941	}
		1942
		1943	Store (DeRefOf (Index (BBUF, 3)), Local6)
		1944	if (LNotEqual (Local6, 0xB3))
		1945	{
		1946	ERR_ (2)
		1947	}
		1948
		1949	Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0)
		1950	if (LNotEqual (Local0, 0x14))
		1951	{
		1952	ERR_ (2)
		1953	}
		1954
		1955
		1956	Store (0x11223344, Local0)
		1957	Store (RefOf (Local0), Local1)
		1958
		1959	Store (DerefOf (Local1), Local2)
		1960	If (LNotEqual (Local2, 0x11223344))
		1961	{
		1962	ERR_ (2)
		1963	}
		1964
		1965
		1966	/* Parser thinks this is a method invocation!! */
		1967
		1968	// RefOf (MAIN)
		1969
		1970
		1971	// RefOf (R___)
		1972	// RefOf (BBUF)
		1973
		1974	// Store (RefOf (Local0), Local1)
		1975
		1976	// CondRefOf (BBUF, Local2)
		1977	// CondRefOf (R___, Local3)
		1978
		1979	// Store (DerefOf (Local1), Local4)
		1980
		1981	// Return (Local4)
		1982	}
		1983
		1984
		1985	Method (INDX, 0)
		1986	{
		1987	Name(STAT,Package(4){})
		1988	Store(0x44443333,Index(STAT,0))
		1989	}
		1990
		1991	//=================================================================
		1992	//=================================================================
		1993	//===================== iPCO TESTS ================================
		1994	//=================================================================
		1995	//=================================================================
		1996	//
		1997	//
		1998	// test IfElseOp.asl
		1999	//
		2000	// test for IfOp and ElseOp, including validation of object stack cleanup
		2001	//
		2002	Device (IFEL)
		2003	{
		2004	Name (DWRD, 1)
		2005	Name (RSLT, 0)
		2006
		2007	// IFNR control method executes IfOp branch with NO nested Return
		2008	// and no Else branch
		2009	Method (IFNR)
		2010	{
		2011	Store (DWRD, RSLT)
		2012	If (LEqual (DWRD, 1))
		2013	{
		2014	Store (0, RSLT)
		2015	}
		2016	} // IFNR
		2017
		2018	// NINR control method does not execute If branch and has no Else branch
		2019	Method (NINR)
		2020	{
		2021	Store (0, RSLT)
		2022	If (LNotEqual (DWRD, 1))
		2023	{
		2024	Store (DWRD, RSLT)
		2025	}
		2026	} // NINR
		2027
		2028	// IENR control method executes IfOp branch with NO nested Return
		2029	Method (IENR)
		2030	{
		2031	If (LEqual (DWRD, 1))
		2032	{
		2033	Store (0, RSLT)
		2034	}
		2035	Else
		2036	{
		2037	Store (DWRD, RSLT)
		2038	}
		2039	} // IENR
		2040
		2041	// ELNR control method executes ElseOp branch with NO nested Return
		2042	Method (ELNR)
		2043	{
		2044	If (LNotEqual (DWRD, 1))
		2045	{
		2046	Store (DWRD, RSLT)
		2047	}
		2048	Else
		2049	{
		2050	Store (0, RSLT)
		2051	}
		2052	} // ELNR
		2053
		2054	// IFRT control method executes IfOp branch with nested Return with
		2055	// no Else branch
		2056	Method (IFRT)
		2057
		2058	{
		2059	If (LEqual (DWRD, 1))
		2060	{
		2061	Return (0)
		2062	}
		2063	Return (DWRD)
		2064	} // IFRT
		2065
		2066	// IERT control method executes IfOp branch with nested Return with
		2067	// Else branch
		2068	Method (IERT)
		2069	{
		2070	If (LEqual (DWRD, 1))
		2071	{
		2072	Return (0)
		2073	}
		2074	Else
		2075	{
		2076	Return (DWRD)
		2077	}
		2078	} // IERT
		2079
		2080	// ELRT control method executes ElseOp branch with nested Return
		2081	Method (ELRT)
		2082	{
		2083	If (LNotEqual (DWRD, 1))
		2084	{
		2085	Return (DWRD)
		2086	}
		2087	Else
		2088	{
		2089	Return (0)
		2090	}
		2091	} // ELRT
		2092
		2093	Method (TEST)
		2094	{
		2095	Store ("++++++++ IfElseOp Test", Debug)
		2096
		2097	// IfOp with NO return value
		2098	IFNR()
		2099	If (LNotEqual (RSLT, 0))
		2100	{
		2101	Return (RSLT)
		2102	}
		2103
		2104	// IfOp with NO return value
		2105	NINR()
		2106	If (LNotEqual (RSLT, 0))
		2107	{
		2108	Return (RSLT)
		2109	}
		2110
		2111	// IfOp with NO return value
		2112	IENR()
		2113	If (LNotEqual (RSLT, 0))
		2114	{
		2115	Return (RSLT)
		2116	}
		2117
		2118	// ElseOp with NO return value
		2119	ELNR()
		2120	If (LNotEqual (RSLT, 0))
		2121	{
		2122	Return (RSLT)
		2123	}
		2124
		2125	// IfOp with return value
		2126	Store (IFRT, RSLT)
		2127	If (LNotEqual (RSLT, 0))
		2128	{
		2129	Return (RSLT)
		2130	}
		2131
		2132	// IfOp with return value
		2133	Store (IERT, RSLT)
		2134	If (LNotEqual (RSLT, 0))
		2135	{
		2136	Return (RSLT)
		2137	}
		2138
		2139	// ElseOp with return value
		2140	Store (ELRT, RSLT)
		2141	If (LNotEqual (RSLT, 0))
		2142	{
		2143	Return (RSLT)
		2144	}
		2145
		2146	Return (0)
		2147	} // TEST
		2148	} // IFEL
		2149
		2150	//
		2151	// test NoSave.asl
		2152	//
		2153	//
		2154	// Internal test cases to validate IfOp (Operator (,,)) where Operator
		2155	// target is ZeroOp to throw away the results.
		2156	// Includes internal test cases for logical operators with no destination
		2157	// operands.
		2158	//
		2159	Device (NOSV)
		2160	{
		2161	Method (TEST)
		2162	{
		2163	Store ("++++++++ NoSave Test", Debug)
		2164
		2165	Name (WRD, 0x1234)
		2166
		2167	//
		2168	// Begin test of nested operators without saving results
		2169	//
		2170
		2171	// Test If (And ()) with no save of And result
		2172	If (And (3, 1, ))
		2173	{
		2174	Store (1, WRD) // pass -- just do something
		2175	}
		2176	else
		2177	{
		2178	Return (1) // fail
		2179	}
		2180
		2181	// Test If (And ()) with no save of And result
		2182	If (And (4, 1, ))
		2183	{
		2184	Return (2) // fail
		2185	}
		2186	else
		2187	{
		2188	Store (2, WRD) // pass -- just do something
		2189	}
		2190
		2191
		2192	// Test If (NAnd ()) with no save of NAnd result
		2193	If (NAnd (3, 1, ))
		2194	{
		2195	Store (3, WRD) // pass -- just do something
		2196	}
		2197	else
		2198	{
		2199	Return (3) // fail
		2200	}
		2201
		2202	// Test If (NAnd ()) with no save of NAnd result
		2203	If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, ))
		2204	{
		2205	Return (4) // fail
		2206	}
		2207	else
		2208	{
		2209	Store (4, WRD) // pass -- just do something
		2210	}
		2211
		2212
		2213	// Test If (NOr ()) with no save of NOr result
		2214	If (NOr (0, 1, ))
		2215	{
		2216	Store (5, WRD) // pass -- just do something
		2217	}
		2218	else
		2219	{
		2220	Return (5) // fail
		2221	}
		2222
		2223	// Test If (NOr ()) with no save of NOr result
		2224	If (NOr (0xFFFFFFFE, 1, ))
		2225	{
		2226	Return (6) // fail
		2227	}
		2228	else
		2229	{
		2230	Store (6, WRD) // pass -- just do something
		2231	}
		2232
		2233
		2234	// Test If (Not ()) with no save of Not result
		2235	If (Not (1, ))
		2236	{
		2237	Store (7, WRD) // pass -- just do something
		2238	}
		2239	else
		2240	{
		2241	Return (7) // fail
		2242	}
		2243
		2244	// Test If (Not ()) with no save of Not result
		2245	If (Not (0xFFFFFFFF, ))
		2246	{
		2247	Return (8) // fail
		2248	}
		2249	else
		2250	{
		2251	Store (8, WRD) // pass -- just do something
		2252	}
		2253
		2254
		2255	// Test If (Or ()) with no save of Or result
		2256	If (Or (3, 1, ))
		2257	{
		2258	Store (9, WRD) // pass -- just do something
		2259	}
		2260	else
		2261	{
		2262	Return (9) // fail
		2263	}
		2264
		2265	// Test If (Or ()) with no save of Or result
		2266	If (Or (0, 0, ))
		2267	{
		2268	Return (10) // fail
		2269	}
		2270	else
		2271	{
		2272	Store (10, WRD) // pass -- just do something
		2273	}
		2274
		2275
		2276	// Test If (XOr ()) with no save of XOr result
		2277	If (XOr (3, 1, ))
		2278	{
		2279	Store (11, WRD) // pass -- just do something
		2280	}
		2281	else
		2282	{
		2283	Return (11) // fail
		2284	}
		2285
		2286	// Test If (XOr ()) with no save of XOr result
		2287	If (XOr (3, 3, ))
		2288	{
		2289	Return (12) // fail
		2290	}
		2291	else
		2292	{
		2293	Store (12, WRD) // pass -- just do something
		2294	}
		2295
		2296
		2297	//
		2298	// Begin test of logical operators with no destination operands
		2299	//
		2300
		2301	// Test If (LAnd ()) with no save of LAnd result
		2302	If (LAnd (3, 3))
		2303	{
		2304	Store (21, WRD) // pass -- just do something
		2305	}
		2306	else
		2307	{
		2308	Return (21) // fail
		2309	}
		2310
		2311	// Test If (LAnd ()) with no save of LAnd result
		2312	If (LAnd (3, 0))
		2313	{
		2314	Return (22) // fail
		2315	}
		2316	else
		2317	{
		2318	Store (22, WRD) // pass -- just do something
		2319	}
		2320
		2321	// Test If (LAnd ()) with no save of LAnd result
		2322	If (LAnd (0, 3))
		2323	{
		2324	Return (23) // fail
		2325	}
		2326	else
		2327	{
		2328	Store (23, WRD) // pass -- just do something
		2329	}
		2330
		2331	// Test If (LAnd ()) with no save of LAnd result
		2332	If (LAnd (0, 0))
		2333	{
		2334	Return (24) // fail
		2335	}
		2336	else
		2337	{
		2338	Store (24, WRD) // pass -- just do something
		2339	}
		2340
		2341
		2342	// Test If (LEqual ()) with no save of LEqual result
		2343	If (LEqual (3, 3))
		2344	{
		2345	Store (31, WRD) // pass -- just do something
		2346	}
		2347	else
		2348	{
		2349	Return (31) // fail
		2350	}
		2351
		2352	// Test If (LEqual ()) with no save of LEqual result
		2353	If (LEqual (1, 3))
		2354	{
		2355	Return (32) // fail
		2356	}
		2357	else
		2358	{
		2359	Store (32, WRD) // pass -- just do something
		2360	}
		2361
		2362
		2363	// Test If (LGreater ()) with no save of LGreater result
		2364	If (LGreater (3, 1))
		2365	{
		2366	Store (41, WRD) // pass -- just do something
		2367	}
		2368	else
		2369	{
		2370	Return (41) // fail
		2371	}
		2372
		2373	// Test If (LGreater ()) with no save of LGreater result
		2374	If (LGreater (4, 4))
		2375	{
		2376	Return (42) // fail
		2377	}
		2378	else
		2379	{
		2380	Store (42, WRD) // pass -- just do something
		2381	}
		2382
		2383	// Test If (LGreater ()) with no save of LGreater result
		2384	If (LGreater (1, 4))
		2385	{
		2386	Return (43) // fail
		2387	}
		2388	else
		2389	{
		2390	Store (43, WRD) // pass -- just do something
		2391	}
		2392
		2393	// Test If (LGreaterEqual ()) with no save of LGreaterEqual result
		2394	If (LGreaterEqual (3, 1))
		2395	{
		2396	Store (44, WRD) // pass -- just do something
		2397	}
		2398	else
		2399	{
		2400	Return (44) // fail
		2401	}
		2402
		2403	// Test If (LGreaterEqual ()) with no save of LGreaterEqual result
		2404	If (LGreaterEqual (3, 3))
		2405	{
		2406	Store (45, WRD) // pass -- just do something
		2407	}
		2408	else
		2409	{
		2410	Return (45) // fail
		2411	}
		2412
		2413	// Test If (LGreaterEqual ()) with no save of LGreaterEqual result
		2414	If (LGreaterEqual (3, 4))
		2415	{
		2416	Return (46) // fail
		2417	}
		2418	else
		2419	{
		2420	Store (46, WRD) // pass -- just do something
		2421	}
		2422
		2423
		2424	// Test If (LLess ()) with no save of LLess result
		2425	If (LLess (1, 3))
		2426	{
		2427	Store (51, WRD) // pass -- just do something
		2428	}
		2429	else
		2430	{
		2431	Return (51) // fail
		2432	}
		2433
		2434	// Test If (LLess ()) with no save of LLess result
		2435	If (LLess (2, 2))
		2436	{
		2437	Return (52) // fail
		2438	}
		2439	else
		2440	{
		2441	Store (52, WRD) // pass -- just do something
		2442	}
		2443
		2444	// Test If (LLess ()) with no save of LLess result
		2445	If (LLess (4, 2))
		2446	{
		2447	Return (53) // fail
		2448	}
		2449	else
		2450	{
		2451	Store (53, WRD) // pass -- just do something
		2452	}
		2453
		2454
		2455	// Test If (LLessEqual ()) with no save of LLessEqual result
		2456	If (LLessEqual (1, 3))
		2457	{
		2458	Store (54, WRD) // pass -- just do something
		2459	}
		2460	else
		2461	{
		2462	Return (54) // fail
		2463	}
		2464
		2465	// Test If (LLessEqual ()) with no save of LLessEqual result
		2466	If (LLessEqual (2, 2))
		2467	{
		2468	Store (55, WRD) // pass -- just do something
		2469	}
		2470	else
		2471	{
		2472	Return (55) // fail
		2473	}
		2474
		2475	// Test If (LLessEqual ()) with no save of LLessEqual result
		2476	If (LLessEqual (4, 2))
		2477	{
		2478	Return (56) // fail
		2479	}
		2480	else
		2481	{
		2482	Store (56, WRD) // pass -- just do something
		2483	}
		2484
		2485
		2486	// Test If (LNot ()) with no save of LNot result
		2487	If (LNot (0))
		2488	{
		2489	Store (61, WRD) // pass -- just do something
		2490	}
		2491	else
		2492	{
		2493	Return (61) // fail
		2494	}
		2495
		2496	// Test If (LNot ()) with no save of LNot result
		2497	If (LNot (1))
		2498	{
		2499	Return (62) // fail
		2500	}
		2501	else
		2502	{
		2503	Store (62, WRD) // pass -- just do something
		2504	}
		2505
		2506
		2507	// Test If (LNotEqual ()) with no save of LNotEqual result
		2508	If (LNotEqual (3, 3))
		2509	{
		2510	Return (63) // fail
		2511	}
		2512	else
		2513	{
		2514	Store (63, WRD) // pass -- just do something
		2515	}
		2516
		2517	// Test If (LNotEqual ()) with no save of LNotEqual result
		2518	If (LNotEqual (1, 3))
		2519	{
		2520	Store (64, WRD) // pass -- just do something
		2521	}
		2522	else
		2523	{
		2524	Return (64) // fail
		2525	}
		2526
		2527
		2528	// Test If (LOr ()) with no save of LOr result
		2529	If (LOr (3, 1))
		2530	{
		2531	Store (71, WRD) // pass -- just do something
		2532	}
		2533	else
		2534	{
		2535	Return (71) // fail
		2536	}
		2537
		2538	// Test If (LOr ()) with no save of LOr result
		2539	If (LOr (0, 1))
		2540	{
		2541	Store (72, WRD) // pass -- just do something
		2542	}
		2543	else
		2544	{
		2545	Return (72) // fail
		2546	}
		2547
		2548	// Test If (LOr ()) with no save of LOr result
		2549	If (LOr (3, 0))
		2550	{
		2551	Store (73, WRD) // pass -- just do something
		2552	}
		2553	else
		2554	{
		2555	Return (73) // fail
		2556	}
		2557
		2558	// Test If (LOr ()) with no save of LOr result
		2559	If (LOr (0, 0))
		2560	{
		2561	Return (74) // fail
		2562	}
		2563	else
		2564	{
		2565	Store (74, WRD) // pass -- just do something
		2566	}
		2567
		2568	Return (0)
		2569	} // TEST
		2570	} // NOSV
		2571
		2572
		2573	//
		2574	// test IndxFld.asl
		2575	//
		2576	// IndexFld test
		2577	// This is just a subset of the many RegionOp/Index Field test cases.
		2578	// Tests index field element AccessAs macro.
		2579	//
		2580	Device (IDXF)
		2581	{ // Test device name
		2582
		2583	OperationRegion (SIO, SystemIO, 0x100, 2)
		2584	Field (SIO, ByteAcc, NoLock, Preserve)
		2585	{
		2586	INDX, 8,
		2587	DATA, 8
		2588	}
		2589	IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
		2590	{
		2591	AccessAs (ByteAcc, 0),
		2592	IFE0, 8,
		2593	IFE1, 8,
		2594	IFE2, 8,
		2595	IFE3, 8,
		2596	IFE4, 8,
		2597	IFE5, 8,
		2598	IFE6, 8,
		2599	IFE7, 8,
		2600	IFE8, 8,
		2601	IFE9, 8,
		2602	}
		2603
		2604	Method (TEST)
		2605	{
		2606	Store ("++++++++ IndxFld Test", Debug)
		2607
		2608	Store (IFE0, Local0)
		2609	Store (IFE1, Local1)
		2610	Store (IFE2, Local2)
		2611
		2612	Return (0)
		2613	} // TEST
		2614	} // IDXF
		2615
		2616	//
		2617	// test NestdLor.asl
		2618	//
		2619	Scope (\_SB) // System Bus
		2620	{ // _SB system bus
		2621
		2622	Name (ZER0, 0)
		2623	Name (ZER1, 0)
		2624	Name (ZER2, 0)
		2625	Name (ONE0, 1)
		2626
		2627	Device (NSTL)
		2628	{
		2629	Method (TEST)
		2630	{
		2631	Store ("++++++++ NestdLor Test", Debug)
		2632
		2633	If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0))))
		2634	{ // Indicate Pass
		2635	Store (0x00, Local0)
		2636	}
		2637
		2638	Else
		2639	{ // Indicate Fail
		2640	Store (0x01, Local0)
		2641	}
		2642
		2643	Return (Local0)
		2644	} // End Method TEST
		2645	} // Device NSTL
		2646	} // _SB system bus
		2647
		2648	//
		2649	// test RetBuf.asl
		2650	//
		2651	// Test ReturnOp(Buffer)
		2652	// This is required to support Control Method Batteries on
		2653	// Dell Latitude Laptops (e.g., CP1-A)
		2654	//
		2655	Device (RTBF)
		2656	{
		2657	Method (SUBR, 1)
		2658	{
		2659	Return (Arg0)
		2660	}
		2661
		2662	Method (RBUF)
		2663	{ // RBUF: Return Buffer from local variable
		2664	Name (ABUF, Buffer() {"ARBITRARY_BUFFER"})
		2665
		2666	// store local buffer ABUF into Local0
		2667	Store (ABUF, Local0)
		2668
		2669	// save Local0 object type value into Local1
		2670	Store (ObjectType (Local0), Local1)
		2671
		2672	// validate Local0 is a Buffer
		2673	If (LNotEqual (Local1, 3)) // Buffer type is 3
		2674	{
		2675	Return (1) // failure
		2676	}
		2677
		2678	// store value returned by control method SUBR into Local0
		2679	Store (SUBR (ABUF), Local0)
		2680
		2681	// save Local0 object type value into Local1
		2682	Store (ObjectType (Local0), Local1)
		2683
		2684	// validate Local0 is a Buffer
		2685	If (LNotEqual (Local1, 3)) // Buffer type is 3
		2686	{
		2687	Return (2) // failure
		2688	}
		2689
		2690	// allocate buffer using Local1 as buffer size (run-time evaluation)
		2691	Store (5, Local1)
		2692	Name (BUFR, Buffer(Local1) {})
		2693
		2694	// store value returned by control method SUBR into Local0
		2695	Store (SUBR (BUFR), Local0)
		2696
		2697	// save Local0 object type value into Local1
		2698	Store (ObjectType (Local0), Local1)
		2699
		2700	// validate Local0 is a Buffer
		2701	If (LNotEqual (Local1, 3)) // Buffer type is 3
		2702	{
		2703	Return (3) // failure
		2704	}
		2705
		2706	// store BUFR Buffer into Local0
		2707	Store (BUFR, Local0)
		2708
		2709	// save Local0 object type value into Local1
		2710	Store (ObjectType (Local0), Local1)
		2711
		2712	// validate Local0 is a Buffer
		2713	If (LNotEqual (Local1, 3)) // Buffer type is 3
		2714	{
		2715	Return (4) // failure
		2716	}
		2717
		2718
		2719	// return Local0 Buffer
		2720	Return (Local0)
		2721	} // RBUF
		2722
		2723	Method (TEST)
		2724	{
		2725	Store ("++++++++ RetBuf Test", Debug)
		2726
		2727	// store RBUF Buffer return value into Local0
		2728	Store (RBUF, Local0)
		2729
		2730	// save Local0 object type value into Local1
		2731	Store (ObjectType (Local0), Local1)
		2732
		2733	// validate Local0 is a Buffer
		2734	If (LNotEqual (Local1, 3)) // Buffer type is 3
		2735	{
		2736	Return (10) // failure
		2737	}
		2738	Else
		2739	{
		2740	Return (0) // success
		2741	}
		2742	} // TEST
		2743	} // RTBF
		2744
		2745	//
		2746	// test RetLVal.asl
		2747	//
		2748	// Test ReturnOp(Lvalue)
		2749	// This is required to support _PSR on IBM ThinkPad 560D and
		2750	// _DCK on Toshiba Tecra 8000.
		2751	//
		2752
		2753	Device (GPE2)
		2754	{
		2755	Method (_L03)
		2756	{
		2757	Store ("Method GPE2._L03 invoked", Debug)
		2758	Return ()
		2759	}
		2760
		2761	Method (_E05)
		2762	{
		2763	Store ("Method GPE2._E05 invoked", Debug)
		2764	Return ()
		2765	}
		2766	}
		2767
		2768	Device (PRW2)
		2769	{
		2770	Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3})
		2771	}
		2772
		2773
		2774	Scope (\_GPE)
		2775	{
		2776	Name (ACST, 0xFF)
		2777
		2778	Method (_L08)
		2779	{
		2780	Store ("Method _GPE._L08 invoked", Debug)
		2781	Return ()
		2782	}
		2783
		2784	Method (_E09)
		2785	{
		2786	Store ("Method _GPE._E09 invoked", Debug)
		2787	Return ()
		2788	}
		2789
		2790	Method (_E11)
		2791	{
		2792	Store ("Method _GPE._E11 invoked", Debug)
		2793	Notify (\PRW1, 2)
		2794	}
		2795
		2796	Method (_L22)
		2797	{
		2798	Store ("Method _GPE._L22 invoked", Debug)
		2799	Return ()
		2800	}
		2801
		2802	Method (_L33)
		2803	{
		2804	Store ("Method _GPE._L33 invoked", Debug)
		2805	Return ()
		2806	}
		2807
		2808	Method (_E64)
		2809	{
		2810	Store ("Method _GPE._E64 invoked", Debug)
		2811	Return ()
		2812	}
		2813
		2814	} // _GPE
		2815
		2816	Device (PRW1)
		2817	{
		2818	Name (_PRW, Package(2) {0x11, 3})
		2819	}
		2820
		2821	Device (PWRB)
		2822	{
		2823	Name (_HID, EISAID("PNP0C0C"))
		2824	Name (_PRW, Package(2) {0x33, 3})
		2825	}
		2826
		2827
		2828	Scope (\_SB) // System Bus
		2829	{ // _SB system bus
		2830
		2831	Device (ACAD)
		2832	{ // ACAD: AC adapter device
		2833	Name (_HID, "ACPI0003") // AC adapter device
		2834
		2835	Name (_PCL, Package () {\_SB})
		2836
		2837	OperationRegion (AREG, SystemIO, 0x0372, 2)
		2838	Field (AREG, ByteAcc, NoLock, Preserve)
		2839	{
		2840	AIDX, 8,
		2841	ADAT, 8
		2842	}
		2843	IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
		2844	{
		2845	, 1, // skips
		2846	ACIN, 1,
		2847	, 2, // skips
		2848	CHAG, 1,
		2849	, 3, // skips
		2850	, 7, // skips
		2851	ABAT, 1,
		2852	} // IndexField
		2853
		2854	Method (_PSR)
		2855	{
		2856	Store (\_GPE.ACST, Local0)
		2857	Store (ACIN, Local1)
		2858	If (LNotEqual (\_GPE.ACST, Local1))
		2859	{
		2860	Store (Local1, \_GPE.ACST)
		2861	// This Notify is commented because it causes a
		2862	// method error when running on a system without the
		2863	// specific device.
		2864	// Notify (\_SB_.ACAD, 0)
		2865	}
		2866	Return (Local0)
		2867	} // _PSR
		2868
		2869	Method (_STA)
		2870	{
		2871	Return (0x0F)
		2872	}
		2873
		2874	Method (_INI)
		2875	{
		2876	Store (ACIN, \_GPE.ACST)
		2877	}
		2878	} // ACAD: AC adapter device
		2879
		2880	// test implicit return from control method
		2881	Method (DIS_, 1)
		2882	{
		2883	Store (Arg0, Local0)
		2884	}
		2885
		2886	Device (RTLV)
		2887	{
		2888	// test implicit return inside nested if with explicit return of Lvalue
		2889	Method (_DCK, 1)
		2890	// Arg0: 1 == dock, 0 == undock
		2891	{
		2892	If (Arg0)
		2893	{ // dock
		2894	Store (0x87, Local0)
		2895
		2896	If (Local0)
		2897	{
		2898	DIS_ (0x23)
		2899	Return (1)
		2900	}
		2901
		2902	Return (0)
		2903	} // dock
		2904	Else
		2905	{ // undock
		2906	Store (Arg0, Local0)
		2907
		2908	If (Local0)
		2909	{
		2910	DIS_ (0x23)
		2911	Return (1)
		2912	}
		2913
		2914	Return (0)
		2915	} // undock
		2916	} // _DCK control method
		2917
		2918	Method (TEST)
		2919	{
		2920	Store ("++++++++ RetLVal Test", Debug)
		2921
		2922	// store _PSR return value into Local0
		2923	Store (\_SB_.ACAD._PSR, Local0)
		2924
		2925	// save Local0 object type value into Local1
		2926	Store (ObjectType (Local0), Local1)
		2927
		2928	// validate Local0 is a Number
		2929	If (LNotEqual (Local1, 1)) // Number/Integer type is 1
		2930	{
		2931	Return (1) // failure
		2932	}
		2933
		2934	// test implicit return inside nested if with explicit return of Lvalue
		2935	Store (_DCK (1), Local2)
		2936
		2937	// save Local2 object type value into Local3
		2938	Store (ObjectType (Local2), Local3)
		2939
		2940	// validate Local2 is a Number
		2941	If (LNotEqual (Local3, 1)) // Number/Integer type is 1
		2942	{
		2943	Return (2) // failure
		2944	}
		2945
		2946	If (LNotEqual (Local2, 1))
		2947	{
		2948	Return (3) // failure
		2949	}
		2950
		2951	Return (0) // success
		2952	} // TEST
		2953	} // RTLV
		2954	} // _SB system bus
		2955
		2956	//
		2957	// test RetPkg.asl
		2958	//
		2959	// Test ReturnOp(Package)
		2960	// This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1)
		2961	//
		2962
		2963	Scope (\_SB) // System Bus
		2964	{ // _SB system bus
		2965	Device(LNKA)
		2966	{
		2967	Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
		2968	Name (_UID, 1)
		2969	}
		2970	Device(LNKB)
		2971	{
		2972	Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
		2973	Name (_UID, 2)
		2974	}
		2975	Device(LNKC)
		2976	{
		2977	Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
		2978	Name (_UID, 3)
		2979	}
		2980	Device(LNKD)
		2981	{
		2982	Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
		2983	Name (_UID, 4)
		2984	}
		2985
		2986	Device (PCI1)
		2987	{ // PCI1: Root PCI Bus
		2988	Name (_HID, "PNP0A03") // Need _HID for root device (String format)
		2989	Name (_ADR,0x00000000)
		2990	Name (_CRS,0)
		2991
		2992	Name (_PRT, Package ()
		2993	{
		2994	Package () {0x0004ffff, 0, LNKA, 0}, // Slot 1, INTA
		2995	Package () {0x0004ffff, 1, LNKB, 0}, // Slot 1, INTB
		2996	Package () {0x0004ffff, 2, LNKC, 0}, // Slot 1, INTC
		2997	Package () {0x0004ffff, 3, LNKD, 0}, // Slot 1, INTD
		2998	Package () {0x0005ffff, 0, \_SB_.LNKB, 0}, // Slot 2, INTA
		2999	Package () {0x0005ffff, 1, \_SB_.LNKC, 0}, // Slot 2, INTB
		3000	Package () {0x0005ffff, 2, \_SB_.LNKD, 0}, // Slot 2, INTC
		3001	Package () {0x0006ffff, 3, \_SB_.LNKA, 0}, // Slot 2, INTD
		3002	Package () {0x0006ffff, 0, LNKC, 0}, // Slot 3, INTA
		3003	Package () {0x0006ffff, 1, LNKD, 0}, // Slot 3, INTB
		3004	Package () {0x0006ffff, 2, LNKA, 0}, // Slot 3, INTC
		3005	Package () {0x0006ffff, 3, LNKB, 0}, // Slot 3, INTD
		3006	})
		3007
		3008	Device (PX40)
		3009	{ // Map f0 space, Start PX40
		3010	Name (_ADR,0x00070000) // Address+function.
		3011	}
		3012	} // PCI0: Root PCI Bus
		3013
		3014	Device (RETP)
		3015	{
		3016	Method (RPKG)
		3017	{ // RPKG: Return Package from local variable
		3018
		3019	// store _PRT package into Local0
		3020	Store (\_SB_.PCI1._PRT, Local0)
		3021
		3022	// return Local0 Package
		3023	Return (Local0)
		3024	} // RPKG
		3025
		3026	Method (TEST)
		3027	{
		3028	Store ("++++++++ RetPkg Test", Debug)
		3029
		3030	// store RPKG package return value into Local0
		3031	Store (RPKG, Local0)
		3032
		3033	// save Local0 object type value into Local1
		3034	Store (ObjectType (Local0), Local1)
		3035
		3036	// validate Local0 is a Package
		3037	If (LNotEqual (Local1, 4)) // Package type is 4
		3038	{ Return (1) } // failure
		3039	Else
		3040	{ Return (0) } // success
		3041	} // TEST
		3042	} // RETP
		3043	} // _SB_
		3044
		3045	//
		3046	// test WhileRet.asl
		3047	//
		3048	// WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp.
		3049	//
		3050	Device (WHLR)
		3051	{
		3052	Name (LCNT, 0)
		3053	Method (WIR)
		3054	{ // WIR: control method that returns inside of IfOp inside of WhileOp
		3055	While (LLess (LCNT, 4))
		3056	{
		3057	If (LEqual (LCNT, 2))
		3058	{
		3059	Return (0)
		3060	}
		3061
		3062	Increment (LCNT)
		3063	}
		3064
		3065	Return (LCNT)
		3066	} // WIR: control method that returns inside of IfOp inside of WhileOp
		3067
		3068	Method (TEST)
		3069	{
		3070	Store ("++++++++ WhileRet Test", Debug)
		3071
		3072	Store (WIR, Local0)
		3073
		3074	Return (Local0)
		3075	} // TEST
		3076	} // WHLR
		3077
		3078	//
		3079	// test AndOrOp.asl
		3080	//
		3081	//This code tests the bitwise AndOp and OrOp Operator terms
		3082	//
		3083	//Syntax of Andop term
		3084	//And - Bitwise And
		3085	//AndTerm := And(
		3086	// Source1, //TermArg=>Integer
		3087	// Source2, //TermArg=>Integer
		3088	// Result //Nothing \| SuperName
		3089	//) => Integer
		3090	//Source1 and Source2 are evaluated as integer data types,
		3091	// a bit-wise AND is performed, and the result is optionally
		3092	//stored into Result.
		3093	//
		3094	//
		3095	//Syntax of OrOp
		3096	//Or - Bit-wise Or
		3097	//OrTerm := Or(
		3098	// Source1, //TermArg=>Integer
		3099	// Source2 //TermArg=>Integer
		3100	// Result //Nothing \| SuperName
		3101	//) => Integer
		3102	//Source1 and Source2 are evaluated as integer data types,
		3103	// a bit-wide OR is performed, and the result is optionally
		3104	//stored in Result
		3105	//
		3106	Device (ANDO)
		3107	{
		3108	OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
		3109	Field (TMEM, ByteAcc, NoLock, Preserve)
		3110	{
		3111	, 3,
		3112	TOUD, 13
		3113	}
		3114
		3115	//Create System Memory Operation Region and field overlays
		3116	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		3117	Field (RAM, AnyAcc, NoLock, Preserve)
		3118	{
		3119	SMDW, 32, // 32-bit DWORD
		3120	SMWD, 16, // 16-bit WORD
		3121	SMBY, 8, // 8-bit BYTE
		3122	}// Field(RAM)
		3123
		3124
		3125	//And with Byte Data
		3126	Name (BYT1, 0xff)
		3127	Name (BYT2, 0xff)
		3128	Name (BRSL, 0x00)
		3129
		3130	//And with Word Data
		3131	Name (WRD1, 0xffff)
		3132	Name (WRD2, 0xffff)
		3133	Name (WRSL, 0x0000)
		3134
		3135	//And with DWord Data
		3136	Name (DWD1, 0xffffffff)
		3137	Name (DWD2, 0xffffffff)
		3138	Name (DRSL, 0x00000000)
		3139
		3140	Method (ANDP)
		3141	{
		3142	//Check with 1 And 1 on byte data
		3143	And(BYT1, BYT2, BRSL)
		3144	if(LNotEqual(BRSL,0xff))
		3145	{Return(1)}
		3146
		3147	//Check with 1 And 1 on Word data
		3148	And(WRD1, WRD2, WRSL)
		3149	if(LNotEqual(WRSL,0xffff))
		3150	{
		3151	Return (1) // failure
		3152	}
		3153
		3154	//Check with 1 And 1 Dword
		3155	And(DWD1, DWD2, DRSL)
		3156	if(LNotEqual(DRSL,0xffffffff))
		3157	{
		3158	Return (1) // failure
		3159	}
		3160
		3161	//Check with 0 And 0 on byte data
		3162	Store(0x00,BYT1)
		3163	Store(0x00,BYT2)
		3164	Store(0x00,BRSL)
		3165	And(BYT1, BYT2, BRSL)
		3166	if(LNotEqual(BRSL,0x00))
		3167	{
		3168	Return (1) // failure
		3169	}
		3170
		3171	//Check with 0 And 0 on Word data
		3172	Store (0x0000,WRD1)
		3173	Store (0x0000,WRD2)
		3174	Store (0x0000,WRSL)
		3175	And(WRD1, WRD2, WRSL)
		3176	if(LNotEqual(WRSL,0x0000))
		3177	{
		3178	Return (1) // failure
		3179	}
		3180
		3181	//Check with 0 And 0 Dword
		3182	Store (0x00000000,DWD1)
		3183	Store (0x00000000,DWD2)
		3184	Store (0x00000000,DRSL)
		3185	And(DWD1, DWD2, DRSL)
		3186	if(LNotEqual(DRSL,0x00000000))
		3187	{
		3188	Return (1) // failure
		3189	}
		3190
		3191
		3192	//Check with 1 And 0 on byte data
		3193	Store(0x55,BYT1)
		3194	Store(0xAA,BYT2)
		3195	Store(0x00,BRSL)
		3196	And(BYT1, BYT2, BRSL)
		3197	if(LNotEqual(BRSL,0x00))
		3198	{
		3199	Return (1) // failure
		3200	}
		3201
		3202	//Check with 1 And 0 on Word data
		3203	Store (0x5555,WRD1)
		3204	Store (0xAAAA,WRD2)
		3205	Store (0x0000,WRSL)
		3206	And(WRD1, WRD2, WRSL)
		3207	if(LNotEqual(WRSL,0x0000))
		3208	{
		3209	Return (1) // failure
		3210	}
		3211
		3212	//Check with 1 And 0 on Dword
		3213	Store (0x55555555,DWD1)
		3214	Store (0xAAAAAAAA,DWD2)
		3215	Store (0x00000000,DRSL)
		3216	And(DWD1, DWD2, DRSL)
		3217	if(LNotEqual(DRSL,0x00000000))
		3218	{
		3219	Return (1) // failure
		3220	}
		3221
		3222	Store (0x1FFF, TOUD)
		3223	Store (TOUD, Local0)
		3224	if(LNotEqual(Local0,0x1FFF))
		3225	{
		3226	Return (1) // failure
		3227	}
		3228
		3229	//TBD- Do We need to check for system memory data also for each test case ??
		3230
		3231	Return(0)
		3232
		3233	}//ANDP
		3234
		3235	Method (OROP)
		3236	{
		3237
		3238	//Check with 1 Ored with 1 on byte data
		3239	Store(0xff,BYT1)
		3240	Store(0xff,BYT2)
		3241	Store(0x00,BRSL)
		3242	Or(BYT1, BYT2, BRSL)
		3243	if(LNotEqual(BRSL,0xff))
		3244	{
		3245	Return (1) // failure
		3246	}
		3247
		3248
		3249	//Check with 1 Ored with 1 on Word data
		3250	Store(0xffff,WRD1)
		3251	Store(0xffff,WRD2)
		3252	Store(0x0000,WRSL)
		3253	Or(WRD1, WRD2, WRSL)
		3254	if(LNotEqual(WRSL,0xffff))
		3255	{
		3256	Return (1) // failure
		3257	}
		3258
		3259	//Check with 1 Ored with 1 on Dword data
		3260	Store(0xffffffff,DWD1)
		3261	Store(0xffffffff,DWD2)
		3262	Store(0x00000000,DRSL)
		3263	Or(DWD1, DWD2, DRSL)
		3264	if(LNotEqual(DRSL,0xffffffff))
		3265	{
		3266	Return (1) // failure
		3267	}
		3268
		3269	//Check with 0 Ored with 0 on byte data
		3270	Store(0x00,BYT1)
		3271	Store(0x00,BYT2)
		3272	Store(0x00,BRSL)
		3273	Or(BYT1, BYT2, BRSL)
		3274	if(LNotEqual(BRSL,0x00))
		3275	{
		3276	Return (1) // failure
		3277	}
		3278
		3279	//Check with 0 Ored with 0 on Word data
		3280	Store (0x0000,WRD1)
		3281	Store (0x0000,WRD2)
		3282	Store (0x0000,WRSL)
		3283	Or(WRD1, WRD2, WRSL)
		3284	if(LNotEqual(WRSL,0x0000))
		3285	{
		3286	Return (1) // failure
		3287	}
		3288
		3289	//Check with 0 Ored with 0 Dword data
		3290	Store (0x00000000,DWD1)
		3291	Store (0x00000000,DWD2)
		3292	Store (0x00000000,DRSL)
		3293	Or(DWD1, DWD2, DRSL)
		3294	if(LNotEqual(DRSL,0x00000000))
		3295	{
		3296	Return (1) // failure
		3297	}
		3298
		3299
		3300	//Check with 1 Ored with 0 on byte data
		3301	Store(0x55,BYT1)
		3302	Store(0xAA,BYT2)
		3303	Store(0x00,BRSL)
		3304	Or(BYT1, BYT2, BRSL)
		3305	if(LNotEqual(BRSL,0xff))
		3306	{
		3307	Return (1) // failure
		3308	}
		3309
		3310	//Check with 1 Ored with 0 on Word data
		3311	Store (0x5555,WRD1)
		3312	Store (0xAAAA,WRD2)
		3313	Store (0x0000,WRSL)
		3314	Or(WRD1, WRD2, WRSL)
		3315	if(LNotEqual(WRSL,0xffff))
		3316	{
		3317	Return (1) // failure
		3318	}
		3319
		3320	//Check with 1 Ored with 0 on Dword data
		3321	Store (0x55555555,DWD1)
		3322	Store (0xAAAAAAAA,DWD2)
		3323	Store (0x00000000,DRSL)
		3324	Or(DWD1, DWD2, DRSL)
		3325	if(LNotEqual(DRSL,0xffffffff))
		3326	{
		3327	Return (1) // failure
		3328	}
		3329
		3330	//TBD - Do We need to check for system memory data also for each test case ??
		3331
		3332	Return(0)
		3333
		3334	}//OROP
		3335
		3336	Method(TEST)
		3337	{
		3338	Store ("++++++++ AndOrOp Test", Debug)
		3339
		3340	Name(RSLT,1)
		3341	//Call Andop method
		3342	Store(ANDP,RSLT)
		3343	if(LEqual(RSLT,1))
		3344	{
		3345	Return (RSLT)
		3346	}
		3347
		3348	//Call OrOp Method
		3349	Store(OROP,RSLT)
		3350	if(LEqual(RSLT,1))
		3351	{
		3352	Return(RSLT)
		3353	}
		3354
		3355	//
		3356	// Return original conditions to allow iterative execution
		3357	//
		3358	Store(0xff,BYT1)
		3359	Store(0xff,BYT2)
		3360	Store(0x00,BRSL)
		3361	Store (0xffff,WRD1)
		3362	Store (0xffff,WRD2)
		3363	Store (0x0000,WRSL)
		3364	Store (0xffffffff,DWD1)
		3365	Store (0xffffffff,DWD2)
		3366	Store (0x00000000,DRSL)
		3367
		3368	Return(0)
		3369	} //TEST
		3370	} //ANDO
		3371
		3372	//
		3373	// test BreakPnt.asl
		3374	//
		3375	// This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is
		3376	// BreakPointTerm := BreakPoint
		3377	// Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger.
		3378	// In the non-debug version of the interpreter, BreakPoint is equivalent to Noop.
		3379	//
		3380	Device (BRKP)
		3381	{
		3382	Name(CNT0,0)
		3383
		3384	Method (BK1)
		3385	{
		3386	BreakPoint
		3387	Return(0)
		3388	}
		3389
		3390	Method (TEST)
		3391	{
		3392	Store ("++++++++ BreakPnt Test", Debug)
		3393
		3394	Store(0,CNT0)
		3395
		3396	//Check BreakPoint statement
		3397	While(LLess(CNT0,10))
		3398	{
		3399	Increment(CNT0)
		3400	}
		3401
		3402	//Check the BreakPoint statement
		3403	If(LEqual(CNT0,10))
		3404	{
		3405	// BreakPoint
		3406	Return(0)
		3407	}
		3408
		3409	//failed
		3410	Return(1)
		3411	}
		3412	}
		3413
		3414	//
		3415	// test AddSubOp.asl
		3416	//
		3417	Device (ADSU)
		3418	{
		3419	// create System Memory Operation Region and field overlays
		3420	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		3421	Field (RAM, AnyAcc, NoLock, Preserve)
		3422	{
		3423	SMDW, 32, // 32-bit DWORD
		3424	SMWD, 16, // 16-bit WORD
		3425	SMBY, 8, // 8-bit BYTE
		3426	} // Field(RAM)
		3427
		3428	Method (TEST)
		3429	{
		3430	Store ("++++++++ AddSubOp Test", Debug)
		3431
		3432	Name (DWRD, 0x12345678)
		3433	Name (WRD, 0x1234)
		3434	Name (BYT, 0x12)
		3435
		3436	// Test AddOp with DWORD data
		3437	Store (0x12345678, DWRD)
		3438	Add (DWRD, 7, DWRD)
		3439	If (LNotEqual (DWRD, 0x1234567F))
		3440	{ Return (DWRD) }
		3441
		3442	// Test AddOp with WORD data
		3443	Add (WRD, 5, WRD)
		3444	If (LNotEqual (WRD, 0x1239))
		3445	{ Return (WRD) }
		3446
		3447	// Test AddOp with BYTE data
		3448	Add (BYT, 3, BYT)
		3449	If (LNotEqual (BYT, 0x15))
		3450	{ Return (BYT) }
		3451
		3452	// Test SubtractOp with DWORD data
		3453	Subtract (DWRD, 7, DWRD)
		3454	If (LNotEqual (DWRD, 0x12345678))
		3455	{ Return (DWRD) }
		3456
		3457	// Test SubtractOp with WORD data
		3458	Subtract (WRD, 3, WRD)
		3459	If (LNotEqual (WRD, 0x1236))
		3460	{ Return (WRD) }
		3461
		3462	// Test SubtractOp with BYTE data
		3463	Subtract (BYT, 3, BYT)
		3464	If (LNotEqual (BYT, 0x12))
		3465	{ Return (BYT) }
		3466
		3467
		3468	// test AddOp with DWORD SystemMemory OpRegion
		3469	Store (0x01234567, SMDW)
		3470	Add (SMDW, 8, SMDW)
		3471	If (LNotEqual (SMDW, 0x0123456F))
		3472	{ Return (SMDW) }
		3473
		3474	// test SubtractOp with DWORD SystemMemory OpRegion
		3475	Subtract (SMDW, 7, SMDW)
		3476	If (LNotEqual (SMDW, 0x01234568))
		3477	{ Return (SMDW) }
		3478
		3479
		3480	// test AddOp with WORD SystemMemory OpRegion
		3481	Store (0x0123, SMWD)
		3482	Add (SMWD, 6, SMWD)
		3483	If (LNotEqual (SMWD, 0x0129))
		3484	{ Return (SMWD) }
		3485
		3486	// test SubtractOp with WORD SystemMemory OpRegion
		3487	Subtract (SMWD, 5, SMWD)
		3488	If (LNotEqual (SMWD, 0x0124))
		3489	{ Return (SMWD) }
		3490
		3491
		3492	// test AddOp with BYTE SystemMemory OpRegion
		3493	Store (0x01, SMBY)
		3494	Add (SMBY, 4, SMBY)
		3495	If (LNotEqual (SMBY, 0x05))
		3496	{ Return (SMBY) }
		3497
		3498	// test SubtractOp with BYTE SystemMemory OpRegion
		3499	Subtract (SMBY, 3, SMBY)
		3500	If (LNotEqual (SMBY, 0x02))
		3501	{ Return (SMBY) }
		3502
		3503	Return (0)
		3504	} // TEST
		3505	} // ADSU
		3506
		3507	//
		3508	// test IncDecOp.asl
		3509	//
		3510	Device (INDC)
		3511	{
		3512	// create System Memory Operation Region and field overlays
		3513	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		3514	Field (RAM, AnyAcc, NoLock, Preserve)
		3515	{
		3516	SMDW, 32, // 32-bit DWORD
		3517	SMWD, 16, // 16-bit WORD
		3518	SMBY, 8, // 8-bit BYTE
		3519	} // Field(RAM)
		3520
		3521	Method (TEST)
		3522	{
		3523	Store ("++++++++ IncDecOp Test", Debug)
		3524
		3525	Name (DWRD, 0x12345678)
		3526	Name (WRD, 0x1234)
		3527	Name (BYT, 0x12)
		3528
		3529	// Test IncrementOp with DWORD data
		3530	Store (0x12345678, DWRD)
		3531	Increment (DWRD)
		3532	If (LNotEqual (DWRD, 0x12345679))
		3533	{ Return (DWRD) }
		3534
		3535	// Test IncrementOp with WORD data
		3536	Increment (WRD)
		3537	If (LNotEqual (WRD, 0x1235))
		3538	{ Return (WRD) }
		3539
		3540	// Test IncrementOp with BYTE data
		3541	Increment (BYT)
		3542	If (LNotEqual (BYT, 0x13))
		3543	{ Return (BYT) }
		3544
		3545	// Test DecrementOp with DWORD data
		3546	Decrement (DWRD)
		3547	If (LNotEqual (DWRD, 0x12345678))
		3548	{ Return (DWRD) }
		3549
		3550	// Test DecrementOp with WORD data
		3551	Decrement (WRD)
		3552	If (LNotEqual (WRD, 0x1234))
		3553	{ Return (WRD) }
		3554
		3555	// Test DecrementOp with BYTE data
		3556	Decrement (BYT)
		3557	If (LNotEqual (BYT, 0x12))
		3558	{ Return (BYT) }
		3559
		3560
		3561	// test IncrementOp with DWORD SystemMemory OpRegion
		3562	Store (0x01234567, SMDW)
		3563	Increment (SMDW)
		3564	If (LNotEqual (SMDW, 0x01234568))
		3565	{ Return (SMDW) }
		3566
		3567	// test DecrementOp with DWORD SystemMemory OpRegion
		3568	Decrement (SMDW)
		3569	If (LNotEqual (SMDW, 0x01234567))
		3570	{ Return (SMDW) }
		3571
		3572
		3573	// test IncrementOp with WORD SystemMemory OpRegion
		3574	Store (0x0123, SMWD)
		3575	Increment (SMWD)
		3576	If (LNotEqual (SMWD, 0x0124))
		3577	{ Return (SMWD) }
		3578
		3579	// test DecrementOp with WORD SystemMemory OpRegion
		3580	Decrement (SMWD)
		3581	If (LNotEqual (SMWD, 0x0123))
		3582	{ Return (SMWD) }
		3583
		3584
		3585	// test IncrementOp with BYTE SystemMemory OpRegion
		3586	Store (0x01, SMBY)
		3587	Increment (SMBY)
		3588	If (LNotEqual (SMBY, 0x02))
		3589	{ Return (SMBY) }
		3590
		3591	// test DecrementOp with BYTE SystemMemory OpRegion
		3592	Decrement (SMBY)
		3593	If (LNotEqual (SMBY, 0x01))
		3594	{ Return (SMBY) }
		3595
		3596	Return (0)
		3597	} // TEST
		3598	} // INDC
		3599
		3600	//
		3601	// test LOps.asl
		3602	//
		3603	//This source tests all the logical operators. Logical operators in ASL are as follows.
		3604	//LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr.
		3605	// Success will return 0 and failure will return a non zero number. Check the source code for
		3606	// non zero number to find where the test failed
		3607
		3608	Device (LOPS)
		3609	{
		3610	//Create System Memory Operation Region and field overlays
		3611	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		3612	Field (RAM, AnyAcc, NoLock, Preserve)
		3613	{
		3614	SMDW, 32, // 32-bit DWORD
		3615	SMWD, 16, // 16-bit WORD
		3616	SMBY, 8, // 8-bit BYTE
		3617	}// Field(RAM)
		3618
		3619	//And with Byte Data
		3620	Name (BYT1, 0xff)
		3621	Name (BYT2, 0xff)
		3622	Name (BRSL, 0x00)
		3623
		3624	//And with Word Data
		3625	Name (WRD1, 0xffff)
		3626	Name (WRD2, 0xffff)
		3627	Name (WRSL, 0x0000)
		3628
		3629	//And with DWord Data
		3630	Name (DWD1, 0xffffffff)
		3631	Name (DWD2, 0xffffffff)
		3632	Name (DRSL, 0x00000000)
		3633
		3634	Name(RSLT,1)
		3635
		3636	Method (ANDL,2) // Test Logical And
		3637	{
		3638	//test with the arguments passed
		3639	if(LEqual(Arg0,Arg1))
		3640	{ Store(LAnd(Arg0,Arg1),RSLT)
		3641	if(LNotEqual(Ones,RSLT))
		3642	{Return(11)}
		3643	}
		3644
		3645	//test with he locals
		3646	Store(Arg0,Local0)
		3647	Store(Arg1,Local1)
		3648
		3649	if(LEqual(Local0,Local1))
		3650	{
		3651	Store(LAnd(Local0,Local1),RSLT)
		3652	if(LNotEqual(Ones,RSLT))
		3653	{Return(12)}
		3654	}
		3655
		3656	//test with BYTE data
		3657	if(LEqual(BYT1,BYT2))
		3658	{ Store(LAnd(BYT1,BYT2),BRSL)
		3659	if(LNotEqual(Ones,BRSL))
		3660	{Return(13)}
		3661	}
		3662
		3663	//test with WORD data
		3664	if(LEqual(WRD1,WRD2))
		3665	{ Store(LAnd(WRD1,WRD2),WRSL)
		3666	if(LNotEqual(Ones,WRSL))
		3667	{Return(14)}
		3668	}
		3669
		3670	//test with DWORD data
		3671	if(LEqual(DWD1,DWD2))
		3672	{ Store(LAnd(DWD1,DWD2),DRSL)
		3673	if(LNotEqual(Ones,DRSL))
		3674	{Return(15)}
		3675	}
		3676
		3677	//Test for system memory data for each test case.
		3678
		3679	Store(0xff,BYT1)
		3680	Store(0xff,SMBY)
		3681	Store(0x00,BRSL)
		3682
		3683	//test with BYTE system memory data
		3684	if(LEqual(BYT1,SMBY))
		3685	{ Store(LAnd(BYT1,SMBY),BRSL)
		3686	if(LNotEqual(Ones,BRSL))
		3687	{Return(16)}
		3688	}
		3689
		3690	Store (0xffff,WRD1)
		3691	Store(0xffff,SMWD)
		3692	Store(0x0000,WRSL)
		3693	//test with WORD system memory data
		3694	if(LEqual(WRD1,SMWD))
		3695	{ Store(LAnd(WRD1,SMWD),WRSL)
		3696	if(LNotEqual(Ones,WRSL))
		3697	{Return(17)}
		3698	}
		3699
		3700	Store(0x000000,DRSL)
		3701	Store (0xffffff,DWD1)
		3702	Store(0xffffff,SMDW)
		3703
		3704	//test with DWORD system memory data
		3705	if(LEqual(DWD1,SMDW))
		3706	{ Store(LAnd(DWD1,SMDW),DRSL)
		3707	if(LNotEqual(Ones,DRSL))
		3708	{Return(18)}
		3709	}
		3710
		3711	Return(0)
		3712
		3713	}//ANDL
		3714
		3715	//Test the LOr Operator
		3716
		3717	Method (ORL_,2)
		3718	{//ORL_
		3719
		3720	//test with the arguments passed
		3721	if(LEqual(Arg0,Arg1))
		3722	{
		3723	Store(LOr(Arg0,Arg1),RSLT)
		3724	if(LNotEqual(Ones,RSLT))
		3725	{
		3726	Return(21)
		3727	}
		3728	}
		3729
		3730	//test with he locals
		3731	Store(Arg0,Local0)
		3732	Store(Arg1,Local1)
		3733
		3734	if(LEqual(Local0,Local1))
		3735	{
		3736	Store(LOr(Local0,Local1),RSLT)
		3737	if(LNotEqual(Ones,RSLT))
		3738	{Return(22)}
		3739	}
		3740
		3741	//Check with 1 LOred with 0 on byte data
		3742	Store(0xff,BYT1)
		3743	Store(0x00,BYT2)
		3744	Store(0x00,BRSL)
		3745
		3746	if(LNotEqual(BYT1, BYT2))
		3747	{
		3748	Store(LOr(BYT1, BYT2), BRSL)
		3749	if(LNotEqual(Ones,BRSL))
		3750	{Return(23)}
		3751	}
		3752
		3753	//Check with 1 LOred with 0 on WORD data
		3754	Store(0xffff,WRD1)
		3755	Store(0x0000,WRD2)
		3756	Store(0x0000,WRSL)
		3757
		3758	if(LNotEqual(WRD1, WRD2))
		3759	{
		3760	Store(LOr(WRD1, WRD2), WRSL)
		3761	if(LNotEqual(Ones,WRSL))
		3762	{Return(24)}
		3763	}
		3764
		3765	//Check with 1 LOred with 0 on DWORD data
		3766	Store(0xffffffff,DWD1)
		3767	Store(0x00000000,DWD2)
		3768	Store(0x00000000,DRSL)
		3769
		3770	if(LNotEqual(DWD1, DWD2))
		3771	{
		3772	Store(LOr(DWD1, DWD2), DRSL)
		3773	if(LNotEqual(Ones,DRSL))
		3774	{Return(25)}
		3775	}
		3776
		3777	Store(0x00,BYT1)
		3778	Store(0xff,SMBY)
		3779	Store(0x00,BRSL)
		3780
		3781	//test with BYTE system memory data
		3782	if(LEqual(BYT1,SMBY))
		3783	{ Store(LOr(BYT1,SMBY),BRSL)
		3784	if(LNotEqual(Ones,BRSL))
		3785	{Return(26)}
		3786	}
		3787
		3788	Store (0x0000,WRD1)
		3789	Store(0xffff,SMWD)
		3790	Store(0x0000,WRSL)
		3791
		3792	//test with WORD system memory data
		3793	if(LEqual(WRD1,SMWD))
		3794	{ Store(LOr(WRD1,SMWD),WRSL)
		3795	if(LNotEqual(Ones,WRSL))
		3796	{Return(27)}
		3797	}
		3798
		3799
		3800	Store(0x00000000,DWD1)
		3801	Store(0xffffffff,SMDW)
		3802	Store(0x00000000,DRSL)
		3803
		3804	//test with DWORD system memory data
		3805	if(LEqual(DWD1,SMDW))
		3806	{ Store(LAnd(DWD1,SMDW),DRSL)
		3807	if(LNotEqual(Ones,DRSL))
		3808	{Return(28)}
		3809	}
		3810	Return(0)
		3811
		3812	}//ORL_
		3813
		3814	//This method tests LGreater and LNot operator
		3815	Method(LSGR,2)
		3816	{//LSGR
		3817
		3818	//Test on arguements passed
		3819
		3820	//in test data, Arg1 > Arg0
		3821	if(LEqual(Ones,LNot(LGreater(Arg1,Arg0))))
		3822	{Return(31)}
		3823
		3824	//test LLessEqual
		3825	if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0))))
		3826	{Return(32)}
		3827
		3828	if(LEqual(Ones,LLess(Arg1,Arg0)))
		3829	{Return(33)}
		3830
		3831	//test LLessEqual
		3832	if(LEqual(Ones,LLessEqual(Arg1,Arg0)))
		3833	{Return(34)}
		3834
		3835	Store(Arg0,Local0)
		3836	Store(Arg1,Local1)
		3837
		3838	//test with the locals
		3839	if(LNot(LGreater(Local1,Local0)))
		3840	{Return(35)}
		3841
		3842	//test on Byte data
		3843	Store(0x12,BYT1)
		3844	Store(0x21,BYT2)
		3845
		3846	if(LNot(LGreater(BYT2,BYT1)))
		3847	{Return(36)}
		3848
		3849	if(LNot(LLess(BYT1,BYT2)))
		3850	{Return(37)}
		3851
		3852	//test LGreaterEqual with byte data
		3853	if(LNot(LGreaterEqual(BYT2,BYT1)))
		3854	{Return(38)}
		3855
		3856	//test LLessEqual byte data
		3857	if(LNot(LLessEqual(BYT1,BYT2)))
		3858	{Return(39)}
		3859
		3860
		3861	//test on Word data
		3862	Store(0x1212,WRD1)
		3863	Store(0x2121,WRD2)
		3864
		3865	if(LNot(LGreater(WRD2,WRD1)))
		3866	{Return(310)}
		3867
		3868	if(LNot(LLess(WRD1,WRD2)))
		3869	{Return(311)}
		3870
		3871	//Test LGreaterEqual with Word Data
		3872	if(LNot(LGreaterEqual(WRD2,WRD1)))
		3873	{Return(312)}
		3874
		3875
		3876	//Test LLessEqual with Word Data
		3877	if(LNot(LLessEqual(WRD1,WRD2)))
		3878	{Return(313)}
		3879
		3880	//test on DWord data
		3881	Store(0x12121212,DWD1)
		3882	Store(0x21212121,DWD2)
		3883
		3884	if(LNot(LGreater(DWD2,DWD1)))
		3885	{Return(314)}
		3886
		3887	if(LNot(LLess(DWD1,DWD2)))
		3888	{Return(315)}
		3889
		3890
		3891	//Test LGreaterEqual with Dword
		3892	if(LNot(LGreaterEqual(DWD2,DWD1)))
		3893	{Return(316)}
		3894
		3895	//Test LLessEqual DWord
		3896	if(LNot(LLessEqual(DWD1,DWD2)))
		3897	{Return(317)}
		3898
		3899	Return(0)
		3900	}//LSGR
		3901
		3902	//The test method
		3903	Method(TEST)
		3904	{
		3905	Store ("++++++++ LOps Test", Debug)
		3906
		3907	Store(0,RSLT)
		3908	//Call LAndOp method
		3909	Store(ANDL(2,2),RSLT)
		3910	if(LNotEqual(RSLT,0))
		3911	{Return(RSLT)}
		3912
		3913	//Call LOrOp Method
		3914	Store(ORL_(5,5),RSLT)
		3915	if(LNotEqual(RSLT,0))
		3916	{Return(RSLT)}
		3917
		3918	//Call LSGR Method
		3919	Store(LSGR(5,7),RSLT)
		3920	if(LNotEqual(RSLT,0))
		3921	{Return(RSLT)}
		3922
		3923	Return(0)
		3924	}//TEST
		3925	}//LOPS
		3926
		3927	//
		3928	// test FdSetOps.asl
		3929	//
		3930	// FindSetLeftBit - Find Set Left Bit
		3931	// FindSetLeftBitTerm := FindSetLeftBit
		3932	// ( Source, //TermArg=>Integer
		3933	// Result //Nothing \| SuperName
		3934	// ) => Integer
		3935	// Source is evaluated as integer data type, and the one-based bit location of
		3936	// the first MSb (most significant set bit) is optionally stored into Result.
		3937	// The result of 0 means no bit was set, 1 means the left-most bit set is the
		3938	// first bit, 2 means the left-most bit set is the second bit, and so on.
		3939	// FindSetRightBit - Find Set Right Bit
		3940
		3941	// FindSetRightBitTerm := FindSetRightBit
		3942	// ( Source, //TermArg=>Integer
		3943	// Result //Nothing \| SuperName
		3944	// ) => Integer
		3945	// Source is evaluated as integer data type, and the one-based bit location of
		3946	// the most LSb (least significant set bit) is optionally stored in Result.
		3947	// The result of 0 means no bit was set, 32 means the first bit set is the
		3948	// 32nd bit, 31 means the first bit set is the 31st bit, and so on.
		3949
		3950	// If the Control method is success Zero is returned. Otherwise a non-zero
		3951	// number is returned.
		3952	//
		3953	Device (FDSO)
		3954	{ // FDSO
		3955
		3956	// Create System Memory Operation Region and field overlays
		3957	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		3958	Field (RAM, AnyAcc, NoLock, Preserve)
		3959	{
		3960	SMDW, 32, // 32-bit DWORD
		3961	SMWD, 16, // 16-bit WORD
		3962	SMBY, 8, // 8-bit BYTE
		3963	} // Field(RAM)
		3964
		3965	// Byte Data
		3966	Name (BYT1, 1)
		3967	Name (BRSL, 0x00)
		3968
		3969	// Word Data
		3970	Name (WRD1, 0x100)
		3971	Name (WRSL, 0x0000)
		3972
		3973	// DWord Data
		3974	Name (DWD1, 0x10000)
		3975	Name (DRSL, 0x00000000)
		3976	Name (RSLT, 1)
		3977	Name (CNTR, 1)
		3978
		3979	Method (SHFT,2)
		3980	// Arg0 is the actual data and Arg1 is the bit position
		3981	{ // SHFT
		3982	Store (Arg0, Local0)
		3983	Store (Arg1, Local1)
		3984
		3985	FindSetLeftBit (Arg0, BRSL)
		3986	If (LNotEqual (BRSL, Arg1))
		3987	{ Return (0x11) }
		3988	If (LNotEqual (Arg0, Local0))
		3989	{ Return (0x12) }
		3990
		3991	FindSetLeftBit (Local0, BRSL)
		3992	If (LNotEqual (BRSL, Local1))
		3993	{ Return (0x13) }
		3994	If (LNotEqual (Arg0, Local0))
		3995	{ Return (0x14) }
		3996
		3997	// test the byte value for SetLeftBit
		3998	Store (7, BYT1)
		3999	FindSetLeftBit (BYT1, BRSL)
		4000	If (LNotEqual (BRSL, 3))
		4001	{ Return (0x15) }
		4002	If (LNotEqual (BYT1, 7))
		4003	{ Return (0x16) }
		4004
		4005	Store (1, BYT1)
		4006	Store (1, CNTR)
		4007	While (LLessEqual (CNTR, 8))
		4008	{ // FindSetLeftBit check loop for byte data
		4009	FindSetLeftBit (BYT1, BRSL)
		4010	If (LNotEqual (BRSL, CNTR))
		4011	{ Return (0x17) }
		4012
		4013	// Shift the bits to check the same
		4014	ShiftLeft (BYT1, 1, BYT1)
		4015	Increment (CNTR)
		4016	} // FindSetLeftBit check loop for byte data
		4017
		4018
		4019	// Check BYTE value for SetRightBit
		4020	Store (7, BYT1)
		4021	FindSetRightBit (BYT1, BRSL)
		4022	If (LNotEqual (BRSL, 1))
		4023	{ Return (0x21) }
		4024	If (LNotEqual (BYT1, 7))
		4025	{ Return (0x22) }
		4026
		4027	Store (1, CNTR)
		4028	Store (0xFF, BYT1)
		4029	While (LLessEqual (CNTR, 8))
		4030	{ // FindSetRightBit check loop for byte data
		4031	FindSetRightBit (BYT1, BRSL)
		4032	If (LNotEqual (BRSL, CNTR))
		4033	{ Return (0x23) }
		4034
		4035	ShiftLeft (BYT1, 1, BYT1)
		4036	Increment (CNTR)
		4037	} // FindSetRightBit check loop for byte data
		4038
		4039
		4040	// Test Word value for SetLeftBit
		4041	Store (9, CNTR)
		4042	Store (0x100, WRD1)
		4043	While (LLessEqual (CNTR, 16))
		4044	{
		4045	// FindSetLeftBit check loop for Word data
		4046	FindSetLeftBit (WRD1, WRSL)
		4047	If (LNotEqual (WRSL, CNTR))
		4048	{ Return (0x31) }
		4049
		4050	// Shift the bits to check the same
		4051	ShiftLeft (WRD1, 1, WRD1)
		4052	Increment (CNTR)
		4053	} // FindSetLeftBit check loop for Word data
		4054
		4055	// Check Word value for SetRightBit
		4056	Store (9, CNTR)
		4057	Store (0xFF00, WRD1)
		4058	While (LLessEqual (CNTR, 16))
		4059	{
		4060	// FindSetRightBit check loop for Word data
		4061	FindSetRightBit (WRD1, WRSL)
		4062	If (LNotEqual (WRSL, CNTR))
		4063	{ Return (0x32) }
		4064
		4065	ShiftLeft (WRD1, 1, WRD1)
		4066	Increment (CNTR)
		4067	} // FindSetRightBit check loop for Word data
		4068
		4069	// Test the DWord value for SetLeftBit
		4070	Store (17, CNTR)
		4071	Store (0x10000, DWD1)
		4072	While (LLessEqual (CNTR, 32))
		4073	{
		4074	// FindSetLeftBit check loop for Dword
		4075	FindSetLeftBit (DWD1, DRSL)
		4076	If (LNotEqual (DRSL, CNTR))
		4077	{ Return (0x41) }
		4078
		4079	// Shift the bits to check the same
		4080	ShiftLeft (DWD1, 1, DWD1)
		4081	Increment (CNTR)
		4082	} // FindSetLeftBit check loop for Dword
		4083
		4084	// Check DWord value for SetRightBit
		4085	Store (17, CNTR)
		4086	Store (0xFFFF0000, DWD1)
		4087	While (LLessEqual (CNTR, 32))
		4088	{ // FindSetRightBit Check loop for DWORD
		4089	FindSetRightBit (DWD1, DRSL)
		4090	If (LNotEqual (DRSL, CNTR))
		4091	{ Return (0x42) }
		4092
		4093	ShiftLeft (DWD1, 1, DWD1)
		4094	Increment (CNTR)
		4095	} // FindSetRightBit Check loop for DWORD
		4096
		4097	Return (0)
		4098	} // SHFT
		4099
		4100	// Test method called from amlexec
		4101	Method (TEST)
		4102	{ // TEST
		4103
		4104	Store ("++++++++ FdSetOps Test", Debug)
		4105
		4106	Store (SHFT (0x80, 8), RSLT)
		4107	If (LNotEqual (RSLT, 0))
		4108	{ Return (RSLT) }
		4109
		4110	Return (0) // pass
		4111	} // TEST
		4112	} // Device FDSO
		4113
		4114	//
		4115	// test MulDivOp.asl
		4116	//
		4117	Device (MLDV)
		4118	{
		4119	// create System Memory Operation Region and field overlays
		4120	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		4121	Field (RAM, AnyAcc, NoLock, Preserve)
		4122	{
		4123	SMDW, 32, // 32-bit DWORD
		4124	SMWD, 16, // 16-bit WORD
		4125	SMBY, 8, // 8-bit BYTE
		4126	} // Field(RAM)
		4127
		4128	Method (TEST)
		4129	{
		4130	Store ("++++++++ MulDivOp Test", Debug)
		4131
		4132	Name (RMDR, 0)
		4133	Name (DWRD, 0x12345678)
		4134	Name (WRD, 0x1234)
		4135	Name (BYT, 0x12)
		4136
		4137	// Test MultiplyOp with DWORD data
		4138	Store (0x12345678, DWRD)
		4139	Multiply (DWRD, 3, DWRD)
		4140	If (LNotEqual (DWRD, 0x369D0368))
		4141	{ Return (DWRD) }
		4142
		4143	// Test MultiplyOp with WORD data
		4144	Multiply (WRD, 4, WRD)
		4145	If (LNotEqual (WRD, 0x48D0))
		4146	{ Return (WRD) }
		4147
		4148	// Test MultiplyOp with BYTE data
		4149	Multiply (BYT, 5, BYT)
		4150	If (LNotEqual (BYT, 0x5A))
		4151	{ Return (BYT) }
		4152
		4153	// Test DivideOp with DWORD data
		4154	Divide (DWRD, 3, DWRD, RMDR)
		4155	If (LNotEqual (DWRD, 0x12345678))
		4156	{ Return (DWRD) }
		4157	If (LNotEqual (RMDR, 0))
		4158	{ Return (RMDR) }
		4159
		4160	// Test DivideOp with WORD data
		4161	Divide (WRD, 4, WRD, RMDR)
		4162	If (LNotEqual (WRD, 0x1234))
		4163	{ Return (WRD) }
		4164	If (LNotEqual (RMDR, 0))
		4165	{ Return (RMDR) }
		4166
		4167	// Test DivideOp with BYTE data
		4168	Divide (BYT, 5, BYT, RMDR)
		4169	If (LNotEqual (BYT, 0x12))
		4170	{ Return (BYT) }
		4171	If (LNotEqual (RMDR, 0))
		4172	{ Return (RMDR) }
		4173
		4174
		4175	// test MultiplyOp with DWORD SystemMemory OpRegion
		4176	Store (0x01234567, SMDW)
		4177	Multiply (SMDW, 2, SMDW)
		4178	If (LNotEqual (SMDW, 0x02468ACE))
		4179	{ Return (SMDW) }
		4180
		4181	// test DivideOp with DWORD SystemMemory OpRegion
		4182	Divide (SMDW, 3, SMDW, RMDR)
		4183	If (LNotEqual (SMDW, 0x00C22E44))
		4184	{ Return (SMDW) }
		4185	If (LNotEqual (RMDR, 2))
		4186	{ Return (RMDR) }
		4187
		4188
		4189	// test MultiplyOp with WORD SystemMemory OpRegion
		4190	Store (0x0123, SMWD)
		4191	Multiply (SMWD, 3, SMWD)
		4192	If (LNotEqual (SMWD, 0x369))
		4193	{ Return (SMWD) }
		4194
		4195	// test DivideOp with WORD SystemMemory OpRegion
		4196	Divide (SMWD, 2, SMWD, RMDR)
		4197	If (LNotEqual (SMWD, 0x01B4))
		4198	{ Return (SMWD) }
		4199	If (LNotEqual (RMDR, 1))
		4200	{ Return (RMDR) }
		4201
		4202
		4203	// test MultiplyOp with BYTE SystemMemory OpRegion
		4204	Store (0x01, SMBY)
		4205	Multiply (SMBY, 7, SMBY)
		4206	If (LNotEqual (SMBY, 0x07))
		4207	{ Return (SMBY) }
		4208
		4209	// test DivideOp with BYTE SystemMemory OpRegion
		4210	Divide (SMBY, 4, SMBY, RMDR)
		4211	If (LNotEqual (SMBY, 0x01))
		4212	{ Return (SMBY) }
		4213	If (LNotEqual (RMDR, 3))
		4214	{ Return (RMDR) }
		4215
		4216	Return (0)
		4217	} // TEST
		4218	} // MLDV
		4219
		4220	//
		4221	// test NBitOps.asl
		4222	//
		4223	//NAnd - Bit-wise NAnd
		4224	//NAndTerm := NAnd(
		4225	// Source1, //TermArg=>Integer
		4226	// Source2 //TermArg=>Integer
		4227	// Result //Nothing \| SuperName
		4228	//) => Integer
		4229	//Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally
		4230	//stored in Result.
		4231
		4232	//NOr - Bitwise NOr
		4233	//NOrTerm := NOr(
		4234	// Source1, //TermArg=>Integer
		4235	// Source2 //TermArg=>Integer
		4236	// Result //Nothing \| SuperName
		4237	//) => Integer
		4238	//Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally
		4239	//stored in Result.
		4240	// Not - Not
		4241	//NotTerm := Not(
		4242	// Source, //TermArg=>Integer
		4243	// Result //Nothing \| SuperName
		4244	//) => Integer
		4245	//Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in
		4246	//Result.
		4247
		4248	//If the Control method is success Zero is returned else a non-zero number is returned
		4249
		4250	Device (NBIT)
		4251	{//NBIT
		4252
		4253	//Create System Memory Operation Region and field overlays
		4254	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		4255	Field (RAM, AnyAcc, NoLock, Preserve)
		4256	{
		4257	SMDW, 32, // 32-bit DWORD
		4258	SMWD, 16, // 16-bit WORD
		4259	SMBY, 8, // 8-bit BYTE
		4260	}// Field(RAM)
		4261
		4262
		4263	//And with Byte Data
		4264	Name (BYT1, 0xff)
		4265	Name (BYT2, 0xff)
		4266	Name (BRSL, 0x00)
		4267
		4268	//And with Word Data
		4269	Name (WRD1, 0xffff)
		4270	Name (WRD2, 0xffff)
		4271	Name (WRSL, 0x0000)
		4272
		4273	//And with DWord Data
		4274	Name (DWD1, 0xffffffff)
		4275	Name (DWD2, 0xffffffff)
		4276	Name (DRSL, 0x00000000)
		4277	Name(RSLT,1)
		4278
		4279
		4280	Name(ARSL,0x00)
		4281	Name(LRSL,0x00)
		4282
		4283	Method(NNDB,2)
		4284	{//NNDB
		4285
		4286	Store(0xffffffff,SMDW)
		4287	Store(0xffff,SMWD)
		4288	Store(0xff,SMBY)
		4289
		4290
		4291	NAnd(Arg0,Arg1,ARSL)
		4292	if(LNotEqual(ARSL,0xfffffffd))
		4293	{Return(11)}
		4294
		4295	Store(Arg0,local0)
		4296	Store(Arg1,Local1)
		4297
		4298	NAnd(Local0,Local1,LRSL)
		4299	if(LNotEqual(LRSL,0xfffffffd))
		4300	{Return(12)}
		4301
		4302
		4303	//Byte data
		4304	NAnd(BYT1,BYT2,BRSL)
		4305	if(LNotEqual(BRSL,0xffffff00))
		4306	{Return(13)}
		4307
		4308	//Word Data
		4309	NAnd(WRD1,WRD2,WRSL)
		4310	if(LNotEqual(WRSL,0xffff0000))
		4311	{Return(14)}
		4312
		4313	//DWord Data
		4314	NAnd(DWD1,DWD2,DRSL)
		4315	if(LNotEqual(DRSL,0x00000000))
		4316	{Return(15)}
		4317
		4318	//Byte data
		4319	NAnd(SMBY,0xff,BRSL)
		4320	if(LNotEqual(BRSL,0xffffff00))
		4321	{Return(16)}
		4322
		4323	//Word Data
		4324	NAnd(SMWD,0xffff,WRSL)
		4325	if(LNotEqual(WRSL,0xffff0000))
		4326	{Return(17)}
		4327
		4328	//DWord Data
		4329	NAnd(SMDW,0xffffffff,DRSL)
		4330	if(LNotEqual(DRSL,0x00000000))
		4331	{Return(18)}
		4332
		4333	Return(0)
		4334
		4335	}//NNDB
		4336
		4337	Method(NNOR,2)
		4338	{//NNOR
		4339
		4340	NOr(Arg0,Arg1,ARSL)
		4341	if(LNotEqual(ARSL,0xfffffffd))
		4342	{Return(21)}
		4343
		4344	Store(Arg0,local0)
		4345	Store(Arg1,Local1)
		4346
		4347	NOr(Local0,Local1,LRSL)
		4348	if(LNotEqual(LRSL,0xfffffffd))
		4349	{Return(22)}
		4350
		4351
		4352	//Byte data
		4353	NOr(BYT1,BYT2,BRSL)
		4354	if(LNotEqual(BRSL,0xffffff00))
		4355	{Return(23)}
		4356
		4357	//Word Data
		4358	NOr(WRD1,WRD2,WRSL)
		4359	if(LNotEqual(WRSL,0xffff0000))
		4360	{Return(24)}
		4361
		4362	//DWord Data
		4363	NOr(DWD1,DWD2,DRSL)
		4364	if(LNotEqual(DRSL,0x00000000))
		4365	{Return(25)}
		4366
		4367	//System Memory Byte data
		4368	NOr(SMBY,0xff,BRSL)
		4369	if(LNotEqual(BRSL,0xffffff00))
		4370	{Return(26)}
		4371
		4372	//System Memory Word Data
		4373	NOr(SMWD,0xffff,WRSL)
		4374	if(LNotEqual(WRSL,0xffff0000))
		4375	{Return(27)}
		4376
		4377	//System Memory DWord Data
		4378	NOr(SMDW,0xffffffff,DRSL)
		4379	if(LNotEqual(DRSL,0x00000000))
		4380	{Return(28)}
		4381
		4382	Return(0)
		4383
		4384	}//NNOR
		4385
		4386	Method(NNOT,2)
		4387	{//NNOT
		4388
		4389	Or(Arg0,Arg1,ARSL)
		4390	Not(ARSL,ARSL)
		4391	if(LNotEqual(ARSL,0xfffffffd))
		4392	{Return(31)}
		4393
		4394	Store(Arg0,local0)
		4395	Store(Arg1,Local1)
		4396
		4397	Or(Local0,Local1,LRSL)
		4398	Not(LRSL,LRSL)
		4399	if(LNotEqual(LRSL,0xfffffffd))
		4400	{Return(32)}
		4401
		4402
		4403	//Byte data
		4404	Or(BYT1,BYT2,BRSL)
		4405	Not(BRSL,BRSL)
		4406	if(LNotEqual(BRSL,0xffffff00))
		4407	{Return(33)}
		4408
		4409	//Word Data
		4410	Or(WRD1,WRD2,WRSL)
		4411	Not(WRSL,WRSL)
		4412	if(LNotEqual(WRSL,0xffff0000))
		4413	{Return(34)}
		4414
		4415	//DWord Data
		4416	Or(DWD1,DWD2,DRSL)
		4417	Not(DRSL,DRSL)
		4418	if(LNotEqual(DRSL,0x00000000))
		4419	{Return(35)}
		4420
		4421	//System Memory Byte data
		4422	Or(SMBY,0xff,BRSL)
		4423	Not(BRSL,BRSL)
		4424	if(LNotEqual(BRSL,0xffffff00))
		4425	{Return(36)}
		4426
		4427	//System Memory Word Data
		4428	Or(SMWD,0xffff,WRSL)
		4429	Not(WRSL,WRSL)
		4430	if(LNotEqual(WRSL,0xffff0000))
		4431	{Return(37)}
		4432
		4433	//System Memory DWord Data
		4434	Or(SMDW,0xffffffff,DRSL)
		4435	Not(DRSL,DRSL)
		4436	if(LNotEqual(DRSL,0x00000000))
		4437	{Return(38)}
		4438
		4439	Return(0)
		4440	}//NNOT
		4441
		4442
		4443	Method(TEST)
		4444	{
		4445
		4446	Store ("++++++++ NBitOps Test", Debug)
		4447
		4448	Store(NNDB(2,2),RSLT)
		4449	if(LNotEqual(RSLT,0))
		4450	{Return(RSLT)}
		4451
		4452	Store(NNOR(2,2),RSLT)
		4453	if(LNotEqual(RSLT,0))
		4454	{Return(RSLT)}
		4455
		4456	Store(NNOT(2,2),RSLT)
		4457	if(LNotEqual(RSLT,0))
		4458	{Return(RSLT)}
		4459
		4460
		4461	Return(0)
		4462	}
		4463
		4464	}//Device NBIT
		4465
		4466	//
		4467	// test ShftOp.asl
		4468	//
		4469	//ShiftRightTerm := ShiftRight(
		4470	// Source, //TermArg=>Integer
		4471	// ShiftCount //TermArg=>Integer
		4472	// Result //Nothing \| SuperName
		4473	//) => Integer
		4474	//Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit
		4475	//zeroed ShiftCount times. The result is optionally stored into Result.
		4476
		4477	//ShiftLeft(
		4478	// Source, //TermArg=>Integer
		4479	// ShiftCount //TermArg=>Integer
		4480	// Result //Nothing \| SuperName
		4481	//) => Integer
		4482	//Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant
		4483	//bit zeroed ShiftCount times. The result is optionally stored into Result.
		4484
		4485	//If the Control method is success Zero is returned else a non-zero number is returned
		4486	Device (SHFT)
		4487	{//SHFT
		4488
		4489	//Create System Memory Operation Region and field overlays
		4490	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		4491	Field (RAM, AnyAcc, NoLock, Preserve)
		4492	{
		4493	SMDW, 32, // 32-bit DWORD
		4494	SMWD, 16, // 16-bit WORD
		4495	SMBY, 8, // 8-bit BYTE
		4496	}// Field(RAM)
		4497
		4498
		4499	Name(SHFC,0x00)
		4500
		4501	//And with Byte Data
		4502	Name (BYT1, 0xff)
		4503	Name (BRSL, 0x00)
		4504
		4505	//And with Word Data
		4506	Name (WRD1, 0xffff)
		4507	Name (WRSL, 0x0000)
		4508
		4509	//And with DWord Data
		4510	Name (DWD1, 0xffffffff)
		4511	Name (DRSL, 0x00000000)
		4512
		4513	Name(RSLT,1)
		4514
		4515	Name(ARSL,0x00)
		4516	Name(LRSL,0x00)
		4517
		4518	Method(SLFT,2)
		4519	{//SLFT
		4520
		4521	Store(0xffffffff,SMDW)
		4522	Store(0xffff,SMWD)
		4523	Store(0xff,SMBY)
		4524
		4525
		4526	//Arg0-> 2 & Arg1->2
		4527	ShiftLeft(Arg0,Arg1,ARSL)
		4528	if(LNotEqual(ARSL,8))
		4529	{Return(11)}
		4530
		4531	Store(Arg0,local0)
		4532	Store(Arg1,Local1)
		4533
		4534	//Local0->8 and Local1->2
		4535	ShiftLeft(Local0,Local1,LRSL)
		4536	if(LNotEqual(LRSL,8))
		4537	{Return(12)}
		4538
		4539	Store(2,SHFC)
		4540	//Byte data
		4541	ShiftLeft(BYT1,SHFC,BRSL)
		4542	if(LNotEqual(BRSL,0x3FC))
		4543	{Return(13)}
		4544
		4545	Store(4,SHFC)
		4546	//Word Data
		4547	ShiftLeft(WRD1,SHFC,WRSL)
		4548	if(LNotEqual(WRSL,0xFFFF0))
		4549	{Return(14)}
		4550
		4551	Store(8,SHFC)
		4552	//DWord Data
		4553	ShiftLeft(DWD1,SHFC,DRSL)
		4554	if(LNotEqual(DRSL,0xFFFFFF00))
		4555	{Return(15)}
		4556
		4557
		4558	//System Memory Byte data
		4559	Store(4,SHFC)
		4560	ShiftLeft(SMBY,SHFC,BRSL)
		4561	if(LNotEqual(BRSL,0xFF0))
		4562	{Return(16)}
		4563
		4564	//Word Data
		4565	Store(4,SHFC)
		4566	ShiftLeft(SMWD,SHFC,WRSL)
		4567	if(LNotEqual(WRSL,0xffff0))
		4568	{Return(17)}
		4569
		4570	//DWord Data
		4571	Store(8,SHFC)
		4572	ShiftLeft(SMDW,SHFC,DRSL)
		4573	if(LNotEqual(DRSL,0xFFFFFF00))
		4574	{Return(18)}
		4575
		4576	Return(0)
		4577
		4578	}//SLFT
		4579
		4580	Method(SRGT,2)
		4581	{//SRGT
		4582	//And with Byte Data
		4583	Store (0xff,BYT1)
		4584	Store (0x00,BRSL)
		4585
		4586	//And with Word Data
		4587	Store (0xffff,WRD1)
		4588	Store (0x0000,WRSL)
		4589
		4590	//And with DWord Data
		4591	Store(0xffffffff,DWD1)
		4592	Store (0x00000000,DRSL)
		4593
		4594	//Reinitialize the result objects
		4595	Store(0x00,ARSL)
		4596	Store(0x00,LRSL)
		4597
		4598	Store(0xffffffff,SMDW)
		4599	Store(0xffff,SMWD)
		4600	Store(0xff,SMBY)
		4601
		4602	//Arg0-> 2 & Arg1->2
		4603	ShiftRight(Arg0,Arg1,ARSL)
		4604	if(LNotEqual(ARSL,0))
		4605	{Return(21)}
		4606
		4607	Store(Arg0,local0)
		4608	Store(Arg1,Local1)
		4609
		4610	//Local0->8 and Local1->2
		4611	ShiftRight(Local0,Local1,LRSL)
		4612	if(LNotEqual(LRSL,0))
		4613	{Return(22)}
		4614
		4615	Store(2,SHFC)
		4616	//Byte data
		4617	ShiftRight(BYT1,SHFC,BRSL)
		4618	if(LNotEqual(BRSL,0x3F))
		4619	{Return(23)}
		4620
		4621	Store(4,SHFC)
		4622	//Word Data
		4623	ShiftRight(WRD1,SHFC,WRSL)
		4624	if(LNotEqual(WRSL,0xFFF))
		4625	{Return(24)}
		4626
		4627	Store(8,SHFC)
		4628	//DWord Data
		4629	ShiftRight(DWD1,SHFC,DRSL)
		4630	if(LNotEqual(DRSL,0xFFFFFF))
		4631	{Return(25)}
		4632
		4633	//System Memory Byte data
		4634	Store(4,SHFC)
		4635	ShiftRight(SMBY,SHFC,BRSL)
		4636	if(LNotEqual(BRSL,0xF))
		4637	{Return(26)}
		4638
		4639	//Word Data
		4640	Store(4,SHFC)
		4641	ShiftRight(SMWD,SHFC,WRSL)
		4642	if(LNotEqual(WRSL,0xFFF))
		4643	{Return(27)}
		4644
		4645	//DWord Data
		4646	Store(8,SHFC)
		4647	ShiftRight(SMDW,SHFC,DRSL)
		4648	if(LNotEqual(DRSL,0xFFFFFF))
		4649	{Return(28)}
		4650
		4651	Return(0)
		4652	}//SRGT
		4653
		4654	//Test method called from amlexec
		4655	Method(TEST)
		4656	{
		4657	Store ("++++++++ ShftOp Test", Debug)
		4658
		4659	Store(SLFT(2,2),RSLT)
		4660	if(LNotEqual(RSLT,0))
		4661	{Return(RSLT)}
		4662	Store(SRGT(2,2),RSLT)
		4663	if(LNotEqual(RSLT,0))
		4664	{Return(RSLT)}
		4665	Return(0)
		4666	}
		4667
		4668	}//Device SHFT
		4669
		4670	//
		4671	// test Xor.asl and slightly modified
		4672	//
		4673	//This code tests the XOR opcode term
		4674	//Syntax of XOR term
		4675	// XOr(
		4676	// Source1 //TermArg=>BufferTerm
		4677	// Source2 //TermArg=>Integer
		4678	// Result //NameString
		4679	// )
		4680	//"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in
		4681	// Result
		4682	Device (XORD)
		4683	{
		4684	//This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD
		4685	Method (TEST)
		4686	{
		4687	Store ("++++++++ Xor Test", Debug)
		4688
		4689	//Overlay in system memory
		4690	OperationRegion (RAM, SystemMemory, 0x800000, 256)
		4691	Field (RAM, ByteAcc, NoLock, Preserve)
		4692	{
		4693	RES1, 1, //Offset
		4694	BYT1, 8, //First BYTE
		4695	BYT2, 8, //Second BYTE
		4696	RBYT, 8, //Result Byte
		4697	RES2, 1, //Offset
		4698	WRD1, 16, //First WORD field
		4699	WRD2, 16, //Second WORD field
		4700	RWRD, 16, //RSLT WORD field
		4701	RES3, 1, //Offset
		4702	DWD1, 32, //First Dword
		4703	DWD2, 32, //Second Dword
		4704	RDWD, 32, //Result Dword
		4705	RES4, 1, //Offset
		4706	}
		4707
		4708	// Store bits in the single bit fields for checking
		4709	// at the end
		4710	Store(1, RES1)
		4711	Store(1, RES2)
		4712	Store(1, RES3)
		4713	Store(1, RES4)
		4714
		4715	// Check the stored single bits
		4716	if(LNotEqual(RES1, 1))
		4717	{
		4718	Return(1)
		4719	}
		4720
		4721	if(LNotEqual(RES2, 1))
		4722	{
		4723	Return(1)
		4724	}
		4725
		4726	if(LNotEqual(RES3, 1))
		4727	{
		4728	Return(1)
		4729	}
		4730
		4731	if(LNotEqual(RES4, 1))
		4732	{
		4733	Return(1)
		4734	}
		4735
		4736	//************************************************
		4737	// (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition
		4738	Store(0x00,BYT1)
		4739	Store(0x00,BYT2)
		4740	XOr(BYT1,BYT2,Local0)
		4741	Store (Local0, RBYT)
		4742	if(LNotEqual(RBYT,0))
		4743	{ Return(1)}
		4744
		4745	// (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition
		4746	Store(0xff,BYT1)
		4747	Store(0xff,BYT2)
		4748	XOr(BYT1,BYT2,Local0)
		4749	Store (Local0, RBYT)
		4750	if(LNotEqual(RBYT,0))
		4751	{ Return(1)}
		4752
		4753	// (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition
		4754	Store(0x55,BYT1)
		4755	Store(0xAA,BYT2)
		4756	XOr(BYT1,BYT2,Local0)
		4757	Store (Local0, RBYT)
		4758	if(LNotEqual(RBYT,0xFF))
		4759	{ Return(1)}
		4760
		4761	//(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition
		4762	Store(0xAA,BYT1)
		4763	Store(0x55,BYT2)
		4764	XOr(BYT1,BYT2,Local0)
		4765	Store (Local0, RBYT)
		4766	if(LNotEqual(RBYT,0xFF))
		4767	{ Return(1)}
		4768
		4769	Store(0x12,BYT1)
		4770	Store(0xED,BYT2)
		4771
		4772	XOr(BYT1,BYT2,Local0)
		4773	Store (Local0, RBYT)
		4774	if(LNotEqual(RBYT,0xFF))
		4775	{
		4776	Return(1)
		4777	}
		4778
		4779	// Store known values for checking later
		4780	Store(0x12, BYT1)
		4781	if(LNotEqual(BYT1, 0x12))
		4782	{
		4783	Return(1)
		4784	}
		4785
		4786	Store(0xFE, BYT2)
		4787	if(LNotEqual(BYT2, 0xFE))
		4788	{
		4789	Return(1)
		4790	}
		4791
		4792	Store(0xAB, RBYT)
		4793	if(LNotEqual(RBYT, 0xAB))
		4794	{
		4795	Return(1)
		4796	}
		4797
		4798	//***********************************************
		4799	// (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition
		4800	Store(0x0000,WRD1)
		4801	Store(0x0000,WRD2)
		4802	XOr(WRD1,WRD2,RWRD)
		4803	if(LNotEqual(RWRD,0))
		4804	{ Return(1)}
		4805
		4806	// (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition
		4807	Store(0xffff,WRD1)
		4808	Store(0xffff,WRD2)
		4809	XOr(WRD1,WRD2,RWRD)
		4810	if(LNotEqual(RWRD,0))
		4811	{ Return(1)}
		4812
		4813	// (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition
		4814	Store(0x5555,WRD1)
		4815	Store(0xAAAA,WRD2)
		4816	XOr(WRD1,WRD2,RWRD)
		4817	if(LNotEqual(RWRD,0xFFFF))
		4818	{ Return(1)}
		4819
		4820	//(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition
		4821	Store(0xAAAA,WRD1)
		4822	Store(0x5555,WRD2)
		4823	XOr(WRD1,WRD2,RWRD)
		4824	if(LNotEqual(RWRD,0xFFFF))
		4825	{ Return(1)}
		4826
		4827	Store(0x1234,WRD1)
		4828	Store(0xEDCB,WRD2)
		4829	XOr(WRD1,WRD2,RWRD)
		4830	if(LNotEqual(RWRD,0xFFFF))
		4831	{ Return(1)}
		4832
		4833	// Store known values for checking later
		4834	Store(0x1234, WRD1)
		4835	if(LNotEqual(WRD1, 0x1234))
		4836	{
		4837	Return(1)
		4838	}
		4839
		4840	Store(0xFEDC, WRD2)
		4841	if(LNotEqual(WRD2, 0xFEDC))
		4842	{
		4843	Return(1)
		4844	}
		4845
		4846	Store(0x87AB, RWRD)
		4847	if(LNotEqual(RWRD, 0x87AB))
		4848	{
		4849	Return(1)
		4850	}
		4851
		4852
		4853	//**************************************************
		4854	// (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition
		4855	Store(0x00000000,DWD1)
		4856	Store(0x00000000,DWD2)
		4857	XOr(DWD1,DWD2,RDWD)
		4858	if(LNotEqual(RDWD,0))
		4859	{ Return(1)}
		4860
		4861	// (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition
		4862	Store(0xffffffff,DWD1)
		4863	Store(0xffffffff,DWD2)
		4864	XOr(DWD1,DWD2,RDWD)
		4865	if(LNotEqual(RDWD,0))
		4866	{ Return(1)}
		4867
		4868	// (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
		4869	Store(0x55555555,DWD1)
		4870	Store(0xAAAAAAAA,DWD2)
		4871	XOr(DWD1,DWD2,RDWD)
		4872	if(LNotEqual(RDWD,0xFFFFFFFF))
		4873	{ Return(1)}
		4874
		4875	//(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition
		4876	Store(0xAAAAAAAA,DWD1)
		4877	Store(0x55555555,DWD2)
		4878	XOr(DWD1,DWD2,RDWD)
		4879	if(LNotEqual(RDWD,0xFFFFFFFF))
		4880	{ Return(1)}
		4881
		4882	// (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
		4883	Store(0x12345678,DWD1)
		4884	Store(0xEDCBA987,DWD2)
		4885	XOr(DWD1,DWD2,RDWD)
		4886	if(LNotEqual(RDWD,0xFFFFFFFF))
		4887	{ Return(1)}
		4888
		4889	Store(0x12345678,DWD1)
		4890	if(LNotEqual(DWD1,0x12345678))
		4891	{
		4892	Return(1)
		4893	}
		4894
		4895	Store(0xFEDCBA98,DWD2)
		4896	if(LNotEqual(DWD2,0xFEDCBA98))
		4897	{
		4898	Return(1)
		4899	}
		4900
		4901	Store(0x91827364,RDWD)
		4902	if(LNotEqual(RDWD,0x91827364))
		4903	{
		4904	Return(1)
		4905	}
		4906
		4907	//****************************************************
		4908	// Check the stored single bits
		4909	if(LNotEqual(RES1, 1))
		4910	{
		4911	Return(1)
		4912	}
		4913
		4914	if(LNotEqual(RES2, 1))
		4915	{
		4916	Return(1)
		4917	}
		4918
		4919	if(LNotEqual(RES3, 1))
		4920	{
		4921	Return(1)
		4922	}
		4923
		4924	if(LNotEqual(RES4, 1))
		4925	{
		4926	Return(1)
		4927	}
		4928
		4929	// Change all of the single bit fields to zero
		4930	Store(0, RES1)
		4931	Store(0, RES2)
		4932	Store(0, RES3)
		4933	Store(0, RES4)
		4934
		4935	// Now, check all of the fields
		4936
		4937	// Byte
		4938	if(LNotEqual(BYT1, 0x12))
		4939	{
		4940	Return(1)
		4941	}
		4942
		4943	if(LNotEqual(BYT2, 0xFE))
		4944	{
		4945	Return(1)
		4946	}
		4947
		4948	if(LNotEqual(RBYT, 0xAB))
		4949	{
		4950	Return(1)
		4951	}
		4952
		4953	// Word
		4954	if(LNotEqual(WRD1, 0x1234))
		4955	{
		4956	Return(1)
		4957	}
		4958
		4959	if(LNotEqual(WRD2, 0xFEDC))
		4960	{
		4961	Return(1)
		4962	}
		4963
		4964	if(LNotEqual(RWRD, 0x87AB))
		4965	{
		4966	Return(1)
		4967	}
		4968
		4969	// Dword
		4970	if(LNotEqual(DWD1, 0x12345678))
		4971	{
		4972	Return(1)
		4973	}
		4974
		4975	if(LNotEqual(DWD2, 0xFEDCBA98))
		4976	{
		4977	Return(1)
		4978	}
		4979
		4980	if(LNotEqual(RDWD, 0x91827364))
		4981	{
		4982	Return(1)
		4983	}
		4984
		4985	// Bits
		4986	if(LNotEqual(RES1, 0))
		4987	{
		4988	Return(1)
		4989	}
		4990
		4991	if(LNotEqual(RES2, 0))
		4992	{
		4993	Return(1)
		4994	}
		4995
		4996	if(LNotEqual(RES3, 0))
		4997	{
		4998	Return(1)
		4999	}
		5000
		5001	if(LNotEqual(RES4, 0))
		5002	{
		5003	Return(1)
		5004	}
		5005
		5006
		5007	Return(0)
		5008	} // TEST
		5009	} // XORD
		5010
		5011	//
		5012	// test CrBytFld.asl
		5013	//
		5014	// CrBytFld test
		5015	// Test for CreateByteField.
		5016	// Tests creating byte field overlay of buffer stored in Local0.
		5017	// Tests need to be added for Arg0 and Name buffers.
		5018	//
		5019	Device (CRBF)
		5020	{ // Test device name
		5021	Method (TEST)
		5022	{
		5023	Store ("++++++++ CrBytFld Test", Debug)
		5024
		5025	// Local0 is unitialized buffer with 4 elements
		5026	Store (Buffer (4) {}, Local0)
		5027
		5028	// create Byte Field named BF0 based on Local0 element 0
		5029	CreateByteField (Local0, 0, BF0)
		5030
		5031	// validate CreateByteField did not alter Local0
		5032	Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
		5033	If (LNotEqual (Local1, 3)) // Buffer object type value is 3
		5034	{ Return (2) }
		5035
		5036	// store something into BF0
		5037	Store (1, BF0)
		5038
		5039	// validate Store did not alter Local0 object type
		5040	Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
		5041	If (LNotEqual (Local1, 3)) // Buffer object type value is 3
		5042	{ Return (3) }
		5043
		5044	// verify that the Store into BF0 was successful
		5045	If (LNotEqual (BF0, 1))
		5046	{ Return (4) }
		5047
		5048
		5049	// create Byte Field named BF1 based on Local0 element 1
		5050	CreateByteField (Local0, 1, BF1)
		5051
		5052	// validate CreateByteField did not alter Local0
		5053	Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
		5054	If (LNotEqual (Local1, 3)) // Buffer object type value is 3
		5055	{ Return (10) }
		5056
		5057	// store something into BF1
		5058	Store (5, BF1)
		5059
		5060	// validate Store did not alter Local0 object type
		5061	Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
		5062	If (LNotEqual (Local1, 3)) // Buffer object type value is 3
		5063	{ Return (11) }
		5064
		5065	// verify that the Store into BF1 was successful
		5066	If (LNotEqual (BF1, 5))
		5067	{ Return (12) }
		5068
		5069	// verify that the Store into BF1 did not alter BF0
		5070	If (LNotEqual (BF0, 1))
		5071	{ Return (13) }
		5072
		5073
		5074	// store something into BF0
		5075	Store (0xFFFF, BF0)
		5076
		5077	// verify that the Store into BF0 was successful
		5078	If (LNotEqual (BF0, 0xFF))
		5079	{ Return (20) }
		5080
		5081	// verify that the Store into BF0 did not alter BF1
		5082	If (LNotEqual (BF1, 5))
		5083	{ Return (21) }
		5084
		5085
		5086	Return (0)
		5087	} // TEST
		5088	} // CRBF
		5089
		5090	//
		5091	// test IndexOp4.asl
		5092	//
		5093	// IndexOp4 test
		5094	// This is just a subset of the many RegionOp/Index Field test cases.
		5095	// Tests access of index fields smaller than 8 bits.
		5096	//
		5097	Device (IDX4)
		5098	{ // Test device name
		5099
		5100	// MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
		5101	// Tests OperationRegion memory access using misaligned BYTE,
		5102	// WORD, and DWORD field element accesses. Validation is performed
		5103	// using both misaligned field entries and aligned field entries.
		5104	//
		5105	// MADM returns 0 if all test cases pass or non-zero identifying
		5106	// the failing test case for debug purposes. This non-zero numbers
		5107	// are not guaranteed to be in perfect sequence (i.e., test case
		5108	// index), but are guaranteed to be unique so the failing test
		5109	// case can be uniquely identified.
		5110	//
		5111	Method (MADM, 1) // Misaligned Dynamic RAM SystemMemory OperationRegion
		5112	// Arg0 -- SystemMemory OperationRegion base address
		5113	{ // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
		5114	OperationRegion (RAM, SystemMemory, Arg0, 0x100)
		5115	Field (RAM, DwordAcc, NoLock, Preserve)
		5116	{ // aligned field definition (for verification)
		5117	DWD0, 32, // aligned DWORD field
		5118	DWD1, 32 // aligned DWORD field
		5119	}
		5120	Field (RAM, ByteAcc, NoLock, Preserve)
		5121	{ // bit access field definition
		5122	BIT0, 1, // single bit field entry
		5123	BIT1, 1, // single bit field entry
		5124	BIT2, 1, // single bit field entry
		5125	BIT3, 1, // single bit field entry
		5126	BIT4, 1, // single bit field entry
		5127	BIT5, 1, // single bit field entry
		5128	BIT6, 1, // single bit field entry
		5129	BIT7, 1, // single bit field entry
		5130	BIT8, 1, // single bit field entry
		5131	BIT9, 1, // single bit field entry
		5132	BITA, 1, // single bit field entry
		5133	BITB, 1, // single bit field entry
		5134	BITC, 1, // single bit field entry
		5135	BITD, 1, // single bit field entry
		5136	BITE, 1, // single bit field entry
		5137	BITF, 1, // single bit field entry
		5138	BI10, 1, // single bit field entry
		5139	BI11, 1, // single bit field entry
		5140	BI12, 1, // single bit field entry
		5141	BI13, 1, // single bit field entry
		5142	BI14, 1, // single bit field entry
		5143	BI15, 1, // single bit field entry
		5144	BI16, 1, // single bit field entry
		5145	BI17, 1, // single bit field entry
		5146	BI18, 1, // single bit field entry
		5147	BI19, 1, // single bit field entry
		5148	BI1A, 1, // single bit field entry
		5149	BI1B, 1, // single bit field entry
		5150	BI1C, 1, // single bit field entry
		5151	BI1D, 1, // single bit field entry
		5152	BI1E, 1, // single bit field entry
		5153	BI1F, 1 // single bit field entry
		5154	} // bit access field definition
		5155
		5156	Field (RAM, ByteAcc, NoLock, Preserve)
		5157	{ // two-bit access field definition
		5158	B2_0, 2, // single bit field entry
		5159	B2_1, 2, // single bit field entry
		5160	B2_2, 2, // single bit field entry
		5161	B2_3, 2, // single bit field entry
		5162	B2_4, 2, // single bit field entry
		5163	B2_5, 2, // single bit field entry
		5164	B2_6, 2, // single bit field entry
		5165	B2_7, 2, // single bit field entry
		5166	B2_8, 2, // single bit field entry
		5167	B2_9, 2, // single bit field entry
		5168	B2_A, 2, // single bit field entry
		5169	B2_B, 2, // single bit field entry
		5170	B2_C, 2, // single bit field entry
		5171	B2_D, 2, // single bit field entry
		5172	B2_E, 2, // single bit field entry
		5173	B2_F, 2 // single bit field entry
		5174	} // bit access field definition
		5175
		5176	// initialize memory contents using aligned field entries
		5177	Store (0x5AA55AA5, DWD0)
		5178	Store (0x5AA55AA5, DWD1)
		5179
		5180	// set memory contents to known values using misaligned field entries
		5181	Store (0, BIT0)
		5182	// verify memory contents using misaligned field entries
		5183	If (LNotEqual (BIT0, 0))
		5184	{ Return (1) }
		5185	// verify memory contents using aligned field entries
		5186	If (LNotEqual (DWD0, 0x5AA55AA4))
		5187	{ Return (2) }
		5188
		5189	// set memory contents to known values using misaligned field entries
		5190	Store (1, BIT1)
		5191	// verify memory contents using misaligned field entries
		5192	If (LNotEqual (BIT1, 1))
		5193	{ Return (3) }
		5194	// verify memory contents using aligned field entries
		5195	If (LNotEqual (DWD0, 0x5AA55AA6))
		5196	{ Return (4) }
		5197
		5198	// set memory contents to known values using misaligned field entries
		5199	Store (0, BIT2)
		5200	// verify memory contents using misaligned field entries
		5201	If (LNotEqual (BIT2, 0))
		5202	{ Return (5) }
		5203	// verify memory contents using aligned field entries
		5204	If (LNotEqual (DWD0, 0x5AA55AA2))
		5205	{ Return (6) }
		5206
		5207	// set memory contents to known values using misaligned field entries
		5208	Store (1, BIT3)
		5209	// verify memory contents using misaligned field entries
		5210	If (LNotEqual (BIT3, 1))
		5211	{ Return (7) }
		5212	// verify memory contents using aligned field entries
		5213	If (LNotEqual (DWD0, 0x5AA55AAA))
		5214	{ Return (8) }
		5215
		5216	// set memory contents to known values using misaligned field entries
		5217	Store (1, BIT4)
		5218	// verify memory contents using misaligned field entries
		5219	If (LNotEqual (BIT4, 1))
		5220	{ Return (9) }
		5221	// verify memory contents using aligned field entries
		5222	If (LNotEqual (DWD0, 0x5AA55ABA))
		5223	{ Return (10) }
		5224
		5225	// set memory contents to known values using misaligned field entries
		5226	Store (0, BIT5)
		5227	// verify memory contents using misaligned field entries
		5228	If (LNotEqual (BIT5, 0))
		5229	{ Return (11) }
		5230	// verify memory contents using aligned field entries
		5231	If (LNotEqual (DWD0, 0x5AA55A9A))
		5232	{ Return (12) }
		5233
		5234	// set memory contents to known values using misaligned field entries
		5235	Store (1, BIT6)
		5236	// verify memory contents using misaligned field entries
		5237	If (LNotEqual (BIT6, 1))
		5238	{ Return (13) }
		5239	// verify memory contents using aligned field entries
		5240	If (LNotEqual (DWD0, 0x5AA55ADA))
		5241	{ Return (14) }
		5242
		5243	// set memory contents to known values using misaligned field entries
		5244	Store (0, BIT7)
		5245	// verify memory contents using misaligned field entries
		5246	If (LNotEqual (BIT7, 0))
		5247	{ Return (15) }
		5248	// verify memory contents using aligned field entries
		5249	If (LNotEqual (DWD0, 0x5AA55A5A))
		5250	{ Return (16) }
		5251
		5252	// set memory contents to known values using misaligned field entries
		5253	Store (1, BIT8)
		5254	// verify memory contents using misaligned field entries
		5255	If (LNotEqual (BIT8, 1))
		5256	{ Return (17) }
		5257	// verify memory contents using aligned field entries
		5258	If (LNotEqual (DWD0, 0x5AA55B5A))
		5259	{ Return (18) }
		5260
		5261	// set memory contents to known values using misaligned field entries
		5262	Store (0, BIT9)
		5263	// verify memory contents using misaligned field entries
		5264	If (LNotEqual (BIT9, 0))
		5265	{ Return (19) }
		5266	// verify memory contents using aligned field entries
		5267	If (LNotEqual (DWD0, 0x5AA5595A))
		5268	{ Return (20) }
		5269
		5270	// set memory contents to known values using misaligned field entries
		5271	Store (1, BITA)
		5272	// verify memory contents using misaligned field entries
		5273	If (LNotEqual (BITA, 1))
		5274	{ Return (21) }
		5275	// verify memory contents using aligned field entries
		5276	If (LNotEqual (DWD0, 0x5AA55D5A))
		5277	{ Return (22) }
		5278
		5279	// set memory contents to known values using misaligned field entries
		5280	Store (0, BITB)
		5281	// verify memory contents using misaligned field entries
		5282	If (LNotEqual (BITB, 0))
		5283	{ Return (23) }
		5284	// verify memory contents using aligned field entries
		5285	If (LNotEqual (DWD0, 0x5AA5555A))
		5286	{ Return (24) }
		5287
		5288	// set memory contents to known values using misaligned field entries
		5289	Store (0, BITC)
		5290	// verify memory contents using misaligned field entries
		5291	If (LNotEqual (BITC, 0))
		5292	{ Return (25) }
		5293	// verify memory contents using aligned field entries
		5294	If (LNotEqual (DWD0, 0x5AA5455A))
		5295	{ Return (26) }
		5296
		5297	// set memory contents to known values using misaligned field entries
		5298	Store (1, BITD)
		5299	// verify memory contents using misaligned field entries
		5300	If (LNotEqual (BITD, 1))
		5301	{ Return (27) }
		5302	// verify memory contents using aligned field entries
		5303	If (LNotEqual (DWD0, 0x5AA5655A))
		5304	{ Return (28) }
		5305
		5306	// set memory contents to known values using misaligned field entries
		5307	Store (0, BITE)
		5308	// verify memory contents using misaligned field entries
		5309	If (LNotEqual (BITE, 0))
		5310	{ Return (29) }
		5311	// verify memory contents using aligned field entries
		5312	If (LNotEqual (DWD0, 0x5AA5255A))
		5313	{ Return (30) }
		5314
		5315	// set memory contents to known values using misaligned field entries
		5316	Store (1, BITF)
		5317	// verify memory contents using misaligned field entries
		5318	If (LNotEqual (BITF, 1))
		5319	{ Return (31) }
		5320	// verify memory contents using aligned field entries
		5321	If (LNotEqual (DWD0, 0x5AA5A55A))
		5322	{ Return (32) }
		5323
		5324	// set memory contents to known values using misaligned field entries
		5325	Store (0, BI10)
		5326	// verify memory contents using misaligned field entries
		5327	If (LNotEqual (BI10, 0))
		5328	{ Return (33) }
		5329	// verify memory contents using aligned field entries
		5330	If (LNotEqual (DWD0, 0x5AA4A55A))
		5331	{ Return (34) }
		5332
		5333	// set memory contents to known values using misaligned field entries
		5334	Store (1, BI11)
		5335	// verify memory contents using misaligned field entries
		5336	If (LNotEqual (BI11, 1))
		5337	{ Return (35) }
		5338	// verify memory contents using aligned field entries
		5339	If (LNotEqual (DWD0, 0x5AA6A55A))
		5340	{ Return (36) }
		5341
		5342	// set memory contents to known values using misaligned field entries
		5343	Store (0, BI12)
		5344	// verify memory contents using misaligned field entries
		5345	If (LNotEqual (BI12, 0))
		5346	{ Return (37) }
		5347	// verify memory contents using aligned field entries
		5348	If (LNotEqual (DWD0, 0x5AA2A55A))
		5349	{ Return (38) }
		5350
		5351	// set memory contents to known values using misaligned field entries
		5352	Store (1, BI13)
		5353	// verify memory contents using misaligned field entries
		5354	If (LNotEqual (BI13, 1))
		5355	{ Return (39) }
		5356	// verify memory contents using aligned field entries
		5357	If (LNotEqual (DWD0, 0x5AAAA55A))
		5358	{ Return (40) }
		5359
		5360	// set memory contents to known values using misaligned field entries
		5361	Store (1, BI14)
		5362	// verify memory contents using misaligned field entries
		5363	If (LNotEqual (BI14, 1))
		5364	{ Return (41) }
		5365	// verify memory contents using aligned field entries
		5366	If (LNotEqual (DWD0, 0x5ABAA55A))
		5367	{ Return (42) }
		5368
		5369	// set memory contents to known values using misaligned field entries
		5370	Store (0, BI15)
		5371	// verify memory contents using misaligned field entries
		5372	If (LNotEqual (BI15, 0))
		5373	{ Return (43) }
		5374	// verify memory contents using aligned field entries
		5375	If (LNotEqual (DWD0, 0x5A9AA55A))
		5376	{ Return (44) }
		5377
		5378	// set memory contents to known values using misaligned field entries
		5379	Store (1, BI16)
		5380	// verify memory contents using misaligned field entries
		5381	If (LNotEqual (BI16, 1))
		5382	{ Return (45) }
		5383	// verify memory contents using aligned field entries
		5384	If (LNotEqual (DWD0, 0x5ADAA55A))
		5385	{ Return (46) }
		5386
		5387	// set memory contents to known values using misaligned field entries
		5388	Store (0, BI17)
		5389	// verify memory contents using misaligned field entries
		5390	If (LNotEqual (BI17, 0))
		5391	{ Return (47) }
		5392	// verify memory contents using aligned field entries
		5393	If (LNotEqual (DWD0, 0x5A5AA55A))
		5394	{ Return (48) }
		5395
		5396	// set memory contents to known values using misaligned field entries
		5397	Store (1, BI18)
		5398	// verify memory contents using misaligned field entries
		5399	If (LNotEqual (BI18, 1))
		5400	{ Return (49) }
		5401	// verify memory contents using aligned field entries
		5402	If (LNotEqual (DWD0, 0x5B5AA55A))
		5403	{ Return (50) }
		5404
		5405	// set memory contents to known values using misaligned field entries
		5406	Store (0, BI19)
		5407	// verify memory contents using misaligned field entries
		5408	If (LNotEqual (BI19, 0))
		5409	{ Return (51) }
		5410	// verify memory contents using aligned field entries
		5411	If (LNotEqual (DWD0, 0x595AA55A))
		5412	{ Return (52) }
		5413
		5414	// set memory contents to known values using misaligned field entries
		5415	Store (1, BI1A)
		5416	// verify memory contents using misaligned field entries
		5417	If (LNotEqual (BI1A, 1))
		5418	{ Return (53) }
		5419	// verify memory contents using aligned field entries
		5420	If (LNotEqual (DWD0, 0x5D5AA55A))
		5421	{ Return (54) }
		5422
		5423	// set memory contents to known values using misaligned field entries
		5424	Store (0, BI1B)
		5425	// verify memory contents using misaligned field entries
		5426	If (LNotEqual (BI1B, 0))
		5427	{ Return (55) }
		5428	// verify memory contents using aligned field entries
		5429	If (LNotEqual (DWD0, 0x555AA55A))
		5430	{ Return (56) }
		5431
		5432	// set memory contents to known values using misaligned field entries
		5433	Store (0, BI1C)
		5434	// verify memory contents using misaligned field entries
		5435	If (LNotEqual (BI1C, 0))
		5436	{ Return (57) }
		5437	// verify memory contents using aligned field entries
		5438	If (LNotEqual (DWD0, 0x455AA55A))
		5439	{ Return (58) }
		5440
		5441	// set memory contents to known values using misaligned field entries
		5442	Store (1, BI1D)
		5443	// verify memory contents using misaligned field entries
		5444	If (LNotEqual (BI1D, 1))
		5445	{ Return (59) }
		5446	// verify memory contents using aligned field entries
		5447	If (LNotEqual (DWD0, 0x655AA55A))
		5448	{ Return (60) }
		5449
		5450	// set memory contents to known values using misaligned field entries
		5451	Store (0, BI1E)
		5452	// verify memory contents using misaligned field entries
		5453	If (LNotEqual (BI1E, 0))
		5454	{ Return (61) }
		5455	// verify memory contents using aligned field entries
		5456	If (LNotEqual (DWD0, 0x255AA55A))
		5457	{ Return (62) }
		5458
		5459	// set memory contents to known values using misaligned field entries
		5460	Store (1, BI1F)
		5461	// verify memory contents using misaligned field entries
		5462	If (LNotEqual (BI1F, 1))
		5463	{ Return (63) }
		5464	// verify memory contents using aligned field entries
		5465	If (LNotEqual (DWD0, 0xA55AA55A))
		5466	{ Return (64) }
		5467
		5468
		5469	// set memory contents to known values using misaligned field entries
		5470	Store (3, B2_0)
		5471	// verify memory contents using misaligned field entries
		5472	If (LNotEqual (B2_0, 3))
		5473	{ Return (65) }
		5474	// verify memory contents using aligned field entries
		5475	If (LNotEqual (DWD0, 0xA55AA55B))
		5476	{ Return (66) }
		5477
		5478	// set memory contents to known values using misaligned field entries
		5479	Store (1, B2_1)
		5480	// verify memory contents using misaligned field entries
		5481	If (LNotEqual (B2_1, 1))
		5482	{ Return (67) }
		5483	// verify memory contents using aligned field entries
		5484	If (LNotEqual (DWD0, 0xA55AA557))
		5485	{ Return (68) }
		5486
		5487	// set memory contents to known values using misaligned field entries
		5488	Store (0, B2_2)
		5489	// verify memory contents using misaligned field entries
		5490	If (LNotEqual (B2_2, 0))
		5491	{ Return (69) }
		5492	// verify memory contents using aligned field entries
		5493	If (LNotEqual (DWD0, 0xA55AA547))
		5494	{ Return (70) }
		5495
		5496	// set memory contents to known values using misaligned field entries
		5497	Store (3, B2_3)
		5498	// verify memory contents using misaligned field entries
		5499	If (LNotEqual (B2_3, 3))
		5500	{ Return (71) }
		5501	// verify memory contents using aligned field entries
		5502	If (LNotEqual (DWD0, 0xA55AA5C7))
		5503	{ Return (72) }
		5504
		5505	// set memory contents to known values using misaligned field entries
		5506	Store (3, B2_4)
		5507	// verify memory contents using misaligned field entries
		5508	If (LNotEqual (B2_4, 3))
		5509	{ Return (73) }
		5510	// verify memory contents using aligned field entries
		5511	If (LNotEqual (DWD0, 0xA55AA7C7))
		5512	{ Return (74) }
		5513
		5514	// set memory contents to known values using misaligned field entries
		5515	Store (0, B2_5)
		5516	// verify memory contents using misaligned field entries
		5517	If (LNotEqual (B2_5, 0))
		5518	{ Return (75) }
		5519	// verify memory contents using aligned field entries
		5520	If (LNotEqual (DWD0, 0xA55AA3C7))
		5521	{ Return (76) }
		5522
		5523	// set memory contents to known values using misaligned field entries
		5524	Store (1, B2_6)
		5525	// verify memory contents using misaligned field entries
		5526	If (LNotEqual (B2_6, 1))
		5527	{ Return (77) }
		5528	// verify memory contents using aligned field entries
		5529	If (LNotEqual (DWD0, 0xA55A93C7))
		5530	{ Return (78) }
		5531
		5532	// set memory contents to known values using misaligned field entries
		5533	Store (1, B2_7)
		5534	// verify memory contents using misaligned field entries
		5535	If (LNotEqual (B2_7, 1))
		5536	{ Return (79) }
		5537	// verify memory contents using aligned field entries
		5538	If (LNotEqual (DWD0, 0xA55A53C7))
		5539	{ Return (80) }
		5540
		5541	// set memory contents to known values using misaligned field entries
		5542	Store (0, B2_8)
		5543	// verify memory contents using misaligned field entries
		5544	If (LNotEqual (B2_8, 0))
		5545	{ Return (81) }
		5546	// verify memory contents using aligned field entries
		5547	If (LNotEqual (DWD0, 0xA55853C7))
		5548	{ Return (82) }
		5549
		5550	// set memory contents to known values using misaligned field entries
		5551	Store (1, B2_9)
		5552	// verify memory contents using misaligned field entries
		5553	If (LNotEqual (B2_9, 1))
		5554	{ Return (83) }
		5555	// verify memory contents using aligned field entries
		5556	If (LNotEqual (DWD0, 0xA55453C7))
		5557	{ Return (84) }
		5558
		5559	// set memory contents to known values using misaligned field entries
		5560	Store (2, B2_A)
		5561	// verify memory contents using misaligned field entries
		5562	If (LNotEqual (B2_A, 2))
		5563	{ Return (85) }
		5564	// verify memory contents using aligned field entries
		5565	If (LNotEqual (DWD0, 0xA56453C7))
		5566	{ Return (86) }
		5567
		5568	// set memory contents to known values using misaligned field entries
		5569	Store (2, B2_B)
		5570	// verify memory contents using misaligned field entries
		5571	If (LNotEqual (B2_B, 2))
		5572	{ Return (87) }
		5573	// verify memory contents using aligned field entries
		5574	If (LNotEqual (DWD0, 0xA5A453C7))
		5575	{ Return (88) }
		5576
		5577	// set memory contents to known values using misaligned field entries
		5578	Store (3, B2_C)
		5579	// verify memory contents using misaligned field entries
		5580	If (LNotEqual (B2_C, 3))
		5581	{ Return (89) }
		5582	// verify memory contents using aligned field entries
		5583	If (LNotEqual (DWD0, 0xA7A453C7))
		5584	{ Return (90) }
		5585
		5586	// set memory contents to known values using misaligned field entries
		5587	Store (3, B2_D)
		5588	// verify memory contents using misaligned field entries
		5589	If (LNotEqual (B2_D, 3))
		5590	{ Return (91) }
		5591	// verify memory contents using aligned field entries
		5592	If (LNotEqual (DWD0, 0xAFA453C7))
		5593	{ Return (92) }
		5594
		5595	// set memory contents to known values using misaligned field entries
		5596	Store (1, B2_E)
		5597	// verify memory contents using misaligned field entries
		5598	If (LNotEqual (B2_E, 1))
		5599	{ Return (93) }
		5600	// verify memory contents using aligned field entries
		5601	If (LNotEqual (DWD0, 0x9FA453C7))
		5602	{ Return (94) }
		5603
		5604	// set memory contents to known values using misaligned field entries
		5605	Store (0, B2_F)
		5606	// verify memory contents using misaligned field entries
		5607	If (LNotEqual (B2_F, 0))
		5608	{ Return (95) }
		5609	// verify memory contents using aligned field entries
		5610	If (LNotEqual (DWD0, 0x1FA453C7))
		5611	{ Return (96) }
		5612
		5613
		5614	Return (0) // pass
		5615	} // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
		5616
		5617	Method (TEST)
		5618	{
		5619	Store ("++++++++ IndexOp4 Test", Debug)
		5620
		5621	// MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments:
		5622	// Arg0 -- SystemMemory OperationRegion base address
		5623	Store (MADM (0x800000), Local0)
		5624	If (LNotEqual (Local0, 0)) // MADM returns zero if successful
		5625	{ Return (Local0) } // failure: return MADM error code
		5626
		5627	Return (Local0)
		5628	} // TEST
		5629	} // IDX4
		5630
		5631	//
		5632	// test Event.asl
		5633	//
		5634	// EventOp, ResetOp, SignalOp, and WaitOp test cases.
		5635	//
		5636	Device (EVNT)
		5637	{
		5638	Event (EVNT) // event synchronization object
		5639
		5640	Method (TEVN, 1)
		5641	// Arg0: time to Wait for event in milliseconds
		5642	{ // TEVN control method to test ResetOp, SignalOp, and WaitOp
		5643	// reset EVNT to initialization (zero) state
		5644	Reset (EVNT)
		5645
		5646	// prime EVNT with two outstanding signals
		5647	Signal (EVNT)
		5648	Signal (EVNT)
		5649
		5650
		5651	// acquire existing signal
		5652	Store (Wait (EVNT, Arg0), Local0)
		5653
		5654	// validate Local0 is a Number
		5655	Store (ObjectType (Local0), Local1)
		5656	If (LNotEqual (Local1, 1)) // Number is type 1
		5657	{ Return (0x21) } // Local1 indicates Local0 is not a Number
		5658
		5659	If (LNotEqual (Local0, 0)) // Number is type 1
		5660	{ Return (0x22) } // timeout occurred without acquiring signal
		5661
		5662	Store ("Acquire 1st existing signal PASS", Debug)
		5663
		5664
		5665	// acquire existing signal
		5666	Store (Wait (EVNT, Arg0), Local0)
		5667
		5668	// validate Local0 is a Number
		5669	Store (ObjectType (Local0), Local1)
		5670	If (LNotEqual (Local1, 1)) // Number is type 1
		5671	{ Return (0x31) } // Local1 indicates Local0 is not a Number
		5672
		5673	If (LNotEqual (Local0, 0)) // Number is type 1
		5674	{ Return (0x32) } // timeout occurred without acquiring signal
		5675
		5676	Store ("Acquire 2nd existing signal PASS", Debug)
		5677
		5678
		5679	// ensure WaitOp timeout test cases do not hang
		5680	if (LEqual (Arg0, 0xFFFF))
		5681	{ Store (0xFFFE, Arg0) }
		5682
		5683	// acquire non-existing signal
		5684	Store (Wait (EVNT, Arg0), Local0)
		5685
		5686	// validate Local0 is a Number
		5687	Store (ObjectType (Local0), Local1)
		5688	If (LNotEqual (Local1, 1)) // Number is type 1
		5689	{ Return (0x41) } // Local1 indicates Local0 is not a Number
		5690
		5691	If (LEqual (Local0, 0)) // Number is type 1
		5692	{ Return (0x42) } // non-existant signal was acquired
		5693
		5694	Store ("Acquire signal timeout PASS", Debug)
		5695
		5696
		5697	// prime EVNT with two outstanding signals
		5698	Signal (EVNT)
		5699	Signal (EVNT)
		5700
		5701	// reset EVNT to initialization (zero) state
		5702	Reset (EVNT)
		5703
		5704	// acquire non-existing signal
		5705	Store (Wait (EVNT, Arg0), Local0)
		5706
		5707	// validate Local0 is a Number
		5708	Store (ObjectType (Local0), Local1)
		5709	If (LNotEqual (Local1, 1)) // Number is type 1
		5710	{ Return (0x51) } // Local1 indicates Local0 is not a Number
		5711
		5712	If (LEqual (Local0, 0)) // Number is type 1
		5713	{ Return (0x52) } // non-existant signal was acquired
		5714
		5715	Store ("Reset signal PASS", Debug)
		5716
		5717
		5718	// acquire non-existing signal using Lvalue timeout
		5719	Store (Wait (EVNT, Zero), Local0)
		5720
		5721	// validate Local0 is a Number
		5722	Store (ObjectType (Local0), Local1)
		5723	If (LNotEqual (Local1, 1)) // Number is type 1
		5724	{ Return (0x61) } // Local1 indicates Local0 is not a Number
		5725
		5726	If (LEqual (Local0, 0)) // Number is type 1
		5727	{ Return (0x62) } // non-existant signal was acquired
		5728
		5729	Store ("Zero Lvalue PASS", Debug)
		5730
		5731
		5732	// acquire non-existing signal using Lvalue timeout
		5733	Store (Wait (EVNT, One), Local0)
		5734
		5735	// validate Local0 is a Number
		5736	Store (ObjectType (Local0), Local1)
		5737	If (LNotEqual (Local1, 1)) // Number is type 1
		5738	{ Return (0x71) } // Local1 indicates Local0 is not a Number
		5739
		5740	If (LEqual (Local0, 0)) // Number is type 1
		5741	{ Return (0x72) } // non-existant signal was acquired
		5742
		5743	Store ("One Lvalue PASS", Debug)
		5744
		5745	// Lvalue Event test cases
		5746	// ILLEGAL SOURCE OPERAND Store (EVNT, Local2)
		5747
		5748	// validate Local2 is an Event
		5749	Store (ObjectType (EVNT), Local1)
		5750	If (LNotEqual (Local1, 7)) // Event is type 7
		5751	{ Return (0x81) } // Local1 indicates Local0 is not a Number
		5752
		5753	// reset EVNT to initialization (zero) state
		5754	Reset (EVNT)
		5755
		5756	// prime EVNT with two outstanding signals
		5757	Signal (EVNT)
		5758
		5759	// acquire existing signal
		5760	Store (Wait (EVNT, Arg0), Local0)
		5761
		5762	// validate Local0 is a Number
		5763	Store (ObjectType (Local0), Local1)
		5764	If (LNotEqual (Local1, 1)) // Number is type 1
		5765	{ Return (0x82) } // Local1 indicates Local0 is not a Number
		5766
		5767	If (LNotEqual (Local0, 0)) // Number is type 1
		5768	{ Return (0x83) } // timeout occurred without acquiring signal
		5769
		5770	Store ("Acquire Lvalue existing signal PASS", Debug)
		5771
		5772
		5773	// acquire non-existing signal
		5774	Store (Wait (EVNT, Arg0), Local0)
		5775
		5776	// validate Local0 is a Number
		5777	Store (ObjectType (Local0), Local1)
		5778	If (LNotEqual (Local1, 1)) // Number is type 1
		5779	{ Return (0x84) } // Local1 indicates Local0 is not a Number
		5780
		5781	If (LEqual (Local0, 0)) // Number is type 1
		5782	{ Return (0x85) } // non-existant signal was acquired
		5783
		5784	Store ("Acquire Lvalue signal timeout PASS", Debug)
		5785
		5786
		5787	Return (0) // success
		5788	} // TEVN control method to test ResetOp, SignalOp, and WaitOp
		5789
		5790	Method (TEST)
		5791	{
		5792	Store ("++++++++ Event Test", Debug)
		5793
		5794	Store (TEVN (100), Local0)
		5795
		5796	Return (Local0)
		5797	} // TEST
		5798	} // EVNT
		5799
		5800	//
		5801	// test SizeOfLv.asl
		5802	//
		5803	// Test for SizeOf (Lvalue)
		5804	//
		5805	// This next section will contain the packages that the SizeOfOp will be
		5806	// exercised on. The first one, PKG0, is a regular package of 3 elements.
		5807	// The 2nd one, PKG1, is a nested package with 3 packages inside it, each
		5808	// with 3 elements. It is expected that SizeOf operator will return the
		5809	// same value for these two packages since they both have 3 elements. The
		5810	// final package, PKG2, has 4 elements and the SizeOf operator is expected
		5811	// to return different results for this package.
		5812
		5813	Name (PKG0,
		5814	Package (3)
		5815	{0x0123, 0x4567, 0x89AB}
		5816	) // PKG0
		5817
		5818	Name (PKG1,
		5819	Package (3)
		5820	{
		5821	Package (3) {0x0123, 0x4567, 0x89AB},
		5822	Package (3) {0xCDEF, 0xFEDC, 0xBA98},
		5823	Package (3) {0x7654, 0x3210, 0x1234}
		5824	}
		5825	) // PKG1
		5826
		5827	Name (PKG2,
		5828	Package (4)
		5829	{0x0123, 0x4567, 0x89AB, 0x8888}
		5830	) // PKG2
		5831
		5832	Name (PKG3,
		5833	Package (5)
		5834	{0x0123, 0x4567, 0x89AB, 0x8888, 0x7777}
		5835	) // PKG3
		5836
		5837	// End Packages **********************************************************
		5838
		5839	// The following section will declare the data strings that will be used to
		5840	// exercise the SizeOf operator. STR0 and STR1 are expected to be equal,
		5841	// STR2 is expected to have a different SizeOf value than STR0 and STR1.
		5842
		5843	Name (STR0, "ACPI permits very flexible methods of expressing a system")
		5844
		5845	Name (STR1, "MIKE permits very flexible methods of expressing a system")
		5846
		5847	Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
		5848
		5849	// This string is being made in case we want to do a SizeOf comparison
		5850	// between strings and packages or buffers
		5851	Name (STR3, "12345")
		5852
		5853	// End Strings **********************************************************
		5854
		5855	// The following section will declare the buffers that will be used to exercise
		5856	// the SizeOf operator.
		5857
		5858	Name (BUF0, Buffer (10) {})
		5859	Name (BUF1, Buffer (10) {})
		5860	Name (BUF2, Buffer (8) {})
		5861	Name (BUF3, Buffer (5) {})
		5862
		5863	// End Buffers **********************************************************
		5864	Device (SZLV)
		5865	{
		5866
		5867	Method (CMPR, 2)
		5868	{
		5869	// CMPR is passed two arguments. If unequal, return 1 to indicate
		5870	// that, otherwise return 0 to indicate SizeOf each is equal.
		5871
		5872	Store (0x01, Local0)
		5873
		5874	if (LEqual (SizeOf(Arg0), SizeOf(Arg1)))
		5875	{
		5876	Store (0x00, Local0)
		5877	}
		5878
		5879	return (Local0)
		5880	} // CMPR
		5881
		5882
		5883	Method (TEST)
		5884	{
		5885
		5886	Store ("++++++++ SizeOfLv Test", Debug)
		5887
		5888	// TBD: SizeOf ("string")
		5889	// SizeOf (Buffer)
		5890	// SizeOf (Package)
		5891	// SizeOf (String)
		5892	// SizeOf (STR0) -- where Name (STR0,...) -- lot's of cases
		5893	// buffer, string, package,
		5894	// SizeOf (METH) -- where METH control method returns
		5895	// buffer, string, package,
		5896
		5897	// TBD: SLOC [SizeOf (Local0)] -- dup SARG
		5898
		5899	// Compare the elements that we expect to be the same. Exit out with an error
		5900	// code on the first failure.
		5901	if (LNotEqual (0x00, CMPR (STR0, STR1)))
		5902	{
		5903	Return (0x01)
		5904	}
		5905
		5906	if (LNotEqual (0x00, CMPR (STR3, BUF3)))
		5907	{
		5908	Return (0x02)
		5909	}
		5910
		5911	if (LNotEqual (0x00, CMPR (STR3, PKG3)))
		5912	{
		5913	Return (0x03)
		5914	}
		5915
		5916	// In the following section, this test will cover the SizeOf
		5917	// operator for Local values.
		5918	// In this case, both Local0 and Local1 should have the same Size
		5919	Store (STR0, Local0)
		5920	Store (STR1, Local1)
		5921
		5922	if (LNotEqual (SizeOf (Local0), SizeOf (Local1)))
		5923	{
		5924	Return (0x04)
		5925	}
		5926
		5927	// Now create a case where Local0 and Local1 are different
		5928	Store (STR2, Local1)
		5929
		5930	if (LEqual (SizeOf (Local0), SizeOf (Local1)))
		5931	{
		5932	Return (0x05)
		5933	}
		5934
		5935	// Finally, check for the return of SizeOf for a known Buffer. Just
		5936	// in case we magically pass above cases due to all Buffers being Zero
		5937	// bytes in size, or Infinity, etc.
		5938	if (LNotEqual (0x05, SizeOf (BUF3)))
		5939	{
		5940	Return (0x06)
		5941	}
		5942
		5943	Return (0)
		5944	} // TEST
		5945	} // SZLV
		5946
		5947
		5948	//
		5949	// test BytField.asl
		5950	//
		5951	// BytField test
		5952	// This is just a subset of the many RegionOp/Index Field test cases.
		5953	// Tests access of TBD.
		5954	//
		5955	Scope (\_SB) // System Bus
		5956	{ // _SB system bus
		5957	Device (BYTF)
		5958	{ // Test device name
		5959	Method (TEST)
		5960	{
		5961	Store ("++++++++ BytField Test", Debug)
		5962
		5963	Return (\_TZ.C19B.RSLT)
		5964	} // TEST
		5965	} // BYTF
		5966
		5967	Device (C005)
		5968	{ // Device C005
		5969	Device (C013)
		5970	{ // Device C013
		5971	} // Device C013
		5972	} // Device C005
		5973
		5974	Method (C115)
		5975	{ // C115 control method
		5976	Acquire (\_GL, 0xFFFF)
		5977	Store (\_SB.C005.C013.C058.C07E, Local0)
		5978	Release (\_GL)
		5979	And (Local0, 16, Local0)
		5980	Store (ShiftRight (Local0, 4, ), Local1)
		5981	If (LEqual (Local1, 0))
		5982	{ Return (1) }
		5983	Else
		5984	{ Return (0) }
		5985	} // C115 control method
		5986	} // _SB system bus
		5987
		5988	OperationRegion (C018, SystemIO, 0x5028, 4)
		5989	Field (C018, AnyAcc, NoLock, Preserve)
		5990	{ // Field overlaying C018
		5991	C019, 32
		5992	} // Field overlaying C018
		5993
		5994	OperationRegion (C01A, SystemIO, 0x5030, 4)
		5995	Field (C01A, ByteAcc, NoLock, Preserve)
		5996	{ // Field overlaying C01A
		5997	C01B, 8,
		5998	C01C, 8,
		5999	C01D, 8,
		6000	C01E, 8
		6001	} // Field overlaying C01A
		6002
		6003	Mutex (\C01F, 0)
		6004	Name (\C020, 0)
		6005	Name (\C021, 0)
		6006
		6007	Method (\C022, 0)
		6008	{ // \C022 control method
		6009	Acquire (\C01F, 0xFFFF)
		6010	If (LEqual (\C021, 0))
		6011	{
		6012	Store (C019, Local0)
		6013	And (Local0, 0xFFFEFFFE, Local0)
		6014	Store (Local0, C019)
		6015	Increment (\C021)
		6016	}
		6017	Release (\C01F)
		6018	} // \C022 control method
		6019
		6020	Scope (\_SB.C005.C013)
		6021	{ // Scope \_SB.C005.C013
		6022	Device (C058)
		6023	{ // Device C058
		6024	Name (_HID, "*PNP0A06")
		6025
		6026	OperationRegion (C059, SystemIO, 0xE0, 2)
		6027	Field (C059, ByteAcc, NoLock, Preserve)
		6028	{ // Field overlaying C059
		6029	C05A, 8,
		6030	C05B, 8
		6031	} // Field overlaying C059
		6032
		6033	OperationRegion (C05C, SystemIO, 0xE2, 2)
		6034	Field (C05C, ByteAcc, NoLock, Preserve)
		6035	{ // Field overlaying C05C
		6036	C05D, 8,
		6037	C05E, 8
		6038	} // Field overlaying C05C
		6039	IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
		6040	{ // IndexField overlaying C05D/C05E
		6041	, 0x410, // skip
		6042	C05F, 8,
		6043	C060, 8,
		6044	C061, 8,
		6045	C062, 8,
		6046	C063, 8,
		6047	C064, 8,
		6048	C065, 8,
		6049	C066, 8,
		6050	C067, 8,
		6051	C068, 8,
		6052	C069, 8,
		6053	C06A, 8,
		6054	C06B, 8,
		6055	C06C, 8,
		6056	C06D, 8,
		6057	C06E, 8,
		6058	, 0x70, // skip
		6059	C06F, 8,
		6060	C070, 8,
		6061	C071, 8,
		6062	C072, 8,
		6063	C073, 8,
		6064	C074, 8,
		6065	C075, 8,
		6066	C076, 8,
		6067	C077, 8,
		6068	C078, 8,
		6069	C079, 8,
		6070	C07A, 8,
		6071	C07B, 8,
		6072	C07C, 8,
		6073	C07D, 8,
		6074	C07E, 8
		6075	} // IndexField overlaying C05D/C05E
		6076
		6077	OperationRegion (C07F, SystemIO, 0xE4, 2)
		6078	Field (C07F, ByteAcc, NoLock, Preserve)
		6079	{ // Field overlaying C07F
		6080	C080, 8,
		6081	C081, 8
		6082	} // Field overlaying C07F
		6083
		6084	OperationRegion (C082, SystemIO, 0xE0, 1)
		6085	Field (C082, ByteAcc, NoLock, Preserve)
		6086	{ // Field overlaying C082
		6087	C083, 8
		6088	} // Field overlaying C082
		6089
		6090	OperationRegion (C084, SystemIO, 0xFF, 1)
		6091	Field (C084, ByteAcc, NoLock, Preserve)
		6092	{ // Field overlaying C084
		6093	C085, 8
		6094	} // Field overlaying C084
		6095
		6096	OperationRegion (C086, SystemIO, 0xFD, 1)
		6097	Field (C086, ByteAcc, NoLock, Preserve)
		6098	{ // Field overlaying C086
		6099	C087, 8
		6100	} // Field overlaying C086
		6101
		6102	Mutex (C088, 0)
		6103	Mutex (C089, 0)
		6104	Mutex (C08A, 0)
		6105	Mutex (C08B, 0)
		6106	Mutex (C08C, 0)
		6107	Mutex (C08D, 0)
		6108
		6109	Name (C08E, 0xFFFFFFFD)
		6110	Name (C08F, 0)
		6111
		6112	Method (C0AA, 4)
		6113	{ // C0AA control method
		6114	Store (Buffer (4) {}, Local7)
		6115	CreateByteField (Local7, 0, C0AB)
		6116	CreateByteField (Local7, 1, C0AC)
		6117	CreateByteField (Local7, 2, C0AD)
		6118	CreateByteField (Local7, 3, C0AE)
		6119	Acquire (^C08B, 0xFFFF)
		6120	Acquire (\_GL, 0xFFFF)
		6121	\C022 ()
		6122	Store (1, \_SB.C005.C013.C058.C06B)
		6123	While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
		6124	{ Stall (100) }
		6125	Store (Arg3, \_SB.C005.C013.C058.C06E)
		6126	Store (Arg2, \_SB.C005.C013.C058.C06D)
		6127	Store (Arg1, \_SB.C005.C013.C058.C06C)
		6128	Store (Arg0, \_SB.C005.C013.C058.C06B)
		6129	While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
		6130	{ Stall (100) }
		6131	Store (\_SB.C005.C013.C058.C06E, C0AB)
		6132	Store (\_SB.C005.C013.C058.C06D, C0AC)
		6133	Store (\_SB.C005.C013.C058.C06C, C0AD)
		6134	Store (\_SB.C005.C013.C058.C06B, C0AE)
		6135	If (LNot (LEqual (Arg0, 23)))
		6136	{
		6137	Store (2, \_SB.C005.C013.C058.C06B)
		6138	Stall (100)
		6139	}
		6140	Release (\_GL)
		6141	Release (^C08B)
		6142	Return (Local7)
		6143	} // C0AA control method
		6144	} // Device C058
		6145	} // Scope \_SB.C005.C013
		6146
		6147	Scope (\_TZ)
		6148	{ // \_TZ thermal zone scope
		6149	Name (C18B, Package (2)
		6150	{
		6151	Package (2)
		6152	{
		6153	Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
		6154	Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
		6155	},
		6156	Package (2)
		6157	{
		6158	Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
		6159	Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
		6160	}
		6161	}) // C18B
		6162
		6163	Name (C18C, Package (2)
		6164	{
		6165	Package (2)
		6166	{
		6167	Package (3) {0x64, 0x4B, 0x32},
		6168	Package (3) {0x64, 0x4B, 0x32}
		6169	}
		6170	}) // C81C
		6171
		6172	Name (C18D, 0)
		6173	Name (C18E, 0)
		6174	Name (C18F, 0)
		6175	Name (C190, 0)
		6176	Name (C191, 3)
		6177	Name (C192, 0)
		6178	Name (C193, 1)
		6179	Name (C194, 2)
		6180	Mutex (C195, 0)
		6181	Name (C196, 1)
		6182	Name (C197, 0x0B9C)
		6183	Name (C198, 0x0B9C)
		6184	Name (C199, 0xFFFFFFFD)
		6185	Name (C19A, 0)
		6186
		6187	Device (C19B)
		6188	{ // Device C19B
		6189	Name (RSLT, 0) // default to zero
		6190
		6191	Method (XINI)
		6192	{ // _INI control method (Uses Global Lock -- can't run under AcpiExec)
		6193	Store (\_SB.C115, C19A)
		6194	\_TZ.C19C._SCP (0)
		6195	Subtract (0x0EB2, 0x0AAC, Local1) // Local1 = AACh - EB2h
		6196	Divide (Local1, 10, Local0, Local2) // Local0 = Local1 / 10
		6197	// Local2 = Local1 % 10
		6198	\_SB.C005.C013.C058.C0AA (14, Local2, 0, 0)
		6199	Store
		6200	(DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D)
		6201	Store
		6202	(DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E)
		6203	Store
		6204	(DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F)
		6205
		6206	Store (1, RSLT) // set RSLT to 1 if _INI control method completes
		6207	} // _INI control method
		6208
		6209	// PowerResource (C19D) {...}
		6210	} // Device C19B
		6211
		6212	ThermalZone (C19C)
		6213	{
		6214	Method (_SCP, 1)
		6215	{ // _SCP control method
		6216	Store (Arg0, Local0)
		6217	If (LEqual (Local0, 0))
		6218	{
		6219	Store (0, \_TZ.C192)
		6220	Store (1, \_TZ.C193)
		6221	Store (2, \_TZ.C194)
		6222	Store (3, \_TZ.C191)
		6223	}
		6224	Else
		6225	{
		6226	Store (0, \_TZ.C191)
		6227	Store (1, \_TZ.C192)
		6228	Store (2, \_TZ.C193)
		6229	Store (3, \_TZ.C194)
		6230	}
		6231	} // _SCP control method
		6232	} // ThermalZone C19C
		6233	} // \_TZ thermal zone scope
		6234
		6235
		6236	//
		6237	// test DwrdFld.asl
		6238	//
		6239	Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} )
		6240
		6241	Device (DWDF)
		6242	{
		6243	Method (TEST)
		6244	{
		6245	Store ("++++++++ DwrdFld Test", Debug)
		6246
		6247	CreateByteField (BUFR, 0, BYTE)
		6248	Store (0xAA, BYTE)
		6249
		6250	CreateWordField (BUFR, 1, WORD)
		6251	Store (0xBBCC, WORD)
		6252
		6253	CreateDWordField (BUFR, 3, DWRD)
		6254	Store (0xDDEEFF00, DWRD)
		6255
		6256	CreateByteField (BUFR, 7, BYT2)
		6257	Store (0x11, BYT2)
		6258
		6259	CreateWordField (BUFR, 8, WRD2)
		6260	Store (0x2233, WRD2)
		6261
		6262	Return (0)
		6263
		6264	} // End Method TEST
		6265	} // Device DWDF
		6266
		6267	//
		6268	// test DivAddx.asl
		6269	//
		6270	Name (B1LO, 0xAA)
		6271	Name (B1HI, 0xBB)
		6272
		6273	Method (MKW_, 2)
		6274	{ // This control method will take two bytes and make them into a WORD
		6275
		6276	Multiply (B1HI, 256, Local0) // Make high byte.....high
		6277	Or (Local0, B1LO, Local0) // OR in the low byte
		6278	Return (Local0) // Return the WORD
		6279
		6280	} // MKW_
		6281
		6282	Device (DVAX)
		6283	{
		6284	Method (TEST)
		6285	{
		6286
		6287	Store ("++++++++ DivAddx Test", Debug)
		6288
		6289	Store (25, B1LO)
		6290	Store (0, B1HI)
		6291
		6292	// We'll multiply 25 * 3 to get 75, add 99 to it then divide
		6293	// by 100. We expect to get 74 for the remainder and 1 for
		6294	// the quotient.
		6295	Divide(
		6296	Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63),
		6297	// Dividend,
		6298	100, // Divisor
		6299	Local4, // Remainder
		6300	Local2) // Quotient
		6301
		6302	If (LAnd (LEqual (74, Local4), LEqual (1, Local2)))
		6303	{ // Indicate Pass
		6304	Store (0x00, Local0)
		6305	}
		6306
		6307	Else
		6308	{ // Indicate Fail
		6309	Store (0x01, Local0)
		6310	}
		6311
		6312	Return (Local0)
		6313	} // End Method TEST
		6314	} // Device DVAX
		6315
		6316	//
		6317	// test IndexFld.asl (IndexOp6.asl)
		6318	//
		6319	// IndexFld test
		6320	// This is just a subset of the many RegionOp/Index Field test cases.
		6321	// Tests index field element AccessAs macro.
		6322	// Also tests name resolution of index field elements with same names
		6323	// but different namespace scopes.
		6324	//
		6325	Device (IDX6)
		6326	{ // Test device name
		6327
		6328	OperationRegion (SIO, SystemIO, 0x100, 2)
		6329	Field (SIO, ByteAcc, NoLock, Preserve)
		6330	{
		6331	INDX, 8,
		6332	DATA, 8
		6333	}
		6334	IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
		6335	{
		6336	AccessAs (ByteAcc, 0),
		6337	IFE0, 8,
		6338	IFE1, 8,
		6339	IFE2, 8,
		6340	IFE3, 8,
		6341	IFE4, 8,
		6342	IFE5, 8,
		6343	IFE6, 8,
		6344	IFE7, 8,
		6345	IFE8, 8,
		6346	IFE9, 8,
		6347	}
		6348
		6349	Device (TST_)
		6350	{ // TST_: provides a different namespace scope for IFE0 and IFE1
		6351	OperationRegion (SIO2, SystemIO, 0x100, 2)
		6352	Field (SIO2, ByteAcc, NoLock, Preserve)
		6353	{
		6354	IND2, 8,
		6355	DAT2, 8
		6356	}
		6357	IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
		6358	{
		6359	IFE0, 8, // duplicate IndexField name with different scope
		6360	IFE1, 8
		6361	}
		6362	} // TST_: provides a different namespace scope for IFE0 and IFE1
		6363
		6364	Method (TEST)
		6365	{
		6366	Store ("++++++++ IndexOp6 Test", Debug)
		6367
		6368	Store (IFE0, Local0)
		6369	Store (IFE1, Local1)
		6370	Store (IFE2, Local2)
		6371
		6372	// validate name resolution of IndexFields with different scopes
		6373	Store (\IDX6.IFE0, Local3)
		6374	Store (\IDX6.IFE1, Local4)
		6375	// verioading of namespace can resolve following names
		6376	Store (\IDX6.TST_.IFE0, Local5)
		6377	Store (\IDX6.TST_.IFE1, Local6)
		6378
		6379	Return (0)
		6380	} // TEST
		6381	} // IDX6
		6382
		6383	//
		6384	// test IndexOp5.asl
		6385	//
		6386	// IndexOp5 test
		6387	// This is just a subset of the many RegionOp/Index Field test cases.
		6388	// Tests copying string into buffer then performing IndexOp on result.
		6389	//
		6390	Device (IDX5)
		6391	{ // Test device name
		6392
		6393	Name (OSFL, 0) // 0 == Windows 98, 1 == Windows NT
		6394
		6395	// MCTH is a control method to compare two strings. It returns
		6396	// zero if the strings mismatch, or 1 if the strings match.
		6397	// This exercises the test case of copying a string into a buffer
		6398	// and performing an IndexOp on the resulting buffer.
		6399	Method (MCTH, 2) // Control Method to compare two strings
		6400	{ // MCTH: Control Method to compare two strings
		6401	// Arg0: first string to compare
		6402	// Arg1: second string to compare
		6403	// Return: zero if strings mismatch, 1 if strings match
		6404
		6405	// check if first string's length is less than second string's length
		6406	If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
		6407	{ Return (0) }
		6408
		6409	// increment length to include NULL termination character
		6410	Add (SizeOf (Arg0), 1, Local0) // Local0 = strlen(Arg0) + 1
		6411
		6412	// create two buffers of size Local0 [strlen(Arg0)+1]
		6413	Name (BUF0, Buffer (Local0) {})
		6414	Name (BUF1, Buffer (Local0) {})
		6415
		6416	// copy strings into buffers
		6417	Store (Arg0, BUF0)
		6418	Store (Arg1, BUF1)
		6419
		6420	// validate BUF0 and BUF1 are still buffers
		6421	Store (ObjectType (BUF0), Local1)
		6422	If (LNotEqual (Local1, 3)) // Buffer is type 3
		6423	{ Return (20) }
		6424	Store (ObjectType (BUF1), Local1)
		6425	If (LNotEqual (Local1, 3)) // Buffer is type 3
		6426	{ Return (21) }
		6427
		6428	// Decrement because the Index base below is zero based
		6429	// while Local0 length is one based.
		6430	Decrement (Local0)
		6431
		6432	While (Local0)
		6433	{ // loop through all BUF0 buffer elements
		6434	Decrement (Local0)
		6435
		6436	// check if BUF0[n] == BUF1[n]
		6437	If (LEqual (DerefOf (Index (BUF0, Local0, )),
		6438	DerefOf (Index (BUF1, Local0, ))))
		6439	{ } // this is how the code was really implemented
		6440	Else
		6441	{ Return (Zero) }
		6442	} // loop through all BUF0 buffer elements
		6443
		6444	Return (One) // strings / buffers match
		6445	} // MCTH: Control Method to compare two strings
		6446
		6447
		6448	Method (TEST)
		6449	{
		6450	Store ("++++++++ IndexOp5 Test", Debug)
		6451
		6452	If (MCTH (\_OS, "Microsoft Windows NT"))
		6453	{ Store (1, OSFL) }
		6454
		6455	If (LNotEqual (OSFL, 1))
		6456	{ Return (11) }
		6457
		6458	Return (0)
		6459	} // TEST
		6460	} // IDX5
		6461
		6462	//
		6463	// test IndexOp.asl
		6464	//
		6465	Scope (\_SB) // System Bus
		6466	{ // _SB system bus
		6467
		6468	Method (C097)
		6469	{ Return (1) }
		6470
		6471	Device (PCI2)
		6472	{ // Root PCI Bus
		6473	Name (_HID, EISAID("PNP0A03"))
		6474	Name (_ADR, 0x00000000)
		6475	Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
		6476	Method (_STA) {Return (0x0F)}
		6477
		6478	Device (ISA)
		6479	{ // ISA bridge
		6480	Name (_ADR, 0x00030000) // ISA bus ID
		6481
		6482	Device (EC0)
		6483	{ // Embedded Controller
		6484	Name (_GPE, 0) // EC use GPE0
		6485	Name (_ADR, 0x0030000) // PCI address
		6486
		6487	Method (_STA,0) // EC Status
		6488	{ Return(0xF) } // EC is functioning
		6489
		6490	Name (_CRS, ResourceTemplate()
		6491	{
		6492	IO (Decode16, 0x62, 0x62, 1, 1)
		6493	IO (Decode16, 0x66, 0x66, 1, 1)
		6494	}
		6495	)
		6496
		6497	// create EC's region and field
		6498	OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
		6499	Field (RAM, AnyAcc, NoLock, Preserve)
		6500	{
		6501	// AC information
		6502	ADP, 1, // AC Adapter 1:On-line, 0:Off-line
		6503	AFLT, 1, // AC Adapter Fault 1:Fault 0:Normal
		6504	BAT0, 1, // BAT0 1:present, 0:not present
		6505	, 1, // reserved
		6506	, 28, // filler to force DWORD alignment
		6507
		6508	// CMBatt information
		6509	BPU0, 32, // Power Unit
		6510	BDC0, 32, // Designed Capacity
		6511	BFC0, 32, // Last Full Charge Capacity
		6512	BTC0, 32, // Battery Technology
		6513	BDV0, 32, // Design Voltage
		6514	BST0, 32, // Battery State
		6515	BPR0, 32, // Battery Present Rate
		6516	// (Designed Capacity)x(%)/{(h)x100}
		6517	BRC0, 32, // Battery Remaining Capacity
		6518	// (Designed Capacity)(%)^100
		6519	BPV0, 32, // Battery Present Voltage
		6520	BTP0, 32, // Trip Point
		6521	BCW0, 32, // Design capacity of Warning
		6522	BCL0, 32, // Design capacity of Low
		6523	BCG0, 32, // capacity granularity 1
		6524	BG20, 32, // capacity granularity 2
		6525	BMO0, 32, // Battery model number field
		6526	BIF0, 32, // OEM Information(00h)
		6527	BSN0, 32, // Battery Serial Number
		6528	BTY0, 32, // Battery Type (e.g., "Li-Ion")
		6529	BTY1, 32 // Battery Type (e.g., "Li-Ion")
		6530	} // Field
		6531	} // EC0: Embedded Controller
		6532	} // ISA bridge
		6533	} // PCI2 Root PCI Bus
		6534
		6535	Device (IDX0)
		6536	{ // Test device name
		6537	Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID
		6538	Name (_PCL, Package() {\_SB})
		6539	Method (_STA)
		6540	{
		6541	// _STA bits 0-3 indicate existence of battery slot
		6542	// _STA bit 4 indicates battery (not) present
		6543	If (\_SB.PCI2.ISA.EC0.BAT0)
		6544	{ Return (0x1F) } // Battery present
		6545	else
		6546	{ Return (0x0F) } // Battery not present
		6547	} // _STA
		6548
		6549	Method (_BIF)
		6550	{
		6551	Name (BUFR, Package(13) {})
		6552	Store (\_SB.PCI2.ISA.EC0.BPU0, Index (BUFR,0)) // Power Unit
		6553	Store (\_SB.PCI2.ISA.EC0.BDC0, Index (BUFR,1)) // Designed Capacity
		6554	Store (\_SB.PCI2.ISA.EC0.BFC0, Index (BUFR,2)) // Last Full Charge Capa.
		6555	Store (\_SB.PCI2.ISA.EC0.BTC0, Index (BUFR,3)) // Battery Technology
		6556	Store (\_SB.PCI2.ISA.EC0.BDV0, Index (BUFR,4)) // Designed Voltage
		6557	Store (\_SB.PCI2.ISA.EC0.BCW0, Index (BUFR,5)) // Designed warning level
		6558	Store (\_SB.PCI2.ISA.EC0.BCL0, Index (BUFR,6)) // Designed Low level
		6559	Store (\_SB.PCI2.ISA.EC0.BCG0, Index (BUFR,7)) // Capacity granularity 1
		6560	Store (\_SB.PCI2.ISA.EC0.BG20, Index (BUFR,8)) // Capacity granularity 2
		6561
		6562	Store ("", Index (BUFR,9)) // Model Number
		6563
		6564	Store ("", Index (BUFR,10)) // Serial Number
		6565
		6566	Store ("LiOn", Index (BUFR,11)) // Battery Type
		6567
		6568	Store ("Chicony", Index (BUFR,12)) // OEM Information
		6569
		6570	Return (BUFR)
		6571	} // _BIF
		6572
		6573	Method (_BST)
		6574	{
		6575	Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180})
		6576	Return (BUFR)
		6577	} // _BST
		6578
		6579	Method (_BTP,1)
		6580	{
		6581	Store (arg0, \_SB.PCI2.ISA.EC0.BTP0) // Set Battery Trip point
		6582	}
		6583
		6584	Method (TEST)
		6585	{
		6586
		6587	Store ("++++++++ IndexOp Test", Debug)
		6588
		6589	// test storing into uninitialized package elements
		6590	Name (PBUF, Package(4) {}) // leave unitialized
		6591	Store (0x01234567, Index (PBUF,0))
		6592	Store (0x89ABCDEF, Index (PBUF,1))
		6593	Store (0xFEDCBA98, Index (PBUF,2))
		6594	Store (0x76543210, Index (PBUF,3))
		6595
		6596	// verify values stored into uninitialized package elements
		6597	If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567))
		6598	{ Return (0x10) }
		6599
		6600	If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF))
		6601	{ Return (0x11) }
		6602
		6603	If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98))
		6604	{ Return (0x12) }
		6605
		6606	If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210))
		6607	{ Return (0x13) }
		6608
		6609
		6610	// store _BIF package return value into Local0
		6611	Store (_BIF, Local0)
		6612
		6613	// save Local0 object type value into Local1
		6614	Store (ObjectType (Local0), Local1)
		6615
		6616	// validate Local0 is a Package
		6617	If (LNotEqual (Local1, 4)) // Package type is 4
		6618	{ Return (0x21) } // failure
		6619
		6620
		6621	// test storing into buffer field elements
		6622	Name (BUFR, Buffer(16)
		6623	{ // initial values
		6624	00, 00, 00, 00, 00, 00, 00, 00,
		6625	00, 00, 00, 00, 00, 00, 00, 00,
		6626	}
		6627	) // BUFR
		6628	// test storing into buffer field elements
		6629	Store (0x01234567, Index (BUFR,0)) // should only store 0x67
		6630	Store (0x89ABCDEF, Index (BUFR,4)) // should only store 0xEF
		6631	Store (0xFEDCBA98, Index (BUFR,8)) // should only store 0x98
		6632	Store (0x76543210, Index (BUFR,12)) // should only store 0x10
		6633
		6634	// verify storing into buffer field elements
		6635	If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67))
		6636	{ Return (0x30) }
		6637
		6638	If (LNotEqual (DerefOf (Index (BUFR,1)), 0))
		6639	{ Return (0x31) }
		6640
		6641	If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF))
		6642	{ Return (0x34) }
		6643
		6644	If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98))
		6645	{ Return (0x38) }
		6646
		6647	If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10))
		6648	{ Return (0x3C) }
		6649
		6650
		6651	Return (0) // pass
		6652	} // TEST
		6653	} // IDX0
		6654	} // _SB system bus
		6655
		6656	//
		6657	// test BitIndex.asl
		6658	//
		6659	// BitIndex test
		6660	// This is a test case for accessing fields defined as single bits in
		6661	// memory. This is done by creating two index fields that overlay the
		6662	// same DWORD in memory. One field accesses the DWORD as a DWORD, the
		6663	// other accesses individual bits of the same DWORD field in memory.
		6664	//
		6665	Scope (\_SB) // System Bus
		6666	{ // _SB system bus
		6667	OperationRegion (RAM, SystemMemory, 0x800000, 0x100)
		6668	Field (RAM, AnyAcc, NoLock, Preserve)
		6669	{ // Any access
		6670	TREE, 3,
		6671	WRD0, 16,
		6672	WRD1, 16,
		6673	WRD2, 16,
		6674	WRD3, 16,
		6675	WRD4, 16,
		6676	DWRD, 32, // DWORD field
		6677	}
		6678	Field (RAM, AnyAcc, NoLock, Preserve)
		6679	{ // Any access
		6680	THRE, 3,
		6681	WD00, 16,
		6682	WD01, 16,
		6683	WD02, 16,
		6684	WD03, 16,
		6685	WD04, 16,
		6686	BYT0, 8, // Start off with a BYTE
		6687	BIT0, 1, // single-bit field
		6688	BIT1, 1, // single-bit field
		6689	BIT2, 1, // single-bit field
		6690	BIT3, 1, // single-bit field
		6691	BIT4, 1, // single-bit field
		6692	BIT5, 1, // single-bit field
		6693	BIT6, 1, // single-bit field
		6694	BIT7, 1, // single-bit field
		6695	BIT8, 1, // single-bit field
		6696	BIT9, 1, // single-bit field
		6697	BITA, 1, // single-bit field
		6698	BITB, 1, // single-bit field
		6699	BITC, 1, // single-bit field
		6700	BITD, 1, // single-bit field
		6701	BITE, 1, // single-bit field
		6702	BITF, 1, // single-bit field
		6703	BYTZ, 8, // End with a BYTE for a total of 32 bits
		6704	}
		6705
		6706	Device (BITI)
		6707	{ // Test device name
		6708
		6709	Method (MBIT) // Test single bit memory accesses
		6710	{
		6711
		6712	If (LNotEqual (DWRD, 0x00))
		6713	{
		6714	Store (0xFF00, Local0)
		6715	}
		6716	Else
		6717	{
		6718	// Prime Local0 with 0...assume passing condition
		6719	Store (0, Local0)
		6720
		6721	// set memory contents to known values using DWORD field
		6722	Store (0x5A5A5A5A, DWRD)
		6723
		6724	// Given the value programmed into DWRD, only the odd bits
		6725	// of the lower nibble should be set. BIT1, BIT3 should be set.
		6726	// BIT0 and BIT2 should be clear
		6727
		6728	If (BIT0)
		6729	{
		6730	Or (Local0, 0x01, Local0)
		6731	}
		6732
		6733	If (LNot (BIT1))
		6734	{
		6735	Or (Local0, 0x02, Local0)
		6736	}
		6737
		6738	If (BIT2)
		6739	{
		6740	Or (Local0, 0x04, Local0)
		6741	}
		6742
		6743	If (LNot (BIT3))
		6744	{
		6745	Or (Local0, 0x08, Local0)
		6746	}
		6747
		6748	// Now check the upper nibble. Only the "even" bits should
		6749	// be set. BIT4, BIT6. BIT5 and BIT7 should be clear.
		6750	If (LNot (BIT4))
		6751	{
		6752	Or (Local0, 0x10, Local0)
		6753	}
		6754
		6755	If (BIT5)
		6756	{
		6757	Or (Local0, 0x20, Local0)
		6758	}
		6759
		6760	If (LNot (BIT6))
		6761	{
		6762	Or (Local0, 0x40, Local0)
		6763	}
		6764
		6765	If (BIT7)
		6766	{
		6767	Or (Local0, 0x80, Local0)
		6768	}
		6769	} // End Else DWRD zeroed out
		6770
		6771	Return (Local0)
		6772	} // MBIT: Test single bit memory accesses
		6773
		6774	Method (TEST)
		6775	{
		6776
		6777	Store ("++++++++ BitIndex Test", Debug)
		6778
		6779	// Zero out DWRD
		6780	Store (0x00000000, DWRD)
		6781
		6782	// MBIT returns zero if successful
		6783	// This may be causing problems -- Return (MBIT)
		6784	Store (MBIT, Local0)
		6785
		6786	Return (Local0)
		6787	} // TEST
		6788	} // BITI
		6789	} // _SB system bus
		6790
		6791	//
		6792	// test IndexOp3.asl
		6793	//
		6794	// Additional IndexOp test cases to support ACPICMB (control method battery
		6795	// test) on Compaq laptops. Test cases include storing a package into
		6796	// an IndexOp target and validating that changing source and destination
		6797	// package contents are independent of each other.
		6798	//
		6799	Scope (\_SB) // System Bus
		6800	{ // _SB system bus
		6801
		6802	Name (C174, 13)
		6803	Name (C175, 8)
		6804
		6805	Device (C158)
		6806	{ // C158: AC Adapter device
		6807	Name (_HID, "ACPI0003") // AC Adapter device
		6808	Name (_PCL, Package (1) {\_SB})
		6809
		6810	Method (_PSR)
		6811	{
		6812	Acquire (\_GL, 0xFFFF)
		6813	Release (\_GL)
		6814	And (Local0, 1, Local0) // Local0 &= 1
		6815	Return (Local0)
		6816	} // _PSR
		6817	} // C158: AC Adapter device
		6818
		6819	Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"})
		6820
		6821	Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F})
		6822
		6823	Name (C178, Package (4)
		6824	{
		6825	Package (4) {0, 0, 0x966B, 0x4190},
		6826	Package (4) {0, 0, 0x966B, 0x4190},
		6827	Package (4) {0, 0, 0x966B, 0x4190},
		6828	Package (4) {0, 0, 0x966B, 0x4190}
		6829	}) // C178
		6830
		6831	Name (C179, Package (4) {0, 0, 0x966B, 0x4190})
		6832
		6833	Name (C17A, Package (4)
		6834	{
		6835	Package (3) {0, 0, 0},
		6836	Package (3) {0, 0, 0},
		6837	Package (3) {0, 0, 0},
		6838	Package (3) {0, 0, 0}
		6839	}) // C17A
		6840
		6841	Method (C17B, 1)
		6842	{ // C17B: _BIF implementation
		6843	Name (C17C, Package (13)
		6844	{ // C17C: _BIF control method return package
		6845	0, // Power Unit (0 ==> mWh and mW)
		6846	0x99F5, // Design Capacity
		6847	0x99F5, // Last Full Charge Capacity
		6848	1, // Battery Technology (1 ==> rechargeable)
		6849	0x3840, // Design Voltage
		6850	0x1280, // Design Capacity of Warning
		6851	0x0AC7, // Design Capacity of Low
		6852	1, // Battery Capacity Granularity 1 (Low -- Warning)
		6853	1, // Battery Capacity Granularity 2 (Warning -- Full)
		6854	"2891", // Model Number (ASCIIZ)
		6855	"(-Unknown-)", // Serial Number (ASCIIZ)
		6856	"LIon", // Battery Type (ASCIIZ)
		6857
		6858	}) // C17C: _BIF control method return package
		6859
		6860	And (Arg0, 7, Local0) // Local0 = Arg0 & 7
		6861
		6862	ShiftRight (Local0, 1, Local4) // Local4 = Local0 >> 1
		6863
		6864	Store (C179, Index (C178, Local4, )) // C178->Local4 = C179
		6865
		6866	// verify source and destination packages can be altered independent
		6867	// of each other (i.e., changing one's contents does NOT change other's
		6868	// contents)
		6869	Store (0x1234, Index (C179, 2, )) // C179[2] = 0x1234
		6870	Store (DerefOf (Index (C179, 2, )), Local2) // Local2 = C179[2]
		6871	if (LNotEqual (Local2, 0x1234))
		6872	{ Return (0x1234) }
		6873	// Local2 = C178[0,2]
		6874	Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2)
		6875	if (LNotEqual (Local2, 0x966B))
		6876	{ Return (0x1234) }
		6877
		6878	// Restore data to allow iterative execution
		6879	Store (0x966B, Index (C179, 2, )) // C179[2] = 0x966B
		6880
		6881	// C178[0,3] = 0x5678
		6882	Store (0x5678, Index (DerefOf (Index (C178, 0, )), 3, ))
		6883	// Local2 = C178[0,3]
		6884	Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 3, )), Local2)
		6885	if (LNotEqual (Local2, 0x5678))
		6886	{ Return (0x5678) }
		6887
		6888	Store (DerefOf (Index (C179, 3, )), Local2) // Local2 = C179[3]
		6889	if (LNotEqual (Local2, 0x4190))
		6890	{ Return (0x5678) }
		6891
		6892	// Restore data to allow iterative execution
		6893	Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, )) // C179[2] = 0x4190
		6894
		6895	Return (C17C)
		6896	} // C17B: _BIF implementation
		6897
		6898	Device (C154)
		6899	{ // C154: Battery 0
		6900	Name (_HID, "*PNP0C0A") // Control Method Battey ID
		6901	Name (_UID, 0) // first instance
		6902
		6903	Method (_BIF)
		6904	{ // _BIF
		6905	Return (C17B (48))
		6906	} // _BIF
		6907	} // C154: Battery 0
		6908
		6909	Device (IDX3)
		6910	{
		6911	Method (LCLB)
		6912	{ // LCLB control method: test Index(Local#) where Local# is buffer
		6913	// Local0 is index counter
		6914	// Local1 is buffer
		6915	// Local2 receives BUFR[Local0] via Deref(Index(Local1...))
		6916	// Local3 is Local1 or Local2 object type
		6917	// Local4 is return error code
		6918
		6919	Name (BUFR, Buffer () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
		6920
		6921	// save PKG into Local1
		6922	Store (BUFR, Local1)
		6923
		6924	// save Local2 object type value into Local3
		6925	Store (ObjectType (Local1), Local3)
		6926
		6927	// validate Local1 is a Buffer
		6928	If (LNotEqual (Local3, 3)) // Buffer type is 3
		6929	{ Return (0x9F) }
		6930
		6931
		6932	Store (0, Local0)
		6933	While (LLess (Local0, 5))
		6934	{ // While (Local0 < 5)
		6935	// Local2 = Local1[Local0]
		6936	Store (DerefOf (Index (Local1, Local0, )), Local2)
		6937
		6938	// save Local2 object type value into Local3
		6939	Store (ObjectType (Local2), Local3)
		6940
		6941	// validate Local2 is a Number
		6942	If (LNotEqual (Local3, 1)) // Number type is 1
		6943	{ Return (0x9E) }
		6944
		6945	// validate Local1[Local0] value == Local0
		6946	If (LNotEqual (Local0, Local2))
		6947	{ // Local0 != Local2 == PKG[Local0]
		6948	// Local4 = 0x90 + loop index (Local0)
		6949	Add (0x90, Local0, Local4)
		6950
		6951	// return 0x90 + loop index
		6952	Return (Local4)
		6953	}
		6954
		6955	Increment (Local0)
		6956	} // While (Local0 < 5)
		6957
		6958	Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug)
		6959
		6960	Return (0) // Pass
		6961	} // LCLB control method: test Index(Local#) where Local# is buffer
		6962
		6963	Method (LCLP)
		6964	{ // LCLP control method: test Index(Local#) where Local# is package
		6965	// Local0 is index counter
		6966	// Local1 is package
		6967	// Local2 receives PKG[Local0] via Deref(Index(Local1...))
		6968	// Local3 is Local1 or Local2 object type
		6969	// Local4 is return error code
		6970
		6971	Name (PKG, Package () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
		6972
		6973	// save PKG into Local1
		6974	Store (PKG, Local1)
		6975
		6976	// save Local2 object type value into Local3
		6977	Store (ObjectType (Local1), Local3)
		6978
		6979	// validate Local1 is a Package
		6980	If (LNotEqual (Local3, 4)) // Package type is 4
		6981	{ Return (0x8F) }
		6982
		6983
		6984	Store (0, Local0)
		6985	While (LLess (Local0, 5))
		6986	{ // While (Local0 < 5)
		6987	// Local2 = Local1[Local0]
		6988	Store (DerefOf (Index (Local1, Local0, )), Local2)
		6989
		6990	// save Local2 object type value into Local3
		6991	Store (ObjectType (Local2), Local3)
		6992
		6993	// validate Local2 is a Number
		6994	If (LNotEqual (Local3, 1)) // Number type is 1
		6995	{ Return (0x8E) }
		6996
		6997	// validate Local1[Local0] value == Local0
		6998	If (LNotEqual (Local0, Local2))
		6999	{ // Local0 != Local2 == PKG[Local0]
		7000	// Local4 = 0x80 + loop index (Local0)
		7001	Add (0x80, Local0, Local4)
		7002
		7003	// return 0x80 + loop index
		7004	Return (Local4)
		7005	}
		7006
		7007	Increment (Local0)
		7008	} // While (Local0 < 5)
		7009
		7010	Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug)
		7011
		7012	Return (0) // Pass
		7013	} // LCLP control method: test Index(Local#) where Local# is package
		7014
		7015	Method (TEST)
		7016	{
		7017
		7018	Store ("++++++++ IndexOp3 Test", Debug)
		7019
		7020	// store _BIF package return value into Local0
		7021	Store (\_SB.C154._BIF, Local0)
		7022
		7023	// save Local0 object type value into Local1
		7024	Store (ObjectType (Local0), Local1)
		7025
		7026	// validate Local0 is a Package
		7027	If (LNotEqual (Local1, 4)) // Package type is 4
		7028	{ // failure: did not return a Package (type 4)
		7029	// if Local0 is a Number, it contains an error code
		7030	If (LEqual (Local1, 1)) // Number type is 1
		7031	{ Return (Local0) } // return Local0 error code
		7032	Else // Local0 is not a Number
		7033	{ Return (1) } // return default error code
		7034	} // failure: did not return a Package (type 4)
		7035
		7036	// save LCLB control method return value into Local2
		7037	Store (LCLB, Local2)
		7038	If (LNotEqual (Local2, 0))
		7039	{ Return (Local2) } // return failure code
		7040
		7041	// save LCLP control method return value into Local2
		7042	Store (LCLP, Local2)
		7043	If (LNotEqual (Local2, 0))
		7044	{ Return (Local2) } // return failure code
		7045
		7046	Return (0) // Pass
		7047	} // TEST
		7048	} // IDX3: Test device name
		7049	} // _SB system bus
		7050
		7051	//
		7052	// MTL developed test to exercise Indexes into buffers
		7053	//
		7054	Device(IDX7)
		7055	{
		7056
		7057	Name (PKG4, Package() {
		7058	0x2,
		7059	"A short string",
		7060	Buffer() {0xA, 0xB, 0xC, 0xD},
		7061	0x1234,
		7062	Package() {IDX7, 0x3}
		7063	})
		7064
		7065	//
		7066	// Generic Test method
		7067	//
		7068	// This test returns 0xE (14) - ObjectType = Buffer Field
		7069	Method(TST1)
		7070	{
		7071	Name (DEST, Buffer () // 62 characters plus NULL
		7072	{"Destination buffer that is longer than the short source buffer"})
		7073
		7074	// verify object type returned by Index(Buffer,Element,)
		7075	Store (Index (DEST, 2, ), Local1)
		7076	Store (ObjectType (Local1), Local2)
		7077	If (LEqual(Local2, 14))
		7078	{
		7079	Return(0)
		7080	}
		7081	Else
		7082	{
		7083	Return(0x1)
		7084	}
		7085
		7086	}
		7087
		7088	Method(TST2)
		7089	{
		7090	Name (BUF0, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
		7091	Store(0x55, Index(BUF0, 2))
		7092	Store(DerefOf(Index(BUF0, 2)), Local0)
		7093	If (LEqual(Local0, 0x55))
		7094	{
		7095	Return(0)
		7096	}
		7097	Else
		7098	{
		7099	Return(0x2)
		7100	}
		7101
		7102
		7103	}
		7104
		7105	Method(TST3)
		7106	{
		7107	Name (BUF1, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
		7108	Store(Index(BUF1, 1), Local0)
		7109	Store(DerefOf(Local0), Local1)
		7110	If (LEqual(Local1, 0x2))
		7111	{
		7112	Return(0)
		7113	}
		7114	Else
		7115	{
		7116	Return(0x3)
		7117	}
		7118
		7119	}
		7120
		7121	Method(TST4)
		7122	{
		7123	// Index (PKG4, 0) is a Number
		7124	Store (Index (PKG4, 0), Local0)
		7125	Store (ObjectType(Local0), Local1)
		7126	If (LEqual(Local1, 0x1))
		7127	{
		7128	Return(0)
		7129	}
		7130	Else
		7131	{
		7132	Return(0x4)
		7133	}
		7134
		7135	}
		7136
		7137	Method(TST5)
		7138	{
		7139	// Index (PKG4, 1) is a String
		7140	Store (Index (PKG4, 1), Local0)
		7141	Store (ObjectType(Local0), Local1)
		7142	If (LEqual(Local1, 0x2))
		7143	{
		7144	Return(0)
		7145	}
		7146	Else
		7147	{
		7148	Return(0x5)
		7149	}
		7150
		7151	}
		7152
		7153	Method(TST6)
		7154	{
		7155	// Index (PKG4, 2) is a Buffer
		7156	Store (Index (PKG4, 2), Local0)
		7157	Store (ObjectType(Local0), Local1)
		7158	If (LEqual(Local1, 0x3))
		7159	{
		7160	Return(0)
		7161	}
		7162	Else
		7163	{
		7164	Return(0x6)
		7165	}
		7166
		7167	}
		7168
		7169	Method(TST7)
		7170	{
		7171	// Index (PKG4, 3) is a Number
		7172	Store (Index (PKG4, 3), Local0)
		7173	Store (ObjectType(Local0), Local1)
		7174	If (LEqual(Local1, 0x1))
		7175	{
		7176	Return(0)
		7177	}
		7178	Else
		7179	{
		7180	Return(0x7)
		7181	}
		7182
		7183	}
		7184
		7185	Method(TST8)
		7186	{
		7187	// Index (PKG4, 4) is a Package
		7188	Store (Index (PKG4, 4), Local0)
		7189	Store (ObjectType(Local0), Local1)
		7190	If (LEqual(Local1, 0x4))
		7191	{
		7192	Return(0)
		7193	}
		7194	Else
		7195	{
		7196	Return(0x8)
		7197	}
		7198
		7199	}
		7200
		7201	Method(TST9)
		7202	{
		7203	// DerefOf (Index (PKG4, 0)) is a Number
		7204	Store (DerefOf (Index (PKG4, 0)), Local0)
		7205	If (LEqual(Local0, 0x2))
		7206	{
		7207	Return(0)
		7208	}
		7209	Else
		7210	{
		7211	Return(0x9)
		7212	}
		7213
		7214	}
		7215
		7216	Method(TSTA)
		7217	{
		7218	// DerefOf (Index (PKG4, 1)) is a String
		7219	Store (DerefOf (Index (PKG4, 1)), Local0)
		7220	Store (SizeOf(Local0), Local1)
		7221	If (LEqual(Local1, 0xE))
		7222	{
		7223	Return(0)
		7224	}
		7225	Else
		7226	{
		7227	Return(0xA)
		7228	}
		7229
		7230	}
		7231
		7232	Method(TSTB)
		7233	{
		7234	// DerefOf (Index (PKG4, 2)) is a Buffer
		7235	Store (DerefOf (Index (PKG4, 2)), Local0)
		7236	Store (SizeOf(Local0), Local1)
		7237	If (LEqual(Local1, 0x4))
		7238	{
		7239	Return(0)
		7240	}
		7241	Else
		7242	{
		7243	Return(0xB)
		7244	}
		7245
		7246	}
		7247
		7248	Method(TSTC)
		7249	{
		7250	// DerefOf (Index (PKG4, 3)) is a Number
		7251	Store (DerefOf (Index (PKG4, 3)), Local0)
		7252	If (LEqual(Local0, 0x1234))
		7253	{
		7254	Return(0)
		7255	}
		7256	Else
		7257	{
		7258	Return(0xC)
		7259	}
		7260
		7261	}
		7262
		7263	Method(TSTD)
		7264	{
		7265	// DerefOf (Index (PKG4, 4)) is a Package
		7266	Store (DerefOf (Index (PKG4, 4)), Local0)
		7267	Store (SizeOf(Local0), Local1)
		7268	If (LEqual(Local1, 0x2))
		7269	{
		7270	Return(0)
		7271	}
		7272	Else
		7273	{
		7274	Return(0xD)
		7275	}
		7276
		7277	}
		7278
		7279	Method(TSTE)
		7280	{
		7281	// DerefOf (Index (PKG4, 2)) is a Buffer
		7282	Store (DerefOf (Index (PKG4, 2)), Local0)
		7283	// DerefOf (Index (Local0, 1)) is a Number
		7284	Store (DerefOf (Index (Local0, 1)), Local1)
		7285	If (LEqual(Local1, 0xB))
		7286	{
		7287	Return(0)
		7288	}
		7289	Else
		7290	{
		7291	Return(0xE)
		7292	}
		7293
		7294	}
		7295
		7296	Method (TSTF)
		7297	{
		7298	Name (SRCB, Buffer (12) {}) // 12 characters
		7299	Store ("Short Buffer", SRCB)
		7300
		7301	Name (DEST, Buffer () // 62 characters plus NULL
		7302	{"Destination buffer that is longer than the short source buffer"})
		7303
		7304	// overwrite DEST contents, starting at buffer position 2
		7305	Store (SRCB, Index (DEST, 2))
		7306
		7307	//
		7308	// The DEST buffer element should be replaced with the last element of
		7309	// the SRCB element (i.e. 's'->'r')
		7310	Store (DerefOf (Index (DEST, 2)), Local0)
		7311
		7312	If (LNotEqual (Local0, 0x72)) // 'r'
		7313	{
		7314	// DEST element does not match the value from SRCB
		7315	Return(Or(Local0, 0x1000))
		7316	}
		7317
		7318	Return(0)
		7319	}
		7320
		7321	Method (TSTG)
		7322	{
		7323
		7324	Name (SRCB, Buffer (12) {}) // 12 characters
		7325	Store ("Short Buffer", SRCB)
		7326
		7327	Name (DEST, Buffer () // 62 characters plus NULL
		7328	{"Destination buffer that is longer than the short source buffer"})
		7329
		7330	// overwrite DEST contents, starting at buffer position 2
		7331	Store (SRCB, Index (DEST, 2))
		7332
		7333	//
		7334	// The next element of DEST should be unchanged
		7335	//
		7336	Store (DerefOf (Index (DEST, 3)), Local0)
		7337
		7338	If (LNotEqual (Local0, 0x74)) // 't'
		7339	{
		7340	// DEST has been changed
		7341	Return(Or(Local0, 0x2000))
		7342	}
		7343
		7344	//
		7345	// The next element of DEST should be unchanged
		7346	//
		7347	Store (DerefOf (Index (DEST, 4)), Local0)
		7348
		7349	If (LNotEqual (Local0, 0x69)) // 'i'
		7350	{
		7351	// DEST has been changed
		7352	Return(Or(Local0, 0x2100))
		7353	}
		7354
		7355	//
		7356	// The next element of DEST should be unchanged
		7357	//
		7358	Store (DerefOf (Index (DEST, 5)), Local0)
		7359
		7360	If (LNotEqual (Local0, 0x6E)) // 'n'
		7361	{
		7362	// DEST has been changed
		7363	Return(Or(Local0, 0x2200))
		7364	}
		7365
		7366	//
		7367	// The next element of DEST should be unchanged
		7368	//
		7369	Store (DerefOf (Index (DEST, 6)), Local0)
		7370
		7371	If (LNotEqual (Local0, 0x61)) // 'a'
		7372	{
		7373	// DEST has been changed
		7374	Return(Or(Local0, 0x2300))
		7375	}
		7376
		7377	//
		7378	// The next element of DEST should be unchanged
		7379	//
		7380	Store (DerefOf (Index (DEST, 7)), Local0)
		7381
		7382	If (LNotEqual (Local0, 0x74)) // 't'
		7383	{
		7384	// DEST has been changed
		7385	Return(Or(Local0, 0x2400))
		7386	}
		7387
		7388	//
		7389	// Verify DEST elements beyond end of SRCB buffer copy
		7390	// have not been changed
		7391	Store (DerefOf (Index (DEST, 14)), Local0)
		7392
		7393	If (LNotEqual (Local0, 0x66)) // 'f'
		7394	{
		7395	// DEST has been changed
		7396	Return(Or(Local0, 0x2400))
		7397	}
		7398
		7399	Return(0)
		7400	}
		7401
		7402	//
		7403	// This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit
		7404	// number into the index'ed buffer
		7405	//
		7406	Method (TSTH)
		7407	{
		7408	// Create a Destination Buffer
		7409	Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
		7410
		7411	// Store a number > UINT8 into an index of the buffer
		7412	Store (0x12345678, Index(DBUF, 2))
		7413
		7414	// Check the results
		7415	Store (DerefOf (Index (DBUF, 2)), Local0)
		7416	If (LNotEqual (Local0, 0x78)) // 0x78
		7417	{
		7418	Return(Or(Local0, 0x3000))
		7419	}
		7420
		7421	Store (DerefOf (Index (DBUF, 3)), Local0)
		7422	If (LNotEqual (Local0, 0x64)) // 'd'
		7423	{
		7424	Return(Or(Local0, 0x3100))
		7425	}
		7426
		7427	Store (DerefOf (Index (DBUF, 4)), Local0)
		7428	If (LNotEqual (Local0, 0x65)) // 'e'
		7429	{
		7430	Return(Or(Local0, 0x3200))
		7431	}
		7432
		7433	Store (DerefOf (Index (DBUF, 5)), Local0)
		7434	If (LNotEqual (Local0, 0x66)) // 'f'
		7435	{
		7436	Return(Or(Local0, 0x3300))
		7437	}
		7438
		7439	Return(0)
		7440	}
		7441
		7442	Method (TSTI)
		7443	{
		7444	// Create a Destination Buffer
		7445	Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
		7446
		7447	// Store a String into an index of the buffer
		7448	Store ("ABCDEFGH", Index(DBUF, 2))
		7449
		7450	// Check the results
		7451	Store (DerefOf (Index (DBUF, 2)), Local0)
		7452	If (LNotEqual (Local0, 0x48)) // 'H'
		7453	{
		7454	Return(Or(Local0, 0x4000))
		7455	}
		7456
		7457	Store (DerefOf (Index (DBUF, 3)), Local0)
		7458	If (LNotEqual (Local0, 0x64)) // 'd'
		7459	{
		7460	Return(Or(Local0, 0x4100))
		7461	}
		7462
		7463	Store (DerefOf (Index (DBUF, 4)), Local0)
		7464	If (LNotEqual (Local0, 0x65)) // 'e'
		7465	{
		7466	Return(Or(Local0, 0x4200))
		7467	}
		7468
		7469	Store (DerefOf (Index (DBUF, 5)), Local0)
		7470	If (LNotEqual (Local0, 0x66)) // 'f'
		7471	{
		7472	Return(Or(Local0, 0x4300))
		7473	}
		7474
		7475	Return(0)
		7476	}
		7477
		7478	Method(TSTJ)
		7479	{
		7480	// Create a Destination Buffer
		7481	Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
		7482
		7483	// Store a number > UINT8 into an index of the buffer
		7484	Store (0x1234, Index(DBUF, 2))
		7485
		7486	// Check the results
		7487	Store (DerefOf (Index (DBUF, 2)), Local0)
		7488	If (LNotEqual (Local0, 0x34)) // 0x34
		7489	{
		7490	Return(Or(Local0, 0x3000))
		7491	}
		7492
		7493	Store (DerefOf (Index (DBUF, 3)), Local0)
		7494	If (LNotEqual (Local0, 0x64)) // 'd'
		7495	{
		7496	Return(Or(Local0, 0x3100))
		7497	}
		7498
		7499	Store (DerefOf (Index (DBUF, 4)), Local0)
		7500	If (LNotEqual (Local0, 0x65)) // 'e'
		7501	{
		7502	Return(Or(Local0, 0x3200))
		7503	}
		7504
		7505	Store (DerefOf (Index (DBUF, 5)), Local0)
		7506	If (LNotEqual (Local0, 0x66)) // 'f'
		7507	{
		7508	Return(Or(Local0, 0x3300))
		7509	}
		7510
		7511	Return(0)
		7512	}
		7513
		7514	Method(TSTK)
		7515	{
		7516	// Create a Destination Buffer
		7517	Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
		7518
		7519	// Store a number > UINT8 into an index of the buffer
		7520	Store (0x123456, Index(DBUF, 2))
		7521
		7522	// Check the results
		7523	Store (DerefOf (Index (DBUF, 2)), Local0)
		7524	If (LNotEqual (Local0, 0x56)) // 0x56
		7525	{
		7526	Return(Or(Local0, 0x3000))
		7527	}
		7528
		7529	Store (DerefOf (Index (DBUF, 3)), Local0)
		7530	If (LNotEqual (Local0, 0x64)) // 'd'
		7531	{
		7532	Return(Or(Local0, 0x3100))
		7533	}
		7534
		7535	Store (DerefOf (Index (DBUF, 4)), Local0)
		7536	If (LNotEqual (Local0, 0x65)) // 'e'
		7537	{
		7538	Return(Or(Local0, 0x3200))
		7539	}
		7540
		7541	Store (DerefOf (Index (DBUF, 5)), Local0)
		7542	If (LNotEqual (Local0, 0x66)) // 'f'
		7543	{
		7544	Return(Or(Local0, 0x3300))
		7545	}
		7546
		7547	Return(0)
		7548	}
		7549
		7550	Method(TSTL)
		7551	{
		7552	// Create a Destination Buffer
		7553	Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
		7554
		7555	// Store a number > UINT8 into an index of the buffer
		7556	Store (0x12, Index(DBUF, 2))
		7557
		7558	// Check the results
		7559	Store (DerefOf (Index (DBUF, 2)), Local0)
		7560	If (LNotEqual (Local0, 0x12)) // 0x12
		7561	{
		7562	Return(Or(Local0, 0x3000))
		7563	}
		7564
		7565	Store (DerefOf (Index (DBUF, 3)), Local0)
		7566	If (LNotEqual (Local0, 0x64)) // 'd'
		7567	{
		7568	Return(Or(Local0, 0x3100))
		7569	}
		7570
		7571	Store (DerefOf (Index (DBUF, 4)), Local0)
		7572	If (LNotEqual (Local0, 0x65)) // 'e'
		7573	{
		7574	Return(Or(Local0, 0x3200))
		7575	}
		7576
		7577	Store (DerefOf (Index (DBUF, 5)), Local0)
		7578	If (LNotEqual (Local0, 0x66)) // 'f'
		7579	{
		7580	Return(Or(Local0, 0x3300))
		7581	}
		7582
		7583	Return(0)
		7584	}
		7585
		7586	Method(TEST)
		7587	{
		7588	Store ("++++++++ IndexOp7 Test", Debug)
		7589
		7590	Store(TST1(), Local0)
		7591	if (LGreater (Local0, 0))
		7592	{
		7593	Return(Local0)
		7594	}
		7595
		7596	Store(TST2(), Local0)
		7597	if (LGreater (Local0, 0))
		7598	{
		7599	Return(Local0)
		7600	}
		7601
		7602	Store(TST3(), Local0)
		7603	if (LGreater (Local0, 0))
		7604	{
		7605	Return(Local0)
		7606	}
		7607
		7608	Store(TST4(), Local0)
		7609	if (LGreater (Local0, 0))
		7610	{
		7611	Return(Local0)
		7612	}
		7613
		7614	Store(TST5(), Local0)
		7615	if (LGreater (Local0, 0))
		7616	{
		7617	Return(Local0)
		7618	}
		7619
		7620	Store(TST6(), Local0)
		7621	if (LGreater (Local0, 0))
		7622	{
		7623	Return(Local0)
		7624	}
		7625
		7626	Store(TST7(), Local0)
		7627	if (LGreater (Local0, 0))
		7628	{
		7629	Return(Local0)
		7630	}
		7631
		7632	Store(TST8(), Local0)
		7633	if (LGreater (Local0, 0))
		7634	{
		7635	Return(Local0)
		7636	}
		7637
		7638	Store(TST9(), Local0)
		7639	if (LGreater (Local0, 0))
		7640	{
		7641	Return(Local0)
		7642	}
		7643
		7644	Store(TSTA(), Local0)
		7645	if (LGreater (Local0, 0))
		7646	{
		7647	Return(Local0)
		7648	}
		7649
		7650	Store(TSTB(), Local0)
		7651	if (LGreater (Local0, 0))
		7652	{
		7653	Return(Local0)
		7654	}
		7655
		7656	Store(TSTC(), Local0)
		7657	if (LGreater (Local0, 0))
		7658	{
		7659	Return(Local0)
		7660	}
		7661
		7662	Store(TSTD(), Local0)
		7663	if (LGreater (Local0, 0))
		7664	{
		7665	Return(Local0)
		7666	}
		7667
		7668	Store(TSTE(), Local0)
		7669	if (LGreater (Local0, 0))
		7670	{
		7671	Return(Local0)
		7672	}
		7673
		7674	/* No longer ACPI compliant */
		7675	/*
		7676	Store(TSTF(), Local0)
		7677	if (LGreater (Local0, 0))
		7678	{
		7679	Return(Local0)
		7680	}
		7681	*/
		7682
		7683	Store(TSTG(), Local0)
		7684	if (LGreater (Local0, 0))
		7685	{
		7686	Return(Local0)
		7687	}
		7688
		7689	Store(TSTH(), Local0)
		7690	if (LGreater (Local0, 0))
		7691	{
		7692	Return(Local0)
		7693	}
		7694
		7695	/* No longer ACPI compliant */
		7696	/*
		7697	Store(TSTI(), Local0)
		7698	if (LGreater (Local0, 0))
		7699	{
		7700	Return(Local0)
		7701	}
		7702	*/
		7703	Store(TSTJ(), Local0)
		7704	if (LGreater (Local0, 0))
		7705	{
		7706	Return(Local0)
		7707	}
		7708
		7709	Store(TSTK(), Local0)
		7710	if (LGreater (Local0, 0))
		7711	{
		7712	Return(Local0)
		7713	}
		7714
		7715	Store(TSTL(), Local0)
		7716	if (LGreater (Local0, 0))
		7717	{
		7718	Return(Local0)
		7719	}
		7720
		7721	Return(Local0)
		7722
		7723	}
		7724
		7725	} // Device(IDX7)
		7726
		7727	//
		7728	// test MatchOp.asl
		7729	//
		7730	// MatchOp test cases that utilize nested DerefOf(Index(...)) to validate
		7731	// MatchOp, DerefOfOp, and IndexOp of nested packages.
		7732	//
		7733	Device (MTCH)
		7734	{
		7735
		7736	Method (TEST)
		7737	{
		7738	Store ("++++++++ MatchOp Test", Debug)
		7739
		7740	Name (TIM0, Package ()
		7741	{
		7742	Package () {0x78, 0xB4, 0xF0, 0x0384},
		7743	Package () {0x23, 0x21, 0x10, 0},
		7744	Package () {0x0B, 9, 4, 0},
		7745	Package () {0x70, 0x49, 0x36, 0x27, 0x19},
		7746	Package () {0, 1, 2, 1, 2},
		7747	Package () {0, 0, 0, 1, 1},
		7748	Package () {4, 3, 2, 0},
		7749	Package () {2, 1, 0, 0}
		7750	}) // TIM0
		7751
		7752	Name (TMD0, Buffer (20) {0xFF, 0xFF, 0xFF, 0xFF })
		7753	CreateDWordField (TMD0, 0, PIO0) // 0xFFFFFFFF
		7754	CreateDWordField (TMD0, 4, DMA0)
		7755	CreateDWordField (TMD0, 8, PIO1)
		7756	CreateDWordField (TMD0, 12, DMA1)
		7757	CreateDWordField (TMD0, 16, CHNF)
		7758
		7759
		7760	// validate PIO0 value
		7761	Store (PIO0, Local3)
		7762
		7763	// save Local3 object type value into Local2
		7764	Store (ObjectType (Local3), Local2)
		7765
		7766	// validate Local3 is a Number
		7767	If (LNotEqual (Local2, 1)) // Number type is 1
		7768	{ Return (2) } // failure
		7769
		7770	// validate Local3 Number value
		7771	If (LNotEqual (Local3, 0xFFFFFFFF)) // Number value 0xFFFFFFFF
		7772	{ Return (3) } // failure
		7773
		7774	Store ("DWordField PASS", Debug)
		7775
		7776
		7777	Store (0, Local5)
		7778	Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6)
		7779
		7780	// save Local6 object type value into Local2
		7781	Store (ObjectType (Local6), Local2)
		7782
		7783	// validate Local6 is a Number
		7784	If (LNotEqual (Local2, 1)) // Number type is 1
		7785	{ Return (4) } // failure
		7786
		7787	Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug)
		7788
		7789
		7790	// validate following produces a nested package to validate
		7791	// that MatchOp did not corrupt SearchPackage (TIM0)
		7792	Store (DerefOf (Index (TIM0, 1, )), Local4)
		7793
		7794	// save Local4 object type value into Local2
		7795	Store (ObjectType (Local4), Local2)
		7796
		7797	// validate Local4 is a Package
		7798	If (LNotEqual (Local2, 4)) // Package type is 4
		7799	{ Return (5) } // failure
		7800
		7801	Store ("DerefOf(Index(TIM0,1)),... PASS", Debug)
		7802
		7803
		7804	And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0)
		7805
		7806	// save Local0 object type value into Local2
		7807	Store (ObjectType (Local0), Local2)
		7808
		7809	// validate Local0 is a Number
		7810	If (LNotEqual (Local2, 1)) // Number type is 1
		7811	{ Return (6) } // failure
		7812
		7813	// validate Local0 Number value
		7814	If (LNotEqual (Local0, 3)) // Number value 3
		7815	{ Return (7) } // failure
		7816
		7817	Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug)
		7818
		7819
		7820	// again, validate following produces a nested package
		7821	Store (DerefOf (Index (TIM0, 1, )), Local4)
		7822
		7823	// save Local4 object type value into Local2
		7824	Store (ObjectType (Local4), Local2)
		7825
		7826	// validate Local4 is a Package
		7827	If (LNotEqual (Local2, 4)) // Package type is 4
		7828	{ Return (8) } // failure
		7829
		7830	Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
		7831
		7832
		7833	// again, validate following produces a nested package
		7834	Store (DerefOf (Index (TIM0, 1, )), Local4)
		7835
		7836	// save Local4 object type value into Local2
		7837	Store (ObjectType (Local4), Local2)
		7838
		7839	// validate Local4 is a Package
		7840	If (LNotEqual (Local2, 4)) // Package type is 4
		7841	{ Return (9) } // failure
		7842
		7843	Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
		7844
		7845
		7846	// test nested DerefOf(Index) operators
		7847	Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
		7848
		7849	// save Local1 object type value into Local2
		7850	Store (ObjectType (Local1), Local2)
		7851
		7852	// validate Local1 is a Number
		7853	If (LNotEqual (Local2, 1)) // Number type is 1
		7854	{ Return (10) } // failure
		7855
		7856	// zero indicates pass, non-zero is an error code
		7857	If (LNotEqual (Local1, 0))
		7858	{ Return (11) } // failure
		7859
		7860	Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug)
		7861
		7862
		7863	// again, validate following produces a nested package
		7864	Store (DerefOf (Index (TIM0, 1, )), Local4)
		7865
		7866	// save Local4 object type value into Local2
		7867	Store (ObjectType (Local4), Local2)
		7868
		7869	// validate Local4 is a Package
		7870	If (LNotEqual (Local2, 4)) // Package type is 4
		7871	{ Return (12) } // failure
		7872
		7873	Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
		7874
		7875
		7876	// retest nested DerefOf(Index) operators
		7877	Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
		7878
		7879	// save Local1 object type value into Local2
		7880	Store (ObjectType (Local1), Local2)
		7881
		7882	// validate Local1 is a Number
		7883	If (LNotEqual (Local2, 1)) // Number type is 1
		7884	{ Return (13) } // failure
		7885
		7886	// zero indicates pass, non-zero is an error code
		7887	If (LNotEqual (Local1, 0))
		7888	{ Return (14) } // failure
		7889
		7890	Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug)
		7891
		7892
		7893	// again, validate following produces a nested package
		7894	Store (DerefOf (Index (TIM0, 1, )), Local4)
		7895
		7896	// save Local4 object type value into Local2
		7897	Store (ObjectType (Local4), Local2)
		7898
		7899	// validate Local4 is a Package
		7900	If (LNotEqual (Local2, 4)) // Package type is 4
		7901	{ Return (15) } // failure
		7902
		7903	Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
		7904
		7905
		7906	Return (0) // pass
		7907	} // TEST
		7908	} // MTCH
		7909
		7910	//
		7911	// test WhileBrk.asl
		7912	//
		7913	// This code tests the Break term and While term
		7914	//
		7915	// Syntax of Break term
		7916	// BreakTerm := Break
		7917	// The break operation causes the current package execution to complete.
		7918	//
		7919	// Syntax of While Term
		7920	// WhileTerm := While(
		7921	// Predicate //TermArg=>Integer
		7922	// ) {TermList}
		7923	// Predicate is evaluated as an integer.
		7924	// If the integer is non-zero, the list of terms in TermList is executed.
		7925	// The operation repeats until the Predicate evaluates to zero.
		7926	//
		7927	// MTL NOTE: This test has been modified to reflect ACPI 2.0 break
		7928	// NOTE: This test, when run under the MS ACPI.SYS grinds the system to
		7929	// a halt.
		7930	//
		7931	Device (WHLB)
		7932	{
		7933	Name (CNT0, 0)
		7934	Name (CNT1, 0)
		7935
		7936	Method (TEST)
		7937	{
		7938	// Check Break statement nested in If nested in While nested in
		7939	// While only exits inner-most While loop
		7940	Store (0, CNT0)
		7941
		7942	While (LLess (CNT0, 4))
		7943	{
		7944	Store (0, CNT1)
		7945	While (LLess (CNT1, 10))
		7946	{
		7947	if (LEqual (CNT1, 1))
		7948	{
		7949	Break // exit encompassing loop
		7950	}
		7951
		7952	Increment (CNT1)
		7953	}
		7954
		7955	If (LNotEqual (CNT1, 1))
		7956	{
		7957	// failure
		7958	Return (7)
		7959	}
		7960
		7961	Increment (CNT0)
		7962	}
		7963
		7964	// Verify Break only exited inner-most While loop
		7965
		7966	If (LNotEqual (CNT0, 4))
		7967	{
		7968	// failure
		7969	Return (8)
		7970	}
		7971
		7972	Store ("While/While/If/Break PASS", Debug)
		7973
		7974	Store ("++++++++ WhileBrk Test", Debug)
		7975
		7976	// Check Break statement nested in While
		7977	Store (0, CNT0)
		7978
		7979	While (LLess (CNT0, 10))
		7980	{
		7981	Break // exit encompassing package
		7982	Increment (CNT0)
		7983	}
		7984
		7985	If (LNotEqual (CNT0, 0)) // instruction after Break executed
		7986	{
		7987	Return (4)
		7988	}
		7989
		7990
		7991	Store (0, CNT0)
		7992
		7993	// Test While Term
		7994	While (LLess (CNT0, 10))
		7995	{
		7996	Increment (CNT0)
		7997	}
		7998
		7999	// Check if the while loop was executed until the condition is satisfied.
		8000	If (LNotEqual (CNT0, 10))
		8001	{
		8002	Return (1)
		8003	}
		8004
		8005
		8006	// While loop in a reverse order
		8007	While (LGreater (CNT0, 0))
		8008	{
		8009	Decrement (CNT0)
		8010	}
		8011
		8012	// Check if the while loop was executed until the condition is satisfied.
		8013	If (LNotEqual (CNT0, 0))
		8014	{
		8015	Return (2)
		8016	}
		8017
		8018
		8019	Store ("While/Break PASS", Debug)
		8020
		8021
		8022	// Check Break statement nested in If nested in While
		8023	Store (0, CNT0)
		8024
		8025	While (LLess (CNT0, 10))
		8026	{
		8027	if (LEqual (CNT0, 5))
		8028	{
		8029	Break // exit encompassing Package (If)
		8030
		8031	// if we execute the next instruction,
		8032	// Break did not exit the loop
		8033	Store (20, CNT0) // exit While loop with value larger
		8034	// than above
		8035	}
		8036
		8037	Increment (CNT0) // check if Break exited both If and While
		8038	} // While
		8039
		8040	If (LGreater (CNT0, 19))
		8041	{ // instruction after Break inside IfOp executed
		8042	Return (5)
		8043	}
		8044
		8045	//
		8046	// Break will exit out of the while loop, therefore
		8047	// the CNT0 counter should still Increment until 5
		8048	//
		8049	If (LNotEqual (CNT0, 5))
		8050	{ // instruction after Break inside WhileOp executed
		8051	Return (6)
		8052	}
		8053	Store ("While/If/Break PASS", Debug)
		8054
		8055
		8056	// All the conditions passed
		8057	Return (0)
		8058	} // TEST
		8059	} // WHLB
		8060
		8061
		8062	//
		8063	// test IndexOp2.asl
		8064	//
		8065	// Additional IndexOp test cases to support ACPICMB (control method battery
		8066	// test) on Toshiba Portege 7020CT. Test cases include appropriate bit
		8067	// shifting of Field elements and reading Field elements greater than 64 bits.
		8068	//
		8069	// MTL NOTE: This test has been modified slightly from the original test
		8070	// to take into account ACPI specification limitations.
		8071	//
		8072	Scope (\_SB) // System Bus
		8073	{ // _SB system bus
		8074
		8075	Device (MEM)
		8076	{ // MEM
		8077	Name (_HID, 0x010CD041)
		8078	Name (_STA, 0x0F)
		8079
		8080	OperationRegion (SMEM, SystemMemory, 0x800000, 0x100)
		8081	Field (SMEM, AnyAcc, NoLock, Preserve)
		8082	{ // Field: SMEM overlay using 32-bit field elements
		8083	SMD0, 32, // 32-bits
		8084	SMD1, 32, // 32-bits
		8085	SMD2, 32, // 32-bits
		8086	SMD3, 32 // 32-bits
		8087	} // Field: SMEM overlay using 32-bit field elements
		8088	Field (SMEM, AnyAcc, NoLock, Preserve)
		8089	{ // Field: SMEM overlay using greater than 32-bit field elements
		8090	SME0, 69, // larger than an integer (32 or 64)
		8091	SME1, 97 // larger than an integer
		8092	} // Field: SMEM overlay using greater than 32-bit field elements
		8093
		8094	OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
		8095	Field (SRAM, AnyAcc, NoLock, Preserve)
		8096	{ // Field: SRAM overlay
		8097	, 0x34000, // skip
		8098	IEAX, 0x20,
		8099	IEBX, 0x20,
		8100	IECX, 0x20,
		8101	IEDX, 0x20,
		8102	IESI, 0x20,
		8103	IEDI, 0x20,
		8104	IEBP, 0x20,
		8105	, 0x20,
		8106	OEAX, 0x20,
		8107	OEBX, 0x20,
		8108	OECX, 0x20,
		8109	OEDX, 0x20,
		8110	OESI, 0x20,
		8111	OEDI, 0x20,
		8112	OEBP, 0x20,
		8113	, 0x618, // skip
		8114	ACST, 1,
		8115	BES1, 1,
		8116	BES2, 1,
		8117	, 5, // skip
		8118	BMN1, 0x68,
		8119	BSN1, 0x58,
		8120	BTP1, 0x48,
		8121	BPU1, 0x20,
		8122	BDC1, 0x20,
		8123	BLF1, 0x20,
		8124	BTC1, 0x20,
		8125	BDV1, 0x20,
		8126	BST1, 0x20,
		8127	BPR1, 0x20,
		8128	BRC1, 0x20,
		8129	BPV1, 0x20,
		8130	, 0x20,
		8131	BCW1, 0x20,
		8132	BCL1, 0x20,
		8133	BG11, 0x20,
		8134	BG21, 0x20,
		8135	BOI1, 0x20,
		8136	, 0x530, // skip
		8137	BMN2, 0x68,
		8138	BSN2, 0x58,
		8139	BTP2, 0x48,
		8140	BPU2, 0x20,
		8141	BDC2, 0x20,
		8142	BLF2, 0x20,
		8143	BTC2, 0x20,
		8144	BDV2, 0x20,
		8145	BST2, 0x20,
		8146	BPR2, 0x20,
		8147	BRC2, 0x20,
		8148	BPV2, 0x20,
		8149	, 0x20,
		8150	BCW2, 0x20,
		8151	BCL2, 0x20,
		8152	BG12, 0x20,
		8153	BG22, 0x20,
		8154	BOI2, 0x20,
		8155	, 0x518, // skip
		8156	AC01, 0x10,
		8157	AC11, 0x10,
		8158	PSV1, 0x10,
		8159	CRT1, 0x10,
		8160	TMP1, 0x10,
		8161	AST1, 0x10,
		8162	AC21, 0x10,
		8163	AC31, 0x10,
		8164	AC02, 0x10,
		8165	AC12, 0x10,
		8166	PSV2, 0x10,
		8167	CRT2, 0x10,
		8168	TMP2, 0x10,
		8169	AST2, 0x10,
		8170	AC22, 0x10,
		8171	AC32, 0x10,
		8172	AC03, 0x10,
		8173	AC13, 0x10,
		8174	PSV3, 0x10,
		8175	CRT3, 0x10,
		8176	TMP3, 0x10,
		8177	AST3, 0x10,
		8178	AC23, 0x10,
		8179	AC33, 0x10,
		8180	, 0x80, // skip
		8181	TMPF, 0x10,
		8182	, 0x570, // skip
		8183	FANH, 1,
		8184	FANL, 7,
		8185	TF11, 1,
		8186	TF21, 1,
		8187	TF31, 1,
		8188	, 1,
		8189	TF10, 1,
		8190	TF20, 1,
		8191	TF30, 1,
		8192	, 1,
		8193	TP11, 1,
		8194	TP21, 1,
		8195	TP31, 1,
		8196	, 0x6D, // 109
		8197	GP50, 1,
		8198	GP51, 1,
		8199	GP52, 1,
		8200	GP53, 1,
		8201	, 4,
		8202	GP60, 1,
		8203	GP61, 1,
		8204	GP62, 1,
		8205	GP63, 1,
		8206	GP64, 1,
		8207	GP65, 1,
		8208	GP66, 1,
		8209	, 1,
		8210	GP70, 1,
		8211	GP71, 1,
		8212	GP72, 1,
		8213	GP73, 1,
		8214	GP74, 1,
		8215	GP75, 1,
		8216	GP76, 1,
		8217	, 1,
		8218	WED0, 1,
		8219	WED1, 1,
		8220	WED2, 1,
		8221	WED3, 1,
		8222	WED4, 1,
		8223	, 3,
		8224	SBL0, 1,
		8225	SBL1, 1,
		8226	SBL2, 1,
		8227	SBL3, 1,
		8228	, 4,
		8229	LIDS, 1,
		8230	VALF, 1,
		8231	, 2,
		8232	DCKI, 1,
		8233	DCKF, 1,
		8234	BT1F, 1,
		8235	BT2F, 1,
		8236	, 0x7D0, // skip
		8237	HKCD, 8,
		8238	, 8,
		8239	DLID, 0x20,
		8240	DSRN, 0x20,
		8241	, 0x20,
		8242	BDID, 0x20,
		8243	DSPW, 1,
		8244	VGAF, 1,
		8245	VWE0, 1,
		8246	VWE1, 1,
		8247	PPSC, 1,
		8248	SPSC, 1,
		8249	EWLD, 1,
		8250	EWPS, 1,
		8251	, 0x1768, // skip
		8252	PRES, 0x8000
		8253	} // Field: SRAM overlay
		8254	} // MEM
		8255
		8256	Device (BAT1)
		8257	{ // BAT1
		8258	Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID
		8259	Name (_UID, 1)
		8260	Name (_PCL, Package (1) {\_SB})
		8261
		8262	Method (_STA)
		8263	{ // _STA
		8264	If (\_SB.MEM.BES1)
		8265	{ Return (0x1F) } // battery present
		8266	Else
		8267	{ Return (0x0F) } // battery not present
		8268	} // _STA
		8269
		8270	Method (_BIF)
		8271	{ // _BIF
		8272	Name (BUFR, Package (13) {})
		8273
		8274	Store (\_SB.MEM.BPU1, Index (BUFR, 0))
		8275	Store (\_SB.MEM.BDC1, Index (BUFR, 1))
		8276	Store (\_SB.MEM.BLF1, Index (BUFR, 2))
		8277	Store (\_SB.MEM.BTC1, Index (BUFR, 3))
		8278	Store (\_SB.MEM.BDV1, Index (BUFR, 4))
		8279	Store (\_SB.MEM.BCW1, Index (BUFR, 5))
		8280	Store (\_SB.MEM.BCL1, Index (BUFR, 6))
		8281	Store (\_SB.MEM.BG11, Index (BUFR, 7))
		8282	Store (\_SB.MEM.BG21, Index (BUFR, 8))
		8283	Store (\_SB.MEM.BMN1, Index (BUFR, 9))
		8284	Store (\_SB.MEM.BSN1, Index (BUFR, 10))
		8285	Store (\_SB.MEM.BTP1, Index (BUFR, 11))
		8286	Store (\_SB.MEM.BOI1, Index (BUFR, 12))
		8287
		8288	Return (BUFR)
		8289	} // _BIF
		8290	} // BAT1
		8291
		8292	Device (IDX2)
		8293	{
		8294	Method (B2IB)
		8295	{ // B2IB: store from Buffer into Index'ed Buffer
		8296
		8297	Name (SRCB, Buffer () {"Short Buffer"}) // 12 characters plus NULL
		8298
		8299	Name (DEST, Buffer () // 62 characters plus NULL
		8300	{"Destination buffer that is longer than the short source buffer"})
		8301
		8302
		8303	// verify object type returned by Index(Buffer,Element,)
		8304
		8305	Store (Index (DEST, 2, ), Local1)
		8306	Store (ObjectType (Local1), Local2)
		8307
		8308	If (LNotEqual (Local2, 14)) // Buffer Field is type 14
		8309	{
		8310	// Local2 indicates Local1 is not a Buffer Field
		8311
		8312	Return (0x61)
		8313	}
		8314
		8315	// verify object type and value returned by DerefOf(Index(Buffer,Element,))
		8316	// should return Number containing element value
		8317
		8318	Store (DerefOf (Local1), Local3)
		8319	Store (ObjectType (Local3), Local4)
		8320
		8321	If (LNotEqual (Local4, 1)) // Number is type 1
		8322	{
		8323	// Local2 indicates Local1 is not a Number
		8324	Return (0x62)
		8325	}
		8326	Else
		8327	{
		8328	If (LNotEqual (Local3, 0x73)) // expect 's' element from DEST
		8329	{
		8330	Return (0x63)
		8331	}
		8332	}
		8333
		8334	Store ("DerefOf(Index(Buffer,,)) PASS", Debug)
		8335
		8336
		8337	//
		8338	// The following sections have been rewritten because storing into
		8339	// an Indexed buffer only changes one byte - the FIRST byte of the
		8340	// buffer is written to the source index. This is the ONLY byte
		8341	// written -- as per ACPI 2.0
		8342	//
		8343	// Overwrite DEST contents, at buffer position 2 [only]
		8344
		8345	Store (SRCB, Index (DEST, 2, ))
		8346
		8347	//
		8348	// Check that the next byte is not changed
		8349	//
		8350	Store (DerefOf (Index (DEST, 3, )), Local0)
		8351	If (LNotEqual (Local0, 0x74)) // 't'
		8352	{
		8353	// DEST element is not matching original value
		8354	If (LEqual (Local0, 0x68))
		8355	{
		8356	// DEST element was altered to 'h'
		8357	Return (0x68)
		8358	}
		8359	Else
		8360	{
		8361	// DEST element is an unknown value
		8362	Return (0x69)
		8363	}
		8364	}
		8365
		8366	//
		8367	// Check that the elements beyond the SRCB buffer copy
		8368	// have not been altered.
		8369	//
		8370	Store (DerefOf (Index (DEST, 14)), Local0)
		8371
		8372	//
		8373	// This should be an 'f'.
		8374	//
		8375	If (LNotEqual (Local0, 0x66))
		8376	{
		8377	// DEST element was zero'd by buffer copy
		8378	If (LEqual (Local0, 0))
		8379	{
		8380	// DEST element is zero
		8381	Return (0x6A)
		8382	}
		8383	Else
		8384	{
		8385	// DEST element is unknown value
		8386	Return (0x6B)
		8387	}
		8388	}
		8389
		8390	Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug)
		8391
		8392	//
		8393	// verify altering SRCB does NOT alter DEST
		8394	//
		8395	Store (0x6A, Index (SRCB, 1)) // SRCB = "Sjort Buffer"
		8396
		8397	Store (DerefOf (Index (SRCB, 1)), Local0)
		8398
		8399	If (LNotEqual (Local0, 0x6A)) // 'j'
		8400	{
		8401	// SRCB element is unaltered
		8402	Return (0x71)
		8403	}
		8404
		8405	Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that...
		8406
		8407	If (LNotEqual (Local0, 0x74)) // 't'
		8408	{
		8409	// DEST element is altered
		8410	If (LEqual (Local0, 0x6A)) // 'j'
		8411	{
		8412	// SRCB change altered DEST element
		8413	Return (0x72)
		8414	}
		8415	Else
		8416	{
		8417	// DEST element is unknown value
		8418	Return (0x73)
		8419	}
		8420	}
		8421
		8422	// verify altering DEST does NOT alter SRCB
		8423
		8424	Store (0x6B, Index (DEST, 4, )) // DEST = "DeSkination buffer..."
		8425
		8426	Store (DerefOf (Index (DEST, 4, )), Local0)
		8427
		8428	If (LNotEqual (Local0, 0x6B)) // 'k'
		8429	{
		8430	// DEST element is unaltered
		8431	Return (0x74)
		8432	}
		8433
		8434	Store (DerefOf (Index (SRCB, 2, )), Local0)
		8435
		8436	If (LNotEqual (Local0, 0x6F)) // 'o'
		8437	{ // SRC element is altered
		8438	If (LEqual (Local0, 0x6B)) // 'k'
		8439	{
		8440	// DEST change altered SRCB element
		8441	Return (0x75)
		8442	}
		8443	Else
		8444	{
		8445	// SRCB element is unknown value
		8446	Return (0x76)
		8447	}
		8448	}
		8449
		8450	Store ("SRCB and DEST independent PASS", Debug)
		8451
		8452
		8453	// verify string can be written to Index target/destination
		8454	// Only FIRST byte is written
		8455
		8456	Store ("New Buff", Index (DEST, 2, )) // DEST = "DeNkination buffer..."
		8457
		8458	Store (DerefOf (Index (DEST, 2, )), Local0)
		8459
		8460	If (LNotEqual (Local0, 0x4E)) // 'N'
		8461	{
		8462	// DEST element is unaltered
		8463	Return (0x81)
		8464	}
		8465
		8466	Store (DerefOf (Index (DEST, 6, )), Local0)
		8467
		8468	If (LNotEqual (Local0, 0x61)) // 'a'
		8469	{
		8470	// DEST element is unaltered
		8471	Return (0x82)
		8472	}
		8473
		8474	Store (DerefOf (Index (DEST, 10, )), Local0)
		8475
		8476	If (LNotEqual (Local0, 0x6E)) // 'n'
		8477	{
		8478	// DEST element is unaltered
		8479	Return (0x83)
		8480	}
		8481
		8482	Store ("Store(String,Index) PASS", Debug)
		8483
		8484
		8485	Return (0) // pass
		8486	} // B2IB: store from Buffer into Index'ed Buffer
		8487
		8488	Method (FB2P)
		8489	{ // FB2P: store from Field Buffer into Index'ed Package
		8490	Name (DEST, Package (2) {})
		8491
		8492	// initialize memory using 32-bit field elements
		8493	Store (0x01234567, \_SB.MEM.SMD0)
		8494	Store (0x89ABCDEF, \_SB.MEM.SMD1)
		8495	Store (0xFEDCBA98, \_SB.MEM.SMD2)
		8496	Store (0x76543210, \_SB.MEM.SMD3)
		8497
		8498	// move greater than 64-bit buffers into DEST package
		8499	Store (\_SB.MEM.SME0, Index (DEST, 0))
		8500	Store (\_SB.MEM.SME1, Index (DEST, 1))
		8501
		8502	// validate DEST contents
		8503	Store (DerefOf (Index (DEST, 0, )), Local0)
		8504	Store (DerefOf (Index (DEST, 1, )), Local1)
		8505
		8506	// verify Local0 and Local1 are Buffers
		8507	Store (ObjectType (Local0), Local2)
		8508	if (LNotEqual (Local2, 3)) // Buffer type is 3
		8509	{
		8510	Return (0x11)
		8511	}
		8512
		8513	Store (ObjectType (Local1), Local3)
		8514	if (LNotEqual (Local3, 3)) // Buffer type is 3
		8515	{
		8516	Return (0x12)
		8517	}
		8518
		8519	// validate DEST buffer contents
		8520	Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4)
		8521	If (LNotEqual (Local4, 0x67))
		8522	{
		8523	Return (0x13)
		8524	}
		8525
		8526	Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4)
		8527	If (LNotEqual (Local4, 0x45))
		8528	{
		8529	Return (0x14)
		8530	}
		8531
		8532	Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4)
		8533	If (LNotEqual (Local4, 0xEF))
		8534	{
		8535	Return (0x15)
		8536	}
		8537
		8538	Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4)
		8539	If (LNotEqual (Local4, 0xCD))
		8540	{
		8541	Return (0x16)
		8542	}
		8543
		8544	Store ("Store(Mem,PkgElement) PASS", Debug)
		8545
		8546
		8547	// validate changing source \_SB.MEM.SMD* does not impact DEST
		8548	Store (0x12345678, \_SB.MEM.SMD0)
		8549
		8550	Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5)
		8551	If (LNotEqual (Local5, 0x67))
		8552	{
		8553	Return (0x21)
		8554	}
		8555
		8556	Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5)
		8557	If (LNotEqual (Local5, 0x45))
		8558	{
		8559	Return (0x22)
		8560	}
		8561
		8562	// validate changing DEST does not impact source \_SB.MEM.SMD*
		8563	Store (0x30, Index (DerefOf (Index (DEST, 0)), 0))
		8564
		8565	Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5)
		8566	If (LNotEqual (Local5, 0x30))
		8567	{
		8568	Return (0x23)
		8569	}
		8570
		8571	//
		8572	// This section was modified from the original iPCO code because
		8573	// it attempted to compare two buffers. This is not allowed until
		8574	// ACPI v2.0, so the test has been modified to just check the
		8575	// changed \_SB.MEM.SMD0
		8576	//
		8577	Store (\_SB.MEM.SMD0, Local5)
		8578
		8579	If(LNotEqual(Local5, 0x12345678))
		8580	{
		8581	Return (0x24)
		8582	}
		8583
		8584	Store ("Mem and Pkg independent PASS", Debug)
		8585
		8586
		8587	Return (0)
		8588	} // FB2P: store from Field Buffer into Index'ed Package
		8589
		8590	Method (TEST)
		8591	{
		8592	Store ("++++++++ IndexOp2 Test", Debug)
		8593
		8594	// store _BIF package return value into Local0
		8595
		8596	Store (\_SB.BAT1._BIF, Local0)
		8597
		8598	// save Local0 object type value into Local1
		8599	Store (ObjectType (Local0), Local1)
		8600
		8601	// validate Local0 is a Package
		8602	If (LNotEqual (Local1, 4)) // Package type is 4
		8603	{
		8604	// failure
		8605	Return (2)
		8606	}
		8607
		8608	// validate source and destination buffers are independent of each
		8609	// of each other (i.e., changing one's contents does not change
		8610	// other's contents) using B2IB (store from Buffer into Index'ed
		8611	// Buffer) and FB2P (store from Field Buffer into Index'ed Package)
		8612
		8613	// call B2IB (store from Buffer into Index'ed Buffer)
		8614	Store (B2IB, Local2) // Local2 is B2IB return value
		8615
		8616	// save Local2 object type value into Local3
		8617	Store (ObjectType (Local2), Local3)
		8618
		8619	// validate Local2 is a Number
		8620	If (LNotEqual (Local3, 1)) // Number type is 1
		8621	{
		8622	// failure
		8623	Return (4)
		8624	}
		8625
		8626	// zero indicates pass, non-zero is an error code
		8627	If (LNotEqual (Local2, 0))
		8628	{
		8629	// return B2IB error code
		8630	Return (Local2)
		8631	}
		8632
		8633	// call FB2P (store from Field Buffer into Index'ed Package)
		8634	Store (FB2P, Local2) // Local2 is FB2P return value
		8635
		8636	// save Local2 object type value into Local3
		8637	Store (ObjectType (Local2), Local3)
		8638
		8639	// validate Local2 is a Number
		8640	If (LNotEqual (Local3, 1)) // Number type is 1
		8641	{
		8642	// failure
		8643	Return (5)
		8644	}
		8645
		8646	// zero indicates pass, non-zero is an error code
		8647	If (LNotEqual (Local2, 0))
		8648	{
		8649	// return FB2P error code
		8650	Return (Local2)
		8651	}
		8652
		8653
		8654	Return (0)
		8655	} // TEST
		8656	} // IDX2: Test device name
		8657	} // _SB system bus
		8658
		8659	//
		8660	// test SizeOf.asl
		8661	//
		8662	// Test for SizeOf
		8663	// test cases include following SizeOf arguments:
		8664	// buffer, buffer field;
		8665	// control method argument, control method local variable;
		8666	// control method return values;
		8667	// direct string, string;
		8668	// package;
		8669	// buffer, package, and string package elements
		8670	//
		8671	// MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,...
		8672	// calls because it is not legal to perform a SizeOf operation on a Buffer Field.
		8673	// This test has also been extended to test additional Package element sizes.
		8674	//
		8675	Device (SIZO)
		8676	{
		8677	// SAR0 control method validates SizeOf(Arg)
		8678	// SAR0 should only be called by SARG
		8679	Method (SAR0, 2)
		8680	// Arg0 object to determine size of
		8681	// Arg1 expected Arg length
		8682	{ // SAR0: SizeOf(Arg) test control method
		8683	// Local0 Arg0 length
		8684	// Local1 Local0 object type
		8685
		8686	// Store first string size (Arg0) into Local7
		8687	Store (SizeOf (Arg0), Local0)
		8688
		8689	// save Local0 object type value into Local1
		8690	Store (ObjectType (Local0), Local1)
		8691
		8692	// validate Local0 is a Number
		8693	If (LNotEqual (Local1, 1)) // Number type is 1
		8694	{ Return (0x21) }
		8695
		8696	// If strings are not of equal size, return error code
		8697	If (LNotEqual (Local0, Arg1))
		8698	{ Return (0x22) }
		8699
		8700	Return (0)
		8701	} // SAR0: SizeOf(Arg) test control method
		8702
		8703	Method (SARG)
		8704	{ // SARG: SizeOf(Arg) test control method
		8705	Name (BUFR, Buffer (12) {}) // uninitialized Buffer
		8706	Name (BUF1, Buffer() {0x01, 0x02, 0x03, 0x04, 0x05})
		8707	Name (PKG0, Package (4) {}) // uninitialized Package
		8708	Name (STR0, "String")
		8709	Name (PKG1, Package (4)
		8710	{
		8711	BUFR,
		8712	"String2",
		8713	STR0,
		8714	PKG0
		8715	}) // PKG1
		8716
		8717	Name (PKG2, Package (4)
		8718	{
		8719	Buffer (15) {},
		8720	"String 1",
		8721	Package (2) {}
		8722	}) // PKG2
		8723
		8724	// Namespace entry buffer reference
		8725	Store (SAR0 (BUFR, 12), Local0)
		8726
		8727	// save Local0 object type value into Local1
		8728	Store (ObjectType (Local0), Local1)
		8729
		8730	// validate Local0 is a Number
		8731	If (LNotEqual (Local1, 1)) // Number type is 1
		8732	{
		8733	Return (0x23)
		8734	}
		8735
		8736	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8737	{
		8738	Return (Local0)
		8739	}
		8740
		8741	Store ("SizeOf(Arg=BUFR) PASS", Debug)
		8742
		8743
		8744	// Namespace entry package reference
		8745	Store (SAR0 (PKG0, 4), Local0)
		8746
		8747	// save Local0 object type value into Local1
		8748	Store (ObjectType (Local0), Local1)
		8749
		8750	// validate Local0 is a Number
		8751	If (LNotEqual (Local1, 1)) // Number type is 1
		8752	{
		8753	Return (0x24)
		8754	}
		8755
		8756	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8757	{
		8758	Return (Local0)
		8759	}
		8760
		8761	Store ("SizeOf(Arg=PKG0) PASS", Debug)
		8762
		8763
		8764	// Namespace entry string reference
		8765	Store (SAR0 (STR0, 6), Local0)
		8766
		8767	// save Local0 object type value into Local1
		8768	Store (ObjectType (Local0), Local1)
		8769
		8770	// validate Local0 is a Number
		8771	If (LNotEqual (Local1, 1)) // Number type is 1
		8772	{
		8773	Return (0x25)
		8774	}
		8775
		8776	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8777	{
		8778	Return (Local0)
		8779	}
		8780
		8781	Store ("SizeOf(Arg=STR0) PASS", Debug)
		8782
		8783
		8784	// direct string reference
		8785	Store (SAR0 ("String", 6), Local0)
		8786
		8787	// save Local0 object type value into Local1
		8788	Store (ObjectType (Local0), Local1)
		8789
		8790	// validate Local0 is a Number
		8791	If (LNotEqual (Local1, 1)) // Number type is 1
		8792	{
		8793	Return (0x26)
		8794	}
		8795
		8796	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8797	{
		8798	Return (Local0)
		8799	}
		8800
		8801	Store ("SizeOf(Arg=String) PASS", Debug)
		8802
		8803	Store (0x55, Index (BUF1, 2))
		8804
		8805	/****************************************************
		8806	//
		8807	// This section is commented because it is illegal to
		8808	// perform a SizeOf operation on a Buffer Field
		8809	//
		8810	// Namespace BufferField reference
		8811	Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
		8812
		8813	// save Local0 object type value into Local1
		8814	Store (ObjectType (Local0), Local1)
		8815
		8816	// validate Local0 is a Number
		8817	If (LNotEqual (Local1, 1)) // Number type is 1
		8818	{ Return (0x27) }
		8819
		8820	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8821	{ Return (Local0) }
		8822
		8823	Store ("SizeOf(Arg=BufferField) PASS", Debug)
		8824	****************************************************/
		8825
		8826	// Namespace BufferPackageElement reference
		8827	//
		8828	Store (SAR0 (Index(PKG1, 0), 12), Local0)
		8829
		8830	// save Local0 object type value into Local1
		8831	Store (ObjectType (Local0), Local1)
		8832
		8833	// validate Local0 is a Number
		8834	If (LNotEqual (Local1, 1)) // Number type is 1
		8835	{
		8836	Return (0x28)
		8837	}
		8838
		8839	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8840	{
		8841	Return (Local0)
		8842	}
		8843
		8844	Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug)
		8845
		8846
		8847	// Namespace StringPackageElement reference
		8848	Store (SAR0 (Index (PKG1, 1, ), 7), Local0)
		8849
		8850	// save Local0 object type value into Local1
		8851	Store (ObjectType (Local0), Local1)
		8852
		8853	// validate Local0 is a Number
		8854	If (LNotEqual (Local1, 1)) // Number type is 1
		8855	{
		8856	Return (0x29)
		8857	}
		8858
		8859	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8860	{
		8861	Return (Local0)
		8862	}
		8863
		8864	Store ("SizeOf(Arg=Package String Element) PASS", Debug)
		8865
		8866
		8867	// Namespace StringPackageElement reference
		8868	Store (SAR0 (Index (PKG1, 2, ), 6), Local0)
		8869
		8870	// save Local0 object type value into Local1
		8871	Store (ObjectType (Local0), Local1)
		8872
		8873	// validate Local0 is a Number
		8874	If (LNotEqual (Local1, 1)) // Number type is 1
		8875	{
		8876	Return (0x2A)
		8877	}
		8878
		8879	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8880	{
		8881	Return (Local0)
		8882	}
		8883
		8884	Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug)
		8885
		8886
		8887	// Namespace PackagePackageElement reference
		8888	Store (SAR0 (Index (PKG1, 3, ), 4), Local0)
		8889
		8890	// save Local0 object type value into Local1
		8891	Store (ObjectType (Local0), Local1)
		8892
		8893	// validate Local0 is a Number
		8894	If (LNotEqual (Local1, 1)) // Number type is 1
		8895	{
		8896	Return (0x2B)
		8897	}
		8898
		8899	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8900	{
		8901	Return (Local0)
		8902	}
		8903
		8904	Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug)
		8905
		8906	// Package Buffer Element
		8907	Store (SAR0 (Index (PKG2, 0), 15), Local0)
		8908
		8909	// save Local0 object type value into Local1
		8910	Store (ObjectType (Local0), Local1)
		8911
		8912	// validate Local0 is a Number
		8913	If (LNotEqual (Local1, 1)) // Number type is 1
		8914	{
		8915	Return (0x2B)
		8916	}
		8917
		8918	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8919	{
		8920	Return (Local0)
		8921	}
		8922
		8923	Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug)
		8924
		8925	// Package String Element
		8926	Store (SAR0 (Index (PKG2, 1), 8), Local0)
		8927
		8928	// save Local0 object type value into Local1
		8929	Store (ObjectType (Local0), Local1)
		8930
		8931	// validate Local0 is a Number
		8932	If (LNotEqual (Local1, 1)) // Number type is 1
		8933	{
		8934	Return (0x2B)
		8935	}
		8936
		8937	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8938	{
		8939	Return (Local0)
		8940	}
		8941
		8942	Store ("SizeOf(Arg=Package String Element) PASS", Debug)
		8943
		8944	// Package Package Element
		8945	Store (SAR0 (Index (PKG2, 2), 2), Local0)
		8946
		8947	// save Local0 object type value into Local1
		8948	Store (ObjectType (Local0), Local1)
		8949
		8950	// validate Local0 is a Number
		8951	If (LNotEqual (Local1, 1)) // Number type is 1
		8952	{
		8953	Return (0x2B)
		8954	}
		8955
		8956	If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
		8957	{
		8958	Return (Local0)
		8959	}
		8960
		8961	Store ("SizeOf(Arg=Package Package Element) PASS", Debug)
		8962
		8963	Store ("SizeOf(Arg) PASS", Debug)
		8964
		8965	Return (0)
		8966	} // SARG: SizeOf(Arg) test control method
		8967
		8968	Method (SBUF)
		8969	{ // SBUF: SizeOf(Buffer) test control method
		8970	Name (BUFR, Buffer (12) {})
		8971
		8972	// store size of BUFR buffer into Local0
		8973	Store (SizeOf (BUFR), Local0)
		8974
		8975	// save Local0 object type value into Local1
		8976	Store (ObjectType (Local0), Local1)
		8977
		8978	// validate Local0 is a Number
		8979	If (LNotEqual (Local1, 1)) // Number type is 1
		8980	{
		8981	Return (0x31)
		8982	}
		8983
		8984	If (LNotEqual (Local0, 12)) // BUFR size is 12
		8985	{
		8986	Return (0x32)
		8987	}
		8988
		8989	Store ("SizeOf(BUFR) PASS", Debug)
		8990
		8991	Return (0)
		8992	} // SBUF: SizeOf(Buffer) test control method
		8993
		8994
		8995	/****************************************************
		8996	//
		8997	// This section is commented because it is illegal to
		8998	// perform a SizeOf operation on a Buffer Field
		8999	//
		9000	Method (SIND)
		9001	{ // SIND: SizeOf(Index(,,)) test control method
		9002	Name (BUFR, Buffer (12) {})
		9003
		9004	// store size of Index(BUFR,2,) buffer into Local0
		9005	Store (SizeOf (Index (BUFR, 2, )), Local0)
		9006
		9007	// save Local0 object type value into Local1
		9008	Store (ObjectType (Local0), Local1)
		9009
		9010	// validate Local0 is a Number
		9011	If (LNotEqual (Local1, 1)) // Number type is 1
		9012	{
		9013	Return (0x41)
		9014	}
		9015
		9016	If (LNotEqual (Local0, 10)) // 12 - 2 = 10
		9017	{
		9018	Return (0x42)
		9019	}
		9020
		9021	Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
		9022
		9023	// TBD: strings and packages
		9024
		9025	Return (0)
		9026	} // SIND: SizeOf(Index(,,)) test control method
		9027	****************************************************/
		9028
		9029	Method (SLOC)
		9030	{ // SLOC: SizeOf(Local) test control method
		9031	Name (BUFR, Buffer (12) {}) // uninitialized Buffer
		9032	Name (STR0, "String")
		9033	Name (PKG0, Package (4) {}) // uninitialized Package
		9034
		9035
		9036	// store BUFR Buffer into Local2
		9037	Store (BUFR, Local2)
		9038
		9039	// store size of BUFR buffer into Local0
		9040	Store (SizeOf (Local2), Local0)
		9041
		9042	// save Local0 object type value into Local1
		9043	Store (ObjectType (Local0), Local1)
		9044
		9045	// validate Local0 is a Number
		9046	If (LNotEqual (Local1, 1)) // Number type is 1
		9047	{
		9048	Return (0x51)
		9049	}
		9050
		9051	If (LNotEqual (Local0, 12)) // BUFR size is 12
		9052	{
		9053	Return (0x52)
		9054	}
		9055
		9056	Store ("SizeOf(Local2=Buffer) PASS", Debug)
		9057
		9058
		9059	// store STR0 string into Local2
		9060	Store (STR0, Local2)
		9061
		9062	// store size of STR0 buffer into Local0
		9063	Store (SizeOf (Local2), Local0)
		9064
		9065	// save Local0 object type value into Local1
		9066	Store (ObjectType (Local0), Local1)
		9067
		9068	// validate Local0 is a Number
		9069	If (LNotEqual (Local1, 1)) // Number type is 1
		9070	{
		9071	Return (0x53)
		9072	}
		9073
		9074	If (LNotEqual (Local0, 6)) // STR0 size is 6
		9075	{
		9076	Return (0x54)
		9077	}
		9078
		9079	Store ("SizeOf(Local2=String) PASS", Debug)
		9080
		9081
		9082	// store PKG0 Package into Local2
		9083	Store (PKG0, Local2)
		9084
		9085	// store size of PKG0 buffer into Local0
		9086	Store (SizeOf (Local2), Local0)
		9087
		9088	// save Local0 object type value into Local1
		9089	Store (ObjectType (Local0), Local1)
		9090
		9091	// validate Local0 is a Number
		9092	If (LNotEqual (Local1, 1)) // Number type is 1
		9093	{
		9094	Return (0x55)
		9095	}
		9096
		9097	If (LNotEqual (Local0, 4)) // PKG0 size is 4
		9098	{
		9099	Return (0x56)
		9100	}
		9101
		9102	Store ("SizeOf(Local2=Package) PASS", Debug)
		9103
		9104
		9105	Return (0)
		9106	} // SLOC: SizeOf(Local) test control method
		9107
		9108	Method (TEST)
		9109	{
		9110	Store ("++++++++ SizeOf Test", Debug)
		9111
		9112	// Store current operating system string into Local0
		9113	Store (_OS, Local0)
		9114
		9115	Store (SizeOf (_OS), Local3)
		9116
		9117	// save Local3 object type value into Local4
		9118	Store (ObjectType (Local3), Local4)
		9119
		9120	// validate Local3 is a Number
		9121	If (LNotEqual (Local4, 1)) // Number type is 1
		9122	{
		9123	// failure
		9124	Return (0x61)
		9125	}
		9126
		9127	// Store current operating system string into Local0
		9128	// This verifies above SizeOf(_OS) did not corrupt ACPI namespace
		9129	Store (_OS, Local0)
		9130
		9131	// Store SARG [Validate SizeOf(Arg)] return value into Local1
		9132	Store (SARG, Local1)
		9133
		9134	// save Local1 object type value into Local2
		9135	Store (ObjectType (Local1), Local2)
		9136
		9137	// validate Local1 is a Number
		9138	If (LNotEqual (Local2, 1)) // Number type is 1
		9139	{
		9140	// failure
		9141	Return (0x62)
		9142	}
		9143
		9144	// zero indicates pass, non-zero is an error code
		9145	If (LNotEqual (Local1, 0))
		9146	{
		9147	// return SARG error code
		9148	Return (Local1)
		9149	}
		9150
		9151
		9152	// Store SBUF [Validate SizeOf(Buffer)] return value into Local1
		9153	Store (SBUF, Local1)
		9154
		9155	// save Local1 object type value into Local2
		9156	Store (ObjectType (Local1), Local2)
		9157
		9158	// validate Local1 is a Number
		9159	If (LNotEqual (Local2, 1)) // Number type is 1
		9160	{
		9161	// failure
		9162	Return (0x63)
		9163	}
		9164
		9165	// zero indicates pass, non-zero is an error code
		9166	If (LNotEqual (Local1, 0))
		9167	{
		9168	// return SBUF error code
		9169	Return (Local1)
		9170	}
		9171
		9172	/****************************************************
		9173	//
		9174	// This section is commented because it is illegal to
		9175	// perform a SizeOf operation on a Buffer Field
		9176	//
		9177	// Store SIND [verify SizeOf(Index(,,))] return value into Local1
		9178	Store (SIND, Local1)
		9179
		9180	// save Local1 object type value into Local2
		9181	Store (ObjectType (Local1), Local2)
		9182
		9183	// validate Local1 is a Number
		9184	If (LNotEqual (Local2, 1)) // Number type is 1
		9185	{
		9186	// failure
		9187	Return (0x64)
		9188	}
		9189
		9190	// zero indicates pass, non-zero is an error code
		9191	If (LNotEqual (Local1, 0))
		9192	{
		9193	// return SARG error code
		9194	Return (Local1)
		9195	}
		9196	****************************************************/
		9197
		9198	// Store SLOC [verify SizeOf(Local)] return value into Local1
		9199	Store (SLOC, Local1)
		9200
		9201	// save Local1 object type value into Local2
		9202	Store (ObjectType (Local1), Local2)
		9203
		9204	// validate Local1 is a Number
		9205	If (LNotEqual (Local2, 1)) // Number type is 1
		9206	{
		9207	// failure
		9208	Return (0x65)
		9209	}
		9210
		9211	// zero indicates pass, non-zero is an error code
		9212	If (LNotEqual (Local1, 0))
		9213	{
		9214	// return SLOC error code
		9215	Return (Local1)
		9216	}
		9217
		9218
		9219	// TBD: SizeOf (METH) -- where METH control method returns
		9220	// buffer, BufferField, string, package, package element
		9221
		9222
		9223	Return (0)
		9224	} // TEST
		9225	} // SIZO
		9226
		9227	//
		9228	// test SmiShare.asl
		9229	//
		9230	Scope (\_SB) // System Bus
		9231	{ // _SB system bus
		9232	// Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
		9233	OperationRegion(RAM1, SystemMemory, 0x400000, 0xA)
		9234
		9235	Field (RAM1, AnyAcc, NoLock, Preserve)
		9236	{
		9237	BI1T, 1, // Create some bits in memory to access
		9238	BI2T, 2,
		9239	BI3T, 3,
		9240	LST2, 2
		9241	} // End Field RAM1
		9242
		9243	Field (RAM1, WordAcc, NoLock, WriteAsZeros)
		9244	{
		9245	WRD, 16
		9246	} // End 2nd Field RAM1
		9247
		9248	Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
		9249	{
		9250	BYTE, 8
		9251	} // End 3rd Field RAM1
		9252
		9253	Field (RAM1, ByteAcc, NoLock, Preserve)
		9254	{
		9255	SMIC, 8,
		9256	SMID, 8
		9257	}
		9258
		9259	Device (MBIT)
		9260	{
		9261	Method (_INI)
		9262	{
		9263	Store (0, BI1T)
		9264	Store (3, BI2T)
		9265	Store (7, BI3T)
		9266	Store (0, LST2)
		9267	} // End _INI Method
		9268	} // End Device MBIT
		9269
		9270	Device (MWRD)
		9271	{
		9272	Method (_INI)
		9273	{
		9274	Store (0, WRD)
		9275	} // End _INI Method
		9276	} // End Device MWRD
		9277
		9278	Device (MBYT)
		9279	{
		9280	Method (_INI)
		9281	{
		9282	Store (0, BYTE)
		9283	Store (0xC, SMIC)
		9284	Store (0xD, SMID)
		9285	} // End _INI Method
		9286	} // End Device MBYT
		9287
		9288	/*
		9289	// Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
		9290	OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
		9291
		9292	Field (\RAM1, AnyAcc, NoLock, Preserve)
		9293	{
		9294	BI1T, 1, // Create some bits in memory to access
		9295	BI2T, 2,
		9296	BI3T, 3,
		9297	LST2, 2
		9298	} // End Field RAM1
		9299
		9300	Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
		9301	{
		9302	WRD, 16
		9303	} // End 2nd Field RAM1
		9304
		9305	Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
		9306	{
		9307	BYTE, 8
		9308	} // End 3rd Field RAM1
		9309
		9310	Field (\RAM1, ByteAcc, NoLock, Preserve)
		9311	{
		9312	SMIC, 8,
		9313	SMID, 8
		9314	}
		9315	*/
		9316	Method (SMIX)
		9317	{
		9318	Return (BYTE)
		9319	} // End SMIX
		9320
		9321	Method (EVNT)
		9322	{
		9323	Store (SMIX, Local0)
		9324
		9325	If (And (Local0, 0x01))
		9326	{ Notify (\_SB_.SMIS, 0x21)}
		9327
		9328	If (And (Local0, 0x02))
		9329	{ Notify (\_SB_.SMIS, 0x22)}
		9330
		9331	If (And (Local0, 0x04))
		9332	{ Notify (\_SB_.SMIS, 0x24)}
		9333
		9334	If (And (Local0, 0x08))
		9335	{ Notify (\_SB_.SMIS, 0x28)}
		9336
		9337	} // End Method EVNT
		9338
		9339	Device (SMIS)
		9340	{
		9341	Method (BINK)
		9342	{
		9343	Store (0, Local0) // Zero out Local0
		9344
		9345	If (LNotEqual (SMID, 0xD))
		9346	{ Or (0x80, Local0, Local0)}
		9347
		9348	If (LNotEqual (SMIC, 0xC))
		9349	{ Or (0x40, Local0, Local0)}
		9350
		9351	If (LNotEqual (BYTE, 0))
		9352	{ Or (0x20, Local0, Local0)}
		9353
		9354	If (LNotEqual (WRD, 0))
		9355	{ Or (0x10, Local0, Local0)}
		9356
		9357	If (LNotEqual (LST2, 0))
		9358	{ Or (0x8, Local0, Local0)}
		9359
		9360	If (LNotEqual (BI3T, 0x7))
		9361	{ Or (0x4, Local0, Local0)}
		9362
		9363	If (LNotEqual (BI2T, 0x3))
		9364	{ Or (0x2, Local0, Local0)}
		9365
		9366	If (LNotEqual (BI1T, 0))
		9367	{ Or (0x1, Local0, Local0)}
		9368
		9369	Return (Local0)
		9370	} // End Method BINK
		9371
		9372	Method (TEST)
		9373	{
		9374	Store ("++++++++ SmiShare Test", Debug)
		9375
		9376	// Expect EVNT to generate Notify value we just previously
		9377	// stored in BYTE
		9378	Store (0x20, BYTE)
		9379	EVNT ()
		9380	Store (0x21, BYTE)
		9381	EVNT ()
		9382	Store (0x22, BYTE)
		9383	EVNT ()
		9384	Store (0x23, BYTE)
		9385	EVNT ()
		9386
		9387	Return (0) // pass
		9388	} // End Method TEST
		9389	} // Device SMIS
		9390
		9391	Device(CNDT)
		9392	{
		9393	Method(TEST)
		9394	{
		9395	If (ECOK)
		9396	{
		9397	return("Broken")
		9398	}
		9399	Else
		9400	{
		9401	return("Works")
		9402	}
		9403	}
		9404
		9405	Method(ECOK)
		9406	{
		9407	Return(0x0)
		9408	}
		9409	}
		9410
		9411	} // _SB system bus
		9412
		9413
		9414	/* Test a very big buffer */
		9415
		9416	Name(WQAB, Buffer(6756)
		9417	{
		9418	0x46,0x4F,0x4D,0x42,0x01,0x00,0x00,0x00,
		9419	0x54,0x1A,0x00,0x00,0xBA,0xAD,0x00,0x00,
		9420	0x44,0x53,0x00,0x01,0x1A,0x7D,0xDA,0x54,
		9421	0x98,0xBD,0x92,0x00,0x01,0x06,0x18,0x42,
		9422	0x10,0x47,0x10,0x92,0x46,0x62,0x02,0x89,
		9423	0x80,0x90,0x18,0x18,0x14,0x81,0x85,0x00,
		9424	0x49,0x02,0x88,0xC4,0x41,0xE1,0x20,0xD4,
		9425	0x9F,0x40,0x7E,0x05,0x20,0x74,0x28,0x40,
		9426	0xA6,0x00,0x83,0x02,0x9C,0x22,0x88,0xA0,
		9427	0x57,0x01,0x36,0x05,0x98,0x14,0x60,0x51,
		9428	0x80,0x76,0x01,0x96,0x05,0xE8,0x16,0x20,
		9429	0x1D,0x96,0x88,0x04,0x47,0x89,0x01,0x47,
		9430	0xE9,0xC4,0x16,0x6E,0xD8,0xE0,0x85,0xA2,
		9431	0x68,0x06,0x51,0x12,0x94,0x8B,0x20,0x5D,
		9432	0x10,0x52,0x2E,0xC0,0x37,0x82,0x06,0x10,
		9433	0xA5,0x77,0x01,0xB6,0x05,0x98,0x86,0x27,
		9434	0xD2,0x20,0xE4,0x60,0x08,0x54,0xCE,0x80,
		9435	0x20,0x69,0x44,0x21,0x1E,0xA7,0x44,0x08,
		9436	0x0A,0x84,0x90,0xD4,0xF1,0xA0,0xA0,0x71,
		9437	0x88,0xAD,0xCE,0x46,0x93,0xA9,0x74,0x7E,
		9438	0x48,0x82,0x70,0xC6,0x2A,0x7E,0x3A,0x9A,
		9439	0xD0,0xD9,0x9C,0x60,0xE7,0x18,0x72,0x3C,
		9440	0x48,0xF4,0x20,0xB8,0x00,0x0F,0x1C,0x2C,
		9441	0x34,0x84,0x22,0x6B,0x80,0xC1,0x8C,0xDD,
		9442	0x63,0xB1,0x0B,0x4E,0x0A,0xEC,0x61,0xB3,
		9443	0x01,0x19,0xA2,0x24,0x38,0xD4,0x11,0xC0,
		9444	0x12,0x05,0x98,0x1F,0x87,0x0C,0x0F,0x95,
		9445	0x8C,0x25,0x24,0x1B,0xAB,0x87,0xC2,0xA5,
		9446	0x40,0x68,0x6C,0x27,0xED,0x19,0x45,0x2C,
		9447	0x79,0x4A,0x82,0x49,0xE0,0x51,0x44,0x36,
		9448	0x1A,0x27,0x28,0x1B,0x1A,0x25,0x03,0x42,
		9449	0x9E,0x05,0x58,0x07,0x26,0x04,0x76,0x2F,
		9450	0xC0,0x9A,0x00,0x73,0xB3,0x90,0xB1,0xB9,
		9451	0xE8,0xFF,0x0F,0x71,0xB0,0x31,0xDA,0x9A,
		9452	0xAE,0x90,0xC2,0xC4,0x88,0x12,0x2C,0x5E,
		9453	0xC5,0xC3,0x10,0xCA,0x93,0x42,0xA8,0x48,
		9454	0x95,0xA1,0x68,0xB4,0x51,0x2A,0x14,0xE0,
		9455	0x4C,0x80,0x30,0x5C,0x1D,0x03,0x82,0x46,
		9456	0x88,0x15,0x29,0x56,0xFB,0x83,0x20,0xF1,
		9457	0x2D,0x40,0x54,0x01,0xA2,0x48,0xA3,0x41,
		9458	0x9D,0x03,0x3C,0x5C,0x0F,0xF5,0xF0,0x3D,
		9459	0xF6,0x93,0x0C,0x72,0x90,0x67,0xF1,0xA8,
		9460	0x70,0x9C,0x06,0x49,0xE0,0x0B,0x80,0x4F,
		9461	0x08,0x1E,0x38,0xDE,0x35,0xA0,0x66,0x7C,
		9462	0xBC,0x4C,0x10,0x1C,0x6A,0x88,0x1E,0x68,
		9463	0xB8,0x13,0x38,0x44,0x06,0xE8,0x49,0x3D,
		9464	0x52,0x60,0x07,0x77,0x32,0xEF,0x01,0xAF,
		9465	0x0A,0xCD,0x5E,0x12,0x08,0xC1,0xF1,0xF8,
		9466	0x7E,0xC0,0x26,0x9C,0xC0,0xF2,0x07,0x81,
		9467	0x1A,0x99,0xA1,0x3D,0xCA,0xD3,0x8A,0x19,
		9468	0xF2,0x31,0xC1,0x04,0x16,0x0B,0x21,0x05,
		9469	0x10,0x1A,0x0F,0xF8,0x6F,0x00,0x8F,0x17,
		9470	0xBE,0x12,0xC4,0xF6,0x80,0x12,0x0C,0x0B,
		9471	0x21,0x23,0xAB,0xF0,0x78,0xE8,0x28,0x7C,
		9472	0x95,0x38,0x9C,0xD3,0x8A,0x67,0x82,0xE1,
		9473	0x20,0xF4,0x05,0x90,0x00,0x51,0xE7,0x0C,
		9474	0xD4,0x61,0xC1,0xE7,0x04,0x76,0x33,0x38,
		9475	0x83,0x47,0x00,0x8F,0xE4,0x84,0xFC,0x2B,
		9476	0xF1,0xC0,0xE0,0x03,0xE2,0xEF,0x1F,0xA7,
		9477	0xEC,0x11,0x9C,0xA9,0x01,0x7D,0x1C,0xF0,
		9478	0xFF,0x7F,0x28,0x7C,0x88,0x1E,0xDF,0x29,
		9479	0x1F,0xAF,0x4F,0x17,0x96,0x35,0x4E,0xE8,
		9480	0x77,0x08,0x9F,0x38,0x7C,0x64,0x71,0x44,
		9481	0x08,0x39,0x39,0x05,0xA0,0x81,0x4F,0xF7,
		9482	0xEC,0x22,0x9C,0xAE,0x27,0xE5,0x40,0xC3,
		9483	0xA0,0xE3,0x04,0xC7,0x79,0x00,0x1C,0xE3,
		9484	0x84,0x7F,0x2E,0x80,0x3F,0x40,0x7E,0xCA,
		9485	0x78,0xC5,0x48,0xE0,0x98,0x23,0x44,0x9F,
		9486	0x6B,0x3C,0x42,0x2C,0xFC,0x53,0x45,0xE1,
		9487	0x03,0x21,0x63,0x04,0x17,0xA0,0xC7,0x08,
		9488	0x7C,0x03,0x8E,0x11,0x7D,0x94,0xE0,0xEA,
		9489	0x0F,0x1A,0x74,0x80,0xB8,0xFF,0xFF,0x00,
		9490	0xE1,0x83,0x7A,0x80,0xC0,0x37,0xFA,0xD1,
		9491	0x03,0x3D,0x2E,0x8B,0x3E,0x0F,0xC8,0xF8,
		9492	0x89,0x46,0xF3,0xE2,0xA7,0x03,0x7E,0xF8,
		9493	0x00,0x0F,0xA8,0x87,0x84,0x03,0xC5,0x4C,
		9494	0x9B,0x83,0x3E,0xBB,0x1C,0x3A,0x76,0xB8,
		9495	0xE0,0x3F,0x81,0x80,0x4B,0xDE,0x21,0x0C,
		9496	0x14,0x23,0xC6,0x9F,0x83,0x7C,0x0A,0x03,
		9497	0xFF,0xFF,0xFF,0x14,0x06,0xFE,0xE1,0xF0,
		9498	0x20,0x4F,0x07,0x9F,0xB6,0xA8,0x74,0x18,
		9499	0xD4,0x81,0x0B,0xB0,0x32,0x89,0x08,0xCF,
		9500	0x12,0xB5,0x41,0xE8,0xD4,0xF0,0x36,0xF1,
		9501	0xB6,0xE5,0x5B,0x40,0x9C,0xD3,0xEC,0xED,
		9502	0xC0,0x45,0x30,0x22,0xD4,0x0C,0x45,0x4E,
		9503	0x5A,0x11,0x63,0x44,0x79,0xDC,0x32,0xCA,
		9504	0xDB,0xD6,0x0B,0x40,0xBC,0x13,0x7B,0xDE,
		9505	0x32,0x46,0xF0,0xC8,0x0F,0x5C,0x2C,0xC6,
		9506	0xEA,0xF5,0x5F,0xF3,0x81,0x0B,0x70,0xF6,
		9507	0xFF,0x3F,0x70,0x01,0x1C,0x0A,0x7A,0x18,
		9508	0x42,0x0F,0xC3,0x53,0x39,0x97,0x87,0xC8,
		9509	0x53,0x89,0x18,0x35,0x4C,0xD4,0x67,0x28,
		9510	0xDF,0x2D,0x7C,0x20,0x02,0xDF,0x99,0x0B,
		9511	0xF8,0xFD,0xFF,0x0F,0x44,0x70,0x8E,0x29,
		9512	0xB8,0x33,0x0D,0x78,0x7C,0xCE,0x40,0x20,
		9513	0xA7,0xE2,0x43,0x0D,0x60,0x41,0xF4,0x13,
		9514	0xC2,0x27,0x1A,0x2A,0x13,0x06,0x75,0xA8,
		9515	0x01,0xAC,0x5C,0x61,0x9E,0x46,0xCF,0xF9,
		9516	0x59,0xC6,0xA7,0x1A,0x1F,0x4A,0x8D,0x63,
		9517	0x88,0x97,0x99,0x87,0x1A,0x1F,0x0B,0x5E,
		9518	0x49,0x7D,0xA8,0x31,0x54,0x9C,0x87,0x1A,
		9519	0x0F,0x37,0x50,0xD4,0x37,0x9B,0x67,0x1B,
		9520	0xA3,0xC7,0xF7,0x0D,0xD5,0x10,0x0F,0x35,
		9521	0x4C,0xF2,0x4A,0x35,0x16,0x1F,0x6A,0xC0,
		9522	0xF1,0xFF,0x3F,0xD4,0x00,0xFC,0xFF,0xFF,
		9523	0x1F,0x6A,0x00,0x47,0x47,0x03,0x38,0x47,
		9524	0x46,0xDC,0xD1,0x00,0x5C,0x87,0x52,0xE0,
		9525	0x70,0x34,0x00,0x1E,0x47,0x21,0x30,0x5F,
		9526	0x68,0x7C,0x14,0x02,0x16,0xFF,0xFF,0xA3,
		9527	0x10,0xF8,0x65,0x9F,0x83,0x50,0x42,0x8F,
		9528	0x42,0x80,0xA0,0xDB,0xCF,0x53,0xC4,0xB3,
		9529	0x8F,0x2F,0x3F,0x0F,0x04,0x11,0x5E,0xF3,
		9530	0x7D,0x0A,0xF2,0x21,0xDF,0x47,0x21,0x06,
		9531	0x63,0x28,0x5F,0x83,0x7C,0x14,0x62,0x50,
		9532	0xAF,0x41,0xBE,0xEF,0x1B,0xE4,0xF1,0x22,
		9533	0x48,0xEC,0x67,0x02,0x1F,0x85,0x98,0xE8,
		9534	0xA3,0x10,0xA0,0xF0,0xFF,0x7F,0x14,0x02,
		9535	0xF8,0xFF,0xFF,0x3F,0x0A,0x01,0xCE,0x02,
		9536	0x1C,0x0D,0x40,0x37,0xAD,0x47,0x21,0xF0,
		9537	0xDE,0x59,0x4E,0xFB,0x04,0x7C,0x16,0x02,
		9538	0xCC,0xFE,0xFF,0xCF,0x42,0xC0,0xEC,0x28,
		9539	0x74,0x14,0x67,0xF9,0x2A,0xF4,0x04,0xF0,
		9540	0x02,0x10,0x23,0xCC,0x3B,0xD0,0x4B,0x26,
		9541	0xBB,0x8B,0x1B,0xE7,0xC9,0xE5,0x2C,0x9E,
		9542	0xC4,0x7D,0x09,0xF2,0x81,0xE2,0x59,0xC8,
		9543	0x50,0xA7,0x1B,0xF4,0x8D,0xDC,0x03,0x8B,
		9544	0x19,0x3F,0xC4,0xF3,0x90,0x21,0x9E,0x85,
		9545	0x00,0x76,0xFD,0xFF,0xCF,0x42,0x00,0xFF,
		9546	0xFF,0xFF,0x47,0x03,0xF8,0x2F,0x00,0x9F,
		9547	0x85,0x80,0xE7,0x09,0xE0,0x41,0xDB,0x67,
		9548	0x21,0x80,0x33,0x87,0xCB,0xF3,0x7F,0x05,
		9549	0x3A,0x96,0xF7,0x08,0xCF,0xFA,0x24,0x5F,
		9550	0x2F,0x3D,0xD3,0x87,0x82,0x67,0x21,0x86,
		9551	0x75,0x18,0x3E,0x0B,0x31,0x88,0x17,0x4D,
		9552	0x43,0xBC,0x70,0xFA,0x30,0xE0,0xFF,0x3F,
		9553	0x5E,0xE0,0x57,0x4E,0x03,0x05,0x09,0xF4,
		9554	0x2C,0x04,0x30,0xFE,0xFF,0x7F,0x16,0x02,
		9555	0xC8,0xB8,0x46,0x9D,0x85,0x80,0xE5,0x6D,
		9556	0xE5,0x19,0xDB,0xA7,0x95,0x04,0xFF,0xFF,
		9557	0x67,0x21,0xC0,0x41,0x2E,0x23,0x07,0x21,
		9558	0x4C,0xC4,0x87,0x83,0x8F,0x99,0x80,0x9E,
		9559	0x29,0xBE,0xB8,0x1B,0xE3,0x09,0xE0,0x45,
		9560	0xE2,0x31,0x93,0x1D,0x35,0x0D,0xF3,0x2C,
		9561	0x64,0xBC,0xB3,0x78,0x0D,0x78,0x82,0xF7,
		9562	0xE4,0x9F,0x85,0x18,0xD8,0x61,0x05,0x7B,
		9563	0x14,0x32,0xA8,0xC1,0x63,0x87,0x08,0x13,
		9564	0xE8,0x59,0x88,0xC5,0x7D,0xAE,0xE8,0x3C,
		9565	0xE1,0xB3,0x10,0xF0,0xFE,0xFF,0x9F,0x25,
		9566	0xE0,0x5E,0x0D,0x9E,0x85,0x00,0x13,0x87,
		9567	0x0D,0x9F,0x35,0xC0,0x33,0x7C,0x8F,0xEA,
		9568	0x1C,0x1E,0x8F,0x81,0x7F,0x56,0x1D,0xE7,
		9569	0x04,0x96,0x7B,0xD1,0xB2,0x71,0xA0,0xA1,
		9570	0x23,0xB2,0x3A,0x20,0x8D,0x0D,0x73,0x29,
		9571	0x89,0x7C,0x72,0x6C,0xD4,0x56,0x04,0xA7,
		9572	0x33,0x93,0x4F,0x00,0xD6,0x42,0x21,0x05,
		9573	0x34,0x1A,0x8B,0xE1,0x9D,0xF9,0xE8,0x44,
		9574	0x41,0x0C,0xE8,0xE3,0x90,0x6D,0x1C,0x0A,
		9575	0x50,0x7B,0xD1,0x14,0xC8,0x39,0x07,0xA3,
		9576	0x7F,0x76,0x74,0x36,0xBE,0x13,0x70,0x0D,
		9577	0x10,0x3A,0x25,0x18,0xDA,0x6A,0x04,0xFC,
		9578	0xFF,0x67,0x89,0x01,0x33,0xFE,0x53,0x8C,
		9579	0x09,0x7C,0x8E,0xC1,0x1F,0x0C,0xF0,0x03,
		9580	0x7F,0x31,0xA8,0xFA,0x5E,0xA0,0xFB,0x82,
		9581	0xD5,0xDD,0x64,0x20,0xCC,0xC8,0x04,0xF5,
		9582	0x9D,0x0E,0x40,0x01,0xE4,0x0B,0x81,0xCF,
		9583	0x51,0x0F,0x05,0x6C,0x22,0x21,0xC2,0x44,
		9584	0x33,0x3A,0x62,0xC2,0xA8,0xE8,0x13,0xA6,
		9585	0x20,0x9E,0xB0,0x63,0x4D,0x18,0x3D,0x13,
		9586	0x5F,0x74,0xD8,0x88,0x31,0x21,0xAE,0x1E,
		9587	0xD0,0x26,0x18,0xD4,0x97,0x22,0x58,0x43,
		9588	0xE6,0x63,0xF1,0x05,0x02,0x37,0x65,0x30,
		9589	0xCE,0x89,0x5D,0x13,0x7C,0xD9,0xC1,0xCD,
		9590	0x19,0x8C,0xF0,0x98,0xBB,0x18,0xBF,0x3A,
		9591	0x79,0x74,0xFC,0xA0,0xE0,0x1B,0x0E,0xC3,
		9592	0x7E,0x32,0xF3,0x8C,0xDE,0xCB,0x7C,0x8D,
		9593	0xC3,0xC0,0x7A,0xBC,0x1C,0xD6,0x68,0x61,
		9594	0x0F,0xED,0x3D,0xC4,0xFF,0xFF,0x43,0x8C,
		9595	0xCF,0x13,0xC6,0x08,0xEB,0xDB,0x0B,0x38,
		9596	0xEE,0x59,0xF0,0xEF,0x1A,0xE0,0xB9,0x84,
		9597	0xF8,0xAE,0x01,0x30,0xF0,0xFF,0x7F,0xD7,
		9598	0x00,0x4E,0xD7,0x04,0xDF,0x35,0x80,0xF7,
		9599	0xD0,0x7D,0xD7,0x00,0xAE,0xD9,0xEF,0x1A,
		9600	0xA8,0x63,0x80,0x15,0xDE,0x35,0xA0,0x5D,
		9601	0xD9,0xDE,0xD7,0x9E,0xB0,0xAC,0xE9,0xB2,
		9602	0x81,0x52,0x73,0xD9,0x00,0x14,0xFC,0xFF,
		9603	0x2F,0x1B,0x80,0x01,0x29,0x13,0x46,0x85,
		9604	0x9F,0x30,0x05,0xF1,0x84,0x1D,0xEC,0xB2,
		9605	0x01,0x8A,0x18,0x97,0x0D,0xD0,0x8F,0xED,
		9606	0x65,0x03,0x18,0xDC,0x13,0xF8,0x6D,0x03,
		9607	0x78,0x43,0xFA,0xB6,0x01,0xD6,0xFF,0xFF,
		9608	0x6D,0x03,0xAC,0xF9,0x6F,0x1B,0x28,0x0E,
		9609	0xAB,0xBC,0x6D,0x40,0x3C,0xC9,0x33,0x02,
		9610	0xAB,0xBA,0x6E,0xA0,0xF4,0x5C,0x37,0x00,
		9611	0x12,0x88,0x99,0x30,0x2A,0xFE,0x84,0x29,
		9612	0x88,0x27,0xEC,0x68,0xD7,0x0D,0x50,0x04,
		9613	0xB9,0x6E,0x80,0x7E,0x5E,0x09,0xFE,0xFF,
		9614	0xAF,0x1B,0xC0,0xE0,0xA2,0x80,0xB9,0x6F,
		9615	0x00,0x6F,0x58,0x7E,0xDF,0x00,0x7C,0xDC,
		9616	0xC4,0x31,0xF7,0x0D,0xC0,0xCC,0xFF,0xFF,
		9617	0xBE,0x01,0xB0,0xE7,0xA2,0x80,0xBB,0x6F,
		9618	0x00,0xEF,0x8B,0xB4,0xEF,0x1B,0x60,0xFE,
		9619	0xFF,0xDF,0x37,0xC0,0x28,0x6D,0xFD,0x1E,
		9620	0x1C,0x3D,0x21,0x78,0x7C,0xB8,0xFB,0xA5,
		9621	0xC7,0xE7,0xBB,0x39,0x38,0x06,0x79,0x8C,
		9622	0x87,0x76,0xC0,0xAF,0xEF,0x9E,0x98,0xEF,
		9623	0xE6,0xC0,0xFF,0x4C,0x70,0x3C,0x18,0x68,
		9624	0x1C,0x62,0xAB,0x97,0x06,0x72,0x34,0x38,
		9625	0x3F,0xDC,0x19,0x81,0x61,0x15,0x7F,0xF2,
		9626	0x47,0x38,0xC7,0xD0,0xD9,0xE1,0x20,0xB1,
		9627	0x83,0xE0,0xC1,0x56,0x6D,0x02,0x85,0x86,
		9628	0x50,0x14,0x18,0x14,0x8B,0x0F,0x18,0xF8,
		9629	0x61,0xB3,0xB3,0x00,0x93,0x04,0x87,0x3A,
		9630	0x02,0xF8,0x3E,0xD1,0xFC,0x38,0x74,0x37,
		9631	0x38,0x54,0x8F,0xE5,0xA1,0x80,0x9E,0x01,
		9632	0x71,0xC7,0x0C,0x32,0x69,0xCF,0x28,0xE2,
		9633	0x53,0xC2,0x29,0x85,0x49,0xE0,0xF3,0x03,
		9634	0x43,0xE3,0x04,0xAF,0x0D,0xA1,0xF9,0xFF,
		9635	0xFF,0xA4,0xC0,0x3C,0xDF,0x31,0x04,0x6C,
		9636	0x02,0xBB,0xBF,0x64,0xC8,0xDA,0xC0,0x75,
		9637	0x4B,0x32,0x44,0x6F,0x38,0xB2,0x85,0xA2,
		9638	0xE9,0x44,0x79,0xDF,0x88,0x62,0x67,0x08,
		9639	0xC2,0x88,0x12,0x2C,0xC8,0xA3,0x42,0xAC,
		9640	0x28,0x2F,0x05,0x46,0x88,0x18,0xE2,0x95,
		9641	0x23,0xD0,0x09,0x87,0x0F,0xF2,0xD8,0x14,
		9642	0xA7,0xFD,0x41,0x90,0x58,0x4F,0x02,0x8D,
		9643	0xC5,0x91,0x46,0x83,0x3A,0x07,0x78,0xB8,
		9644	0x3E,0xC4,0x78,0xF8,0x0F,0x21,0x06,0x39,
		9645	0xC8,0x73,0x7B,0x54,0x38,0x4E,0x5F,0x25,
		9646	0x4C,0xF0,0x02,0xE0,0x83,0x0A,0x1C,0xD7,
		9647	0x80,0x9A,0xF1,0x33,0x06,0x58,0x8E,0xE3,
		9648	0x3E,0xA9,0xC0,0x1D,0x8F,0xEF,0x07,0x6C,
		9649	0xC2,0x09,0x2C,0x7F,0x10,0xA8,0xE3,0x0C,
		9650	0x9F,0xE7,0x0B,0x8B,0x21,0x1F,0x13,0x4C,
		9651	0x60,0xB1,0x27,0x1B,0x3A,0x1E,0xF0,0xDF,
		9652	0x63,0x1E,0x2F,0x7C,0x32,0xF1,0x7C,0x4D,
		9653	0x30,0x22,0x84,0x9C,0x8C,0x07,0x7D,0x87,
		9654	0xC0,0x5C,0x6F,0xD8,0xB9,0x85,0x8B,0x3A,
		9655	0x68,0xA0,0x4E,0x0B,0x3E,0x28,0xB0,0x9B,
		9656	0x11,0xE6,0xB8,0xCE,0xCF,0x2A,0x60,0xF8,
		9657	0xFF,0x9F,0x55,0x60,0x8F,0x10,0xFE,0xED,
		9658	0xC1,0xF3,0xF2,0x95,0xE1,0xD5,0x21,0x81,
		9659	0x43,0x8E,0x10,0x3D,0x2E,0x8F,0x10,0x73,
		9660	0x3E,0xC2,0x0C,0x11,0x5C,0x67,0x01,0x70,
		9661	0x0C,0x11,0xF8,0x1C,0x70,0xC0,0x71,0x69,
		9662	0xE2,0x03,0xF5,0x01,0x07,0x70,0x70,0x4D,
		9663	0xC3,0x1D,0x70,0xC0,0x71,0x16,0x60,0xFF,
		9664	0xFF,0xC3,0x0D,0x2C,0x49,0x26,0x0E,0x23,
		9665	0x18,0x11,0x30,0x28,0x02,0x02,0xA4,0xB3,
		9666	0x80,0x0F,0x29,0x00,0x1F,0xAE,0x0C,0x0F,
		9667	0x29,0xD8,0x93,0x86,0x07,0x8E,0x1B,0x85,
		9668	0x07,0x8D,0x0B,0x30,0x68,0x7A,0xE2,0x80,
		9669	0x7F,0x4C,0xF0,0x19,0x05,0x1C,0xE3,0x06,
		9670	0xDF,0x2A,0x0C,0xFC,0xFF,0x3F,0x30,0xCC,
		9671	0xE1,0xC2,0x63,0x39,0x8A,0xA0,0x07,0x1E,
		9672	0xD4,0xF7,0x8C,0x33,0xF7,0x24,0x8F,0xD1,
		9673	0x51,0x0F,0x27,0xF4,0xE4,0x85,0x3B,0x57,
		9674	0xF9,0x0A,0x71,0x14,0x18,0xB8,0x77,0x29,
		9675	0x8F,0xCF,0x17,0x2B,0xC3,0x63,0x46,0xFB,
		9676	0x1E,0x72,0xD6,0x11,0x02,0xE2,0x2F,0x75,
		9677	0x6C,0xC0,0x60,0x39,0x18,0x00,0x87,0x01,
		9678	0xE3,0x13,0x0D,0x58,0x67,0x1B,0x3C,0xF4,
		9679	0x69,0x31,0xC4,0xE3,0x0B,0xFB,0x56,0x61,
		9680	0x82,0xEA,0x41,0x75,0x12,0xF4,0xD0,0xC0,
		9681	0x01,0xE8,0xA1,0xC1,0x3F,0xB9,0x90,0xFB,
		9682	0x2B,0x1D,0x82,0xB5,0xE2,0x69,0xDE,0x47,
		9683	0x1E,0xF3,0xDC,0xA2,0xBC,0x0D,0x3C,0x07,
		9684	0xF0,0xD3,0x82,0x87,0xE3,0x63,0x81,0xC7,
		9685	0xE9,0x4B,0x58,0x82,0xF7,0x1A,0x9F,0x6C,
		9686	0x1E,0x5C,0x58,0xB2,0x21,0xA0,0x06,0xEB,
		9687	0x21,0x60,0xA6,0x9A,0xC0,0x49,0x46,0x80,
		9688	0xCA,0x00,0xA1,0x1B,0xCB,0xE9,0x3E,0x8B,
		9689	0x84,0x38,0xCD,0x47,0x99,0xC7,0x02,0x8F,
		9690	0xF5,0xC1,0xC0,0xFF,0x7F,0xCD,0x23,0xD4,
		9691	0x7D,0xCD,0x33,0x7B,0x3A,0xC0,0xAC,0x22,
		9692	0xDC,0x7B,0xCE,0x1B,0x86,0xD1,0x9E,0x2D,
		9693	0x7C,0xCD,0x78,0xD6,0x34,0x42,0x38,0x76,
		9694	0x83,0xF3,0x48,0x8C,0xF0,0x82,0xC0,0x4E,
		9695	0x0C,0x0F,0x30,0xC6,0x39,0x79,0xC3,0xFA,
		9696	0xC2,0xCB,0x40,0x83,0x19,0xDB,0x97,0x01,
		9697	0x36,0x2A,0xDF,0x88,0xC0,0x97,0xFC,0x62,
		9698	0x00,0x65,0x16,0xBE,0x9E,0xF8,0xA0,0xC4,
		9699	0x2E,0x06,0x2C,0xE5,0xC5,0x00,0x54,0x37,
		9700	0x0C,0x5F,0x0C,0xE0,0x5F,0x89,0x5E,0x0C,
		9701	0xC0,0x70,0x71,0xF2,0x3D,0xC0,0x1E,0xEE,
		9702	0xA3,0x74,0x9C,0xBE,0xFD,0xBD,0x19,0xF8,
		9703	0x6C,0xC0,0x60,0x3C,0xC3,0x30,0xC6,0x08,
		9704	0xE3,0x51,0x86,0x31,0xC1,0xDC,0xB7,0x03,
		9705	0xE8,0x39,0x87,0x81,0x4A,0x78,0x3B,0x80,
		9706	0x72,0x0E,0xE8,0xF2,0x68,0x42,0x4F,0x01,
		9707	0x4F,0x07,0x3E,0x29,0x1A,0xA2,0xAF,0xB1,
		9708	0x0A,0x26,0x50,0xC4,0x07,0x0D,0x3E,0xB5,
		9709	0x28,0x3E,0x15,0x78,0x2D,0xCF,0x4E,0xE1,
		9710	0xE2,0x9C,0x89,0xA7,0x6A,0x38,0x03,0xBD,
		9711	0xE6,0x86,0x63,0xFF,0x7F,0x38,0xFC,0xA9,
		9712	0xE0,0x35,0x80,0x1D,0x24,0x3D,0x2D,0x23,
		9713	0xC2,0x38,0xA4,0x3C,0x32,0xF8,0xB6,0x18,
		9714	0xC7,0x90,0x0F,0x91,0xBE,0x13,0x18,0xF2,
		9715	0x21,0xEF,0x79,0xC7,0xC0,0xAF,0x08,0x71,
		9716	0x9E,0xB2,0x7C,0x67,0xF0,0x65,0x01,0x7C,
		9717	0x91,0x2E,0x0B,0x68,0x68,0x9F,0x64,0x7C,
		9718	0x41,0x30,0xEC,0x89,0xB3,0x00,0x77,0x05,
		9719	0x50,0x81,0xFA,0xAE,0x00,0xFF,0x42,0xF0,
		9720	0xAE,0x00,0x86,0x79,0xF9,0x56,0xC0,0x35,
		9721	0x1D,0x4A,0xD0,0x67,0x12,0x5F,0x17,0x70,
		9722	0x53,0x64,0xA9,0x8E,0x0A,0xD0,0x53,0x4C,
		9723	0x02,0x75,0x47,0xF7,0x51,0x01,0xC6,0x4D,
		9724	0xD9,0x07,0x54,0x76,0x5A,0x60,0x67,0x21,
		9725	0x76,0x1D,0xC1,0x5D,0x49,0x18,0xCA,0xB3,
		9726	0x81,0x2F,0x59,0xFC,0x70,0x00,0x03,0xDC,
		9727	0xB3,0x38,0xC4,0x08,0xB1,0xD9,0x81,0xEB,
		9728	0x75,0xD2,0x70,0x2F,0x44,0xEC,0xFF,0x7F,
		9729	0x32,0x00,0xE3,0x51,0x1B,0x1C,0x27,0x9D,
		9730	0xF0,0x91,0x9E,0x59,0xF8,0x49,0x19,0x30,
		9731	0x71,0xF2,0x03,0xE3,0xC9,0x1A,0xC6,0x00,
		9732	0xB8,0xBC,0x57,0x95,0x81,0xFC,0x43,0x90,
		9733	0x20,0x18,0xD4,0x29,0x19,0x38,0x1C,0xC5,
		9734	0x70,0xA7,0x64,0x78,0x50,0xF8,0xC3,0x00,
		9735	0xE6,0x46,0xE8,0x7B,0x82,0xA1,0xDE,0x93,
		9736	0x0E,0xE3,0x91,0xD0,0x04,0x3E,0x2D,0xC3,
		9737	0xFA,0xFF,0x9F,0x96,0x81,0xD5,0xB1,0xDD,
		9738	0x43,0xF6,0x59,0x01,0x77,0x76,0x80,0x3B,
		9739	0x3D,0x7E,0x7A,0x00,0x9C,0x00,0x3D,0x3D,
		9740	0x80,0xED,0xBC,0x01,0xF7,0x40,0x80,0x38,
		9741	0xFE,0xA3,0x82,0x5F,0x59,0x28,0x1C,0x3F,
		9742	0xB6,0xF3,0x63,0x09,0xEE,0x70,0xE0,0x23,
		9743	0x83,0x0F,0x90,0xB8,0xA1,0xF8,0x50,0x81,
		9744	0x3C,0x0B,0x80,0x62,0xF4,0x6C,0x04,0xEC,
		9745	0x06,0xF3,0xD2,0x12,0xE5,0xFF,0xFF,0xDE,
		9746	0xC0,0x4E,0x29,0xB8,0x83,0x00,0xF8,0x8E,
		9747	0x01,0xE0,0x1D,0x0C,0x97,0x35,0x66,0x94,
		9748	0x10,0x18,0x8D,0x19,0x77,0x08,0xE1,0x27,
		9749	0x02,0xDC,0x98,0x3D,0x6E,0x8F,0x19,0x77,
		9750	0x9C,0xE5,0xA3,0x7A,0xCA,0x08,0xE5,0x03,
		9751	0x07,0x3B,0x67,0xBC,0x11,0xF0,0xA1,0x03,
		9752	0x8F,0x03,0x0C,0xEE,0x48,0x01,0xC6,0xCB,
		9753	0x01,0x1B,0x3B,0xB8,0x83,0x90,0x53,0x20,
		9754	0x4B,0x87,0xD1,0xD8,0x71,0xB2,0x81,0x74,
		9755	0x8C,0xF1,0x21,0xD7,0x63,0xC7,0x0D,0xD6,
		9756	0x63,0xC7,0x1D,0x5F,0xB0,0xFF,0xFF,0xE3,
		9757	0x0B,0x18,0xC6,0xC0,0xC5,0x0F,0x03,0x7D,
		9758	0xF3,0xF3,0xE8,0x0C,0xEE,0x61,0xFB,0x04,
		9759	0x13,0xE3,0xF9,0x25,0xC4,0x23,0xCC,0x8B,
		9760	0x4B,0x84,0xA3,0x08,0xF2,0xE6,0x12,0xE7,
		9761	0xD5,0x20,0xCC,0x63,0x4B,0x94,0x10,0x11,
		9762	0x0E,0x26,0xCE,0x13,0x8C,0x11,0x0E,0x3C,
		9763	0x8A,0x21,0x22,0x9C,0x40,0x88,0x93,0x3E,
		9764	0xD9,0x20,0xE1,0x63,0x84,0x8D,0xF6,0x04,
		9765	0xC3,0xC7,0xC2,0xCF,0x2B,0x1E,0x3C,0x3F,
		9766	0xAD,0xF9,0x2E,0xE8,0xC9,0x9C,0xE3,0x43,
		9767	0x96,0xA7,0xF6,0x38,0xE9,0xC3,0x2C,0x6E,
		9768	0x50,0x0F,0x8E,0xEC,0xAE,0xE3,0xE3,0x35,
		9769	0xF6,0x14,0xE4,0x21,0xF0,0x13,0x81,0x2F,
		9770	0x88,0x9E,0xAC,0xEF,0x7A,0xEC,0x5E,0x66,
		9771	0x8C,0xEA,0xA7,0x80,0x3A,0xA6,0x9C,0xC1,
		9772	0x2B,0x04,0xBB,0xE7,0xF9,0x90,0xED,0xBB,
		9773	0x24,0x1B,0x05,0xEE,0x90,0xE0,0x33,0x12,
		9774	0x3F,0x55,0x78,0x18,0x1E,0x05,0x8C,0x19,
		9775	0xBC,0x23,0x1C,0x5A,0x88,0x03,0x7E,0xDF,
		9776	0x65,0x43,0x8D,0x71,0x7A,0x3E,0x7F,0xB0,
		9777	0x41,0xC0,0x87,0x3A,0x54,0x0F,0xF3,0xA8,
		9778	0x5E,0x0A,0x19,0xCE,0xD9,0xC1,0x1D,0x04,
		9779	0xF6,0xF8,0xE1,0x41,0xF0,0x9B,0x25,0x1F,
		9780	0x04,0x3B,0xDF,0xBC,0xC1,0x19,0xE4,0xFF,
		9781	0x7F,0x0C,0xB0,0xCF,0x54,0x3E,0x9A,0x20,
		9782	0x8E,0x80,0xE8,0xF3,0x87,0xC7,0xF0,0x26,
		9783	0xC7,0x87,0x83,0x3D,0x7A,0xE0,0x4E,0x22,
		9784	0x70,0x8F,0x5D,0x07,0xED,0x6B,0x9C,0x2F,
		9785	0x5A,0x30,0xEE,0x7B,0xCF,0x22,0xE0,0xC7,
		9786	0x78,0x6C,0x01,0xC7,0xA1,0x04,0xDC,0xC1,
		9787	0x8E,0x6B,0x1C,0x42,0x51,0x60,0x74,0x28,
		9788	0xC1,0xC5,0x00,0x12,0x8C,0x63,0x9C,0xD1,
		9789	0xD0,0x97,0x48,0x1F,0xD2,0xE0,0x0C,0x1A,
		9790	0xF6,0x3C,0x9F,0x50,0xB8,0x3D,0x01,0x8A,
		9791	0x4E,0x28,0x20,0xC3,0x7D,0x06,0xC1,0x9E,
		9792	0x10,0xF8,0x19,0x84,0xFD,0xFF,0x0F,0x8E,
		9793	0x1E,0xF7,0x7B,0xA3,0x4F,0x8D,0x6C,0xEE,
		9794	0x0F,0x01,0x27,0x70,0xEE,0xEC,0xD4,0x8C,
		9795	0x3B,0x33,0x60,0xCF,0x1F,0x1E,0x02,0x3F,
		9796	0x17,0x78,0xF8,0x1E,0x02,0x7E,0xF0,0x0F,
		9797	0xCC,0x06,0x07,0xE3,0x29,0xC2,0xD7,0x0E,
		9798	0x0E,0xCE,0x4F,0x03,0x06,0xE7,0xAF,0x50,
		9799	0x9F,0xE7,0x19,0x38,0xF6,0xD4,0xEB,0x7B,
		9800	0x87,0xE7,0xEB,0x43,0x05,0xFE,0xA6,0xE7,
		9801	0x43,0x05,0x38,0x0E,0x0F,0xFC,0xB0,0xC2,
		9802	0x86,0xF0,0x28,0x80,0x3F,0xB5,0xF8,0xF8,
		9803	0x17,0xE7,0x29,0x82,0xDD,0x46,0xB0,0x87,
		9804	0x0B,0xC0,0x51,0xB4,0xB3,0x18,0x2A,0xCC,
		9805	0x59,0x8C,0xFC,0xFF,0xCF,0x51,0xA8,0xB3,
		9806	0x18,0x3D,0x5C,0x00,0x2E,0x04,0x1F,0x0F,
		9807	0x40,0x73,0x10,0x78,0x5C,0xF0,0x85,0xE0,
		9808	0x48,0x0E,0xE4,0xE9,0x00,0xF0,0x19,0x4A,
		9809	0xC3,0xA1,0x09,0x13,0x03,0x06,0x75,0x3E,
		9810	0xF0,0x09,0xC5,0xC7,0x0E,0x7E,0x36,0xF0,
		9811	0x8D,0xDC,0x43,0xE5,0xA7,0x66,0x5F,0xF2,
		9812	0x11,0xE0,0x02,0x75,0xA0,0x61,0xA0,0x46,
		9813	0xE4,0x23,0xD2,0xFF,0xFF,0xB9,0x0D,0x1B,
		9814	0x60,0x68,0xF4,0x1C,0x0E,0xE3,0x80,0xEB,
		9815	0x73,0x38,0x76,0x40,0x3E,0x87,0xC3,0x3F,
		9816	0x47,0xC3,0x1F,0x1B,0x3B,0xDD,0xF3,0x81,
		9817	0xC1,0xBA,0x7E,0x63,0x06,0x06,0xB6,0x6F,
		9818	0x91,0x07,0x06,0x1C,0x51,0xCF,0xC6,0x57,
		9819	0x08,0x0F,0x0C,0x6C,0x80,0x1E,0x18,0xF0,
		9820	0x89,0x05,0x21,0x27,0x03,0x43,0x9D,0x32,
		9821	0x8C,0x1C,0xF3,0x89,0xC3,0xC3,0xF0,0xA1,
		9822	0x22,0xEA,0x33,0xC0,0x23,0x1E,0x1B,0x1B,
		9823	0xFB,0xFF,0x8F,0x0D,0x2C,0xC7,0x16,0x8F,
		9824	0x0D,0xFC,0x47,0x78,0xFC,0xD8,0xE0,0x8C,
		9825	0xE5,0xD1,0xC4,0x97,0x99,0x23,0x3B,0x8D,
		9826	0x33,0x7B,0x0D,0xF1,0xD1,0xEE,0xF1,0xDB,
		9827	0x63,0x03,0x97,0x85,0xB1,0x01,0xA5,0x90,
		9828	0x63,0x43,0x1F,0x52,0x7C,0x0A,0xB0,0x71,
		9829	0x54,0x32,0x0F,0x1F,0xAF,0x7C,0x62,0x38,
		9830	0xBA,0x20,0x6F,0xE8,0xBE,0x5C,0xF8,0x48,
		9831	0x63,0x30,0x5F,0x5A,0x7C,0x06,0xE5,0x43,
		9832	0x04,0xD7,0x57,0xC5,0x43,0x04,0x3E,0xA1,
		9833	0x86,0x88,0x1E,0xCF,0xFF,0xFF,0x11,0xCC,
		9834	0x43,0x64,0x43,0x03,0xAF,0x87,0xA1,0x01,
		9835	0xA5,0x98,0xC0,0x5E,0x85,0x87,0x46,0x4F,
		9836	0x3F,0x3E,0x04,0x30,0x08,0xDF,0x06,0xD8,
		9837	0x55,0xC0,0x57,0x21,0x83,0x24,0x18,0xE7,
		9838	0x64,0x41,0x07,0x07,0x8E,0x21,0x79,0x70,
		9839	0xF0,0x07,0xE3,0x21,0x70,0x60,0xCF,0xE0,
		9840	0xB9,0xE8,0x31,0xD8,0xA7,0x1D,0x9F,0x4A,
		9841	0xC0,0x77,0xE6,0x04,0xC7,0xE9,0x1D,0x7B,
		9842	0x29,0xF0,0x08,0x1E,0xAD,0x3C,0x02,0x7E,
		9843	0xB4,0x02,0x66,0xFF,0xFF,0xA3,0x15,0x30,
		9844	0x09,0x7A,0xE6,0xA4,0x03,0x77,0x34,0x18,
		9845	0xD4,0xD1,0x0A,0x5C,0x11,0xC0,0x75,0xDC,
		9846	0xF0,0xD1,0x02,0xCE,0x50,0x0F,0xDA,0x07,
		9847	0x65,0xCF,0xDA,0x97,0x21,0x76,0xB4,0x00,
		9848	0x97,0x89,0x43,0x08,0xD0,0x04,0x3E,0x89,
		9849	0x67,0xEF,0x43,0x03,0xB3,0x8A,0xA1,0x01,
		9850	0xA5,0xA3,0x01,0xEE,0x44,0x81,0xFD,0xFF,
		9851	0x9F,0x28,0x60,0xDE,0x30,0x70,0x07,0x0A,
		9852	0xC0,0xCD,0xE9,0xDB,0xE3,0xE2,0xD0,0x38,
		9853	0xC4,0xE7,0xA7,0x73,0xF6,0xD1,0xE8,0x4C,
		9854	0x71,0x67,0x11,0x30,0x9C,0x7D,0x11,0x8F,
		9855	0x18,0x03,0xF9,0x81,0x21,0x59,0x30,0x28,
		9856	0x16,0x0F,0xC5,0x07,0x03,0x0E,0xEC,0x23,
		9857	0x02,0x3B,0x17,0xB0,0x73,0xAD,0xE1,0xF8,
		9858	0x59,0xC0,0xA7,0x84,0xB7,0xA6,0x17,0x7B,
		9859	0x9F,0xD7,0x7D,0xD6,0x08,0xC9,0xCE,0xF4,
		9860	0x3E,0x89,0xE2,0x0E,0xA2,0x70,0x4E,0x9F,
		9861	0xE0,0x22,0xF0,0x65,0xDF,0xA3,0xE0,0xA7,
		9862	0x07,0xCF,0xF1,0x8D,0xC1,0xA7,0x07,0xE6,
		9863	0x7E,0xF8,0x9A,0xF1,0x33,0xC3,0xE3,0x43,
		9864	0x88,0x27,0xE2,0xDA,0xA6,0x20,0x5B,0x18,
		9865	0x42,0x09,0xF4,0xFF,0x8F,0x10,0xE5,0x6D,
		9866	0x20,0xCA,0x29,0x44,0x88,0x12,0xA4,0xB1,
		9867	0xC9,0x0B,0x35,0xCA,0xD9,0x45,0x6E,0x6D,
		9868	0xF6,0x82,0x0B,0x14,0x2A,0x66,0x9C,0x28,
		9869	0xEF,0x10,0xB1,0xDA,0x1F,0x04,0x91,0xF4,
		9870	0x32,0xD0,0x71,0xC9,0x91,0x0E,0x7D,0xE8,
		9871	0x61,0xFB,0x04,0x8C,0x3F,0x48,0xE2,0xAE,
		9872	0x2A,0x3E,0x28,0xF8,0x00,0x80,0x77,0x09,
		9873	0xA8,0x5B,0x9D,0xC7,0xED,0xF3,0x06,0xF8,
		9874	0xAF,0x17,0x58,0x82,0xF2,0x07,0x81,0x1A,
		9875	0x99,0xA1,0x3D,0xCC,0xB7,0x19,0x43,0xBE,
		9876	0x07,0x1C,0x16,0x3B,0x27,0xF9,0xF0,0x08,
		9877	0x1C,0x8E,0x01,0x4F,0x1B,0xBE,0x51,0x7B,
		9878	0xBE,0x3E,0x62,0x01,0x8E,0xFE,0xFF,0x47,
		9879	0x2C,0x30,0x9D,0xDF,0x7D,0x82,0x01,0xC7,
		9880	0xCD,0x82,0x9F,0x61,0x00,0x67,0x40,0xCF,
		9881	0x30,0x60,0x1F,0x2A,0x6E,0x08,0x5C,0xEE,
		9882	0x8A,0x28,0x90,0x05,0xC2,0xA0,0x0E,0xFD,
		9883	0xE4,0x08,0x42,0xCF,0x9C,0x70,0x86,0x72,
		9884	0xB2,0xBD,0x5F,0x1D,0xC8,0x2D,0xC2,0x43,
		9885	0x3D,0x8B,0xC7,0x04,0x76,0xDA,0x02,0x36,
		9886	0xFF,0xFF,0xE3,0x29,0xB0,0x98,0xF7,0xD3,
		9887	0x69,0x84,0x63,0x03,0xFB,0x71,0x0B,0x38,
		9888	0x1D,0xCC,0xE0,0xDC,0x7F,0xD8,0x2D,0x1A,
		9889	0x37,0x34,0xB0,0x0D,0xCC,0x43,0x03,0x3E,
		9890	0x27,0x47,0x30,0x9E,0x98,0xF8,0x55,0xE2,
		9891	0xE1,0x89,0x1F,0x43,0xC0,0xFA,0xFF,0x3F,
		9892	0x99,0x01,0xF6,0x84,0x1E,0xCB,0x50,0xD2,
		9893	0x4E,0x66,0x80,0xC0,0xFB,0xD8,0x3B,0xC3,
		9894	0x4B,0x83,0xE7,0x74,0xD2,0xCF,0x62,0x3E,
		9895	0x99,0x19,0x21,0x0A,0xBB,0x8F,0x19,0xAD,
		9896	0x37,0x14,0xCD,0x3C,0xE8,0x3B,0x99,0x51,
		9897	0x62,0x46,0x6A,0x0E,0x4C,0x48,0x11,0x0F,
		9898	0x27,0x4A,0x88,0x60,0xAF,0x13,0x6F,0x67,
		9899	0x4F,0x66,0x4C,0xD6,0xC9,0x0C,0x24,0xFF,
		9900	0xFF,0x93,0x19,0x98,0x5C,0x9F,0xCC,0x80,
		9901	0xCA,0x39,0x0A,0x7F,0x32,0x03,0x78,0x74,
		9902	0xC0,0xC2,0x9D,0xCC,0xC0,0xF2,0xFF,0x3F,
		9903	0xC4,0x00,0xCE,0xC7,0x0A,0x63,0x0C,0x3C,
		9904	0xDA,0xC1,0x0C,0x15,0xE6,0x6C,0x86,0x0E,
		9905	0x72,0x08,0xA1,0xC1,0x0E,0x21,0x50,0xE6,
		9906	0x72,0xA0,0xA7,0xF0,0x9A,0xE0,0x73,0x14,
		9907	0xD8,0x0F,0x67,0xC0,0xE1,0xD4,0x80,0x0F,
		9908	0x74,0xE2,0x42,0x8F,0xC2,0x23,0x0E,0x58,
		9909	0xFD,0xC0,0xC8,0xFF,0xFF,0x64,0x06,0x18,
		9910	0x78,0x6A,0xF8,0x40,0x82,0x63,0x31,0xEA,
		9911	0x1B,0xC4,0x21,0xBE,0x8D,0xF8,0xE8,0xFE,
		9912	0x6A,0xE2,0x4B,0x00,0xE6,0x42,0xE2,0xD3,
		9913	0x09,0xB3,0x70,0x38,0x03,0x5A,0x43,0x60,
		9914	0x57,0x26,0xCF,0x9C,0x0F,0xE1,0x6C,0x3C,
		9915	0x7A,0xDC,0xE9,0x04,0xDE,0x38,0x7C,0x3A,
		9916	0x01,0x5E,0x07,0x0C,0xCC,0x0C,0xC2,0x3F,
		9917	0x84,0xB0,0x21,0x9C,0xAA,0xC7,0x70,0xEE,
		9918	0xAF,0x38,0x3E,0x9D,0x80,0xF3,0xFF,0x7F,
		9919	0x62,0x03,0x0C,0x0A,0x7E,0x32,0xF8,0xB8,
		9920	0x46,0x25,0xC2,0xA0,0x8E,0xE6,0x80,0x7B,
		9921	0x98,0x27,0x36,0x26,0x6F,0xC5,0x1A,0x8B,
		9922	0x4F,0x6C,0x30,0xFF,0xFF,0x27,0x36,0x80,
		9923	0xD1,0x87,0x20,0xB0,0xFD,0xFF,0x0F,0x41,
		9924	0x60,0x1C,0xA0,0x0F,0x41,0x80,0x9B,0xD3,
		9925	0x09,0xEE,0xC4,0x07,0xB6,0x63,0x10,0x60,
		9926	0x6D,0xE8,0x3E,0x06,0x81,0xF9,0xFF,0x3F,
		9927	0x5A,0x98,0xA3,0xE0,0xC2,0x8E,0x7C,0x28,
		9928	0x29,0xA7,0x3E,0xB4,0x0C,0x20,0x69,0x38,
		9929	0xC9,0x01,0x9D,0xD3,0x3D,0x70,0x92,0x75,
		9930	0xEA,0x40,0x8F,0xC7,0xA0,0xAF,0x1C,0xBE,
		9931	0x12,0xF0,0x23,0x07,0x93,0x00,0xAA,0x41,
		9932	0xFA,0xCC,0x07,0x9C,0x8E,0x1C,0xE0,0x38,
		9933	0x26,0x05,0xC6,0xDE,0x0E,0xDE,0x22,0x3D,
		9934	0x89,0xA7,0xA1,0xE3,0x0C,0x51,0x38,0x26,
		9935	0x39,0x18,0x44,0x7A,0x95,0x62,0x03,0x7C,
		9936	0xAB,0xF1,0xD9,0xC8,0x07,0x10,0x78,0xE3,
		9937	0xF6,0xD8,0x61,0xFF,0xFF,0x0F,0x75,0xC0,
		9938	0x01,0xE2,0xA4,0xF8,0x21,0xC3,0x98,0x67,
		9939	0xC5,0x0F,0x75,0x80,0xF5,0x18,0x27,0x3A,
		9940	0x94,0xF0,0x43,0x1D,0x20,0xE8,0xFF,0x7F,
		9941	0xA8,0x03,0x86,0x38,0x6F,0x24,0xD1,0x1E,
		9942	0xEA,0x98,0xE8,0x43,0x1D,0x40,0xC8,0xFF,
		9943	0xFF,0xA1,0x0E,0x18,0x9E,0x87,0x00,0xAE,
		9944	0x9C,0xEF,0xC0,0x7C,0x22,0x02,0xEF,0xFF,
		9945	0xFF,0x7C,0x07,0xB8,0x1B,0x2D,0xCC,0x51,
		9946	0x70,0x41,0xAF,0x0E,0x03,0x51,0x09,0x30,
		9947	0x28,0x02,0xC7,0x5F,0x9B,0x60,0x1C,0xEA,
		9948	0x7C,0x87,0x3E,0x2F,0x78,0xD8,0x4F,0x05,
		9949	0x9E,0xC4,0xA9,0xFA,0x5A,0x70,0x14,0x4F,
		9950	0x00,0x3E,0xE1,0x01,0xFF,0xA1,0xC1,0x9A,
		9951	0x44,0xF1,0x43,0x03,0xF5,0x11,0xE4,0xFF,
		9952	0x7F,0x68,0xC0,0x28,0xEA,0xF9,0x06,0x7D,
		9953	0xCC,0xF2,0xD9,0x20,0xE6,0x0B,0x48,0x84,
		9954	0x07,0x10,0x5F,0x1F,0xD8,0x71,0xD2,0x67,
		9955	0xA0,0x40,0x51,0xDE,0x37,0xF8,0x09,0x07,
		9956	0x5C,0x83,0xF3,0x09,0x07,0xBC,0x87,0x23,
		9957	0x1F,0x4B,0xC0,0x77,0xD0,0x84,0x73,0x81,
		9958	0xF1,0x8D,0x8D,0x9D,0x06,0xC0,0x76,0x00,
		9959	0x06,0xDF,0x69,0x00,0x1C,0xC7,0x24,0x7E,
		9960	0x3A,0x04,0x13,0xCC,0xC1,0xBC,0x34,0xFB,
		9961	0xFF,0xEF,0xFD,0x94,0x43,0xCF,0x86,0x80,
		9962	0x75,0x49,0x07,0x43,0x94,0x88,0xB3,0x21,
		9963	0x20,0xFD,0xFF,0x7F,0x36,0xC4,0x20,0xC4,
		9964	0x09,0xFC,0x12,0xD1,0xDC,0xD9,0x90,0xAE,
		9965	0xD8,0x67,0x43,0x80,0xE1,0xFF,0xFF,0x23,
		9966	0x00,0xF6,0x7C,0x04,0x38,0x3D,0x64,0x83,
		9967	0xE7,0x14,0x08,0xE3,0xE4,0x03,0x38,0xFE,
		9968	0xFF,0x8F,0x15,0xE6,0x18,0x78,0xEA,0x97,
		9969	0x9B,0x8F,0x03,0x54,0xD4,0x2B,0xC2,0x30,
		9970	0x94,0xC5,0x87,0x05,0x1F,0x11,0xF8,0x61,
		9971	0xC1,0x23,0xA8,0x78,0x9C,0xF4,0x74,0xE3,
		9972	0x33,0x21,0x3B,0x24,0x38,0xFC,0x20,0xE9,
		9973	0x41,0x13,0x3C,0xE7,0x23,0x78,0xB7,0x1E,
		9974	0x38,0xA7,0x02,0xC0,0x4D,0xAE,0x27,0xA3,
		9975	0x4E,0x17,0x0E,0x70,0x8E,0x92,0x8D,0x63,
		9976	0x08,0xE5,0x70,0xCC,0xB7,0x87,0xA6,0xC9,
		9977	0x4E,0x56,0x30,0x63,0x41,0xEA,0x24,0xE0,
		9978	0x01,0x38,0x10,0x8C,0xB4,0x93,0x68,0x34,
		9979	0x86,0xB3,0x5A,0x18,0xC1,0x19,0xC4,0xC7,
		9980	0x11,0xE7,0x3A,0x19,0xA1,0x3F,0x07,0x3E,
		9981	0x15,0x61,0x82,0xDC,0x4B,0xE8,0xBC,0x7D,
		9982	0x37,0xE0,0x57,0x61,0x8F,0xC5,0xFF,0x7F,
		9983	0x60,0xDF,0x4E,0xC0,0x31,0x17,0xAB,0x01,
		9984	0x45,0x0D,0xC0,0x68,0x98,0x53,0xC0,0x53,
		9985	0x09,0xB8,0x82,0xCD,0x0D,0x7D,0x61,0xB1,
		9986	0xD6,0xA9,0xE8,0x14,0xF4,0x3E,0x70,0x70,
		9987	0xC0,0x63,0xF6,0x1E,0x1C,0x2C,0x34,0x0F,
		9988	0x0E,0x6C,0xD9,0x06,0x87,0x56,0x72,0x17,
		9989	0x21,0x87,0x0F,0xFC,0xEC,0x80,0x03,0xA0,
		9990	0x67,0x07,0x0B,0xC9,0xB3,0x03,0x9B,0xBE,
		9991	0xB3,0x08,0x28,0x70,0xFE,0xFF,0x11,0xDE,
		9992	0x3B,0x7C,0x6E,0x79,0xF6,0x60,0x63,0x78,
		9993	0x74,0x31,0x9A,0xD1,0xB9,0xA6,0xDB,0x04,
		9994	0x4A,0xC5,0x6D,0x82,0x82,0xF8,0x06,0xE0,
		9995	0x84,0x34,0xBA,0x75,0xE2,0x66,0x62,0xFC,
		9996	0x47,0x0C,0x1F,0x11,0x0E,0xE9,0x6C,0x4D,
		9997	0x30,0x0F,0xA4,0x9E,0x81,0xBE,0xB3,0xE1,
		9998	0x67,0x1F,0xF2,0xC1,0xC5,0xD3,0xF0,0xF5,
		9999	0x86,0xDC,0x3B,0xE8,0xB4,0x7D,0x66,0xC0,
		10000	0x1C,0x74,0x7D,0x9D,0x7A,0x83,0x27,0x57,
		10001	0x09,0xEA,0xE1,0x02,0x42,0x2F,0x34,0xBE,
		10002	0xDC,0x25,0x78,0xE0,0xF4,0xE9,0xEE,0xBD,
		10003	0x84,0x9D,0xF1,0x12,0xBC,0xE0,0x25,0x98,
		10004	0x77,0x10,0xA8,0x51,0x79,0x10,0x98,0xAB,
		10005	0x3C,0xCB,0x37,0x06,0x54,0xB2,0x8B,0x16,
		10006	0x3D,0xC3,0xBC,0xC3,0xF8,0x92,0xE0,0xEB,
		10007	0x87,0xCF,0x2D,0x5E,0xC0,0xEB,0x16,0x0C,
		10008	0x82,0x67,0xA0,0x57,0x17,0xDF,0xD9,0x0D,
		10009	0xFC,0x2A,0xF0,0x46,0x13,0x22,0x98,0x61,
		10010	0x0F,0xFF,0xDD,0xDD,0xA8,0xBE,0xE9,0x18,
		10011	0xEB,0x75,0xC4,0x23,0xE5,0xC7,0x96,0x03,
		10012	0x8A,0xF4,0xF2,0xE6,0x09,0xF8,0x2C,0xE3,
		10013	0x53,0xDD,0x49,0xF9,0x7A,0x68,0xF4,0x57,
		10014	0x08,0x1F,0x7E,0x8C,0xEC,0x73,0x0E,0x3B,
		10015	0xDF,0xB1,0x41,0x71,0xC4,0x07,0x86,0x97,
		10016	0x1A,0x4F,0x85,0x9D,0xBB,0x60,0x1C,0x1C,
		10017	0xD8,0xB1,0x08,0x73,0x7C,0x05,0xD7,0xC9,
		10018	0xE6,0xFF,0xFF,0xE4,0x00,0x6E,0x78,0xCC,
		10019	0xC1,0xD7,0xE7,0x0D,0xDF,0x0C,0x3C,0x2E,
		10020	0x7E,0xE4,0xF0,0x49,0xE3,0xA5,0xD3,0xD8,
		10021	0xA7,0xE9,0xA3,0xD1,0xCB,0x9B,0x4F,0x2F,
		10022	0x18,0x58,0x5F,0x1A,0x38,0xAC,0xD1,0xC2,
		10023	0x3E,0x06,0x9C,0xB9,0x2F,0x44,0xB8,0xC3,
		10024	0x23,0x58,0x00,0xF1,0xB7,0x92,0x47,0x0E,
		10025	0x4F,0xC0,0x80,0x4C,0xD3,0xBA,0x74,0x20,
		10026	0xE2,0xA7,0x3C,0x2B,0x5F,0x99,0x2E,0x43,
		10027	0x0C,0xE3,0xA9,0xF2,0xF1,0xC3,0xB3,0xF1,
		10028	0x51,0xC0,0xC7,0x28,0xCF,0xFC,0x8C,0x22,
		10029	0xBD,0x32,0x10,0x50,0x9D,0x88,0xB8,0x42,
		10030	0x18,0x89,0xA1,0xD1,0x9D,0x83,0xC7,0x1F,
		10031	0x22,0x05,0x31,0xA0,0x6F,0x2E,0xC0,0xF4,
		10032	0x4C,0x04,0x5C,0xFE,0xFF,0x37,0x17,0x80,
		10033	0xFF,0xFF,0xFF,0x9B,0x0B,0xE0,0xE6,0xFE,
		10034	0xE0,0x9B,0x0B,0x70,0x8D,0xB4,0x2A,0x7A,
		10035	0x61,0x77,0x08,0x18,0xD4,0x9D,0x1D,0x70,
		10036	0x78,0x2B,0x78,0x67,0x87,0xF5,0xFF,0xBF,
		10037	0xB3,0xC3,0xC3,0x8C,0x13,0xE5,0x85,0x21,
		10038	0xC6,0x3B,0x3B,0x0B,0xF0,0x26,0xD0,0x51,
		10039	0xC6,0x77,0x76,0x80,0x1F,0x67,0xD8,0x77,
		10040	0x69,0xF0,0x5E,0x75,0x81,0xF5,0xFF,0xFF,
		10041	0xAA,0x0B,0x3C,0x04,0xDF,0xA7,0x41,0x3E,
		10042	0x5E,0x30,0x8C,0x83,0x2B,0x27,0xA1,0xC7,
		10043	0x02,0x6B,0x85,0x41,0xDD,0xA9,0xC1,0xA5,
		10044	0x09,0x5C,0x17,0x5F,0x1F,0x6A,0x7C,0xA4,
		10045	0xC5,0x9F,0x2F,0x70,0x01,0x86,0x4C,0x4F,
		10046	0x65,0x30,0xAE,0x29,0x3E,0x95,0x61,0xEE,
		10047	0x0E,0x1E,0x90,0x8F,0x18,0xC0,0x67,0x15,
		10048	0x1E,0x18,0xEE,0xB4,0xE0,0x9B,0x92,0x41,
		10049	0xCF,0x31,0xA8,0x8F,0x3C,0x27,0xEF,0x7B,
		10050	0xC2,0xE3,0x84,0xA3,0x9E,0x83,0xE8,0xD8,
		10051	0xC0,0x71,0xDC,0xC0,0xFD,0xFF,0xC7,0x06,
		10052	0xEF,0x70,0x83,0x3B,0xE8,0xF8,0x62,0x70,
		10053	0x5C,0x18,0xB8,0xE7,0x02,0x0F,0xC3,0x37,
		10054	0x1D,0x8F,0x08,0x33,0xFE,0xD7,0x3F,0x23,
		10055	0x04,0xC4,0x5F,0x8C,0xD8,0x80,0xC1,0x78,
		10056	0x6B,0xF3,0xF5,0x0D,0x37,0x60,0x5F,0x1D,
		10057	0x7C,0xC1,0xF0,0x09,0xCC,0xE8,0x2F,0x30,
		10058	0x4F,0x62,0x3E,0x36,0x90,0x0B,0x1C,0x1D,
		10059	0x30,0x38,0x00,0x3D,0x60,0xF8,0x87,0x8B,
		10060	0x77,0x39,0x30,0x5C,0x05,0x7D,0x5C,0xF0,
		10061	0xB1,0xC7,0x8A,0xEE,0x72,0xE8,0x9B,0x9C,
		10062	0x61,0xE2,0x18,0xE2,0x0D,0x8C,0xDD,0x25,
		10063	0xC8,0x61,0x0E,0xEA,0x5D,0xC2,0x73,0xE0,
		10064	0x67,0x0B,0x9F,0xE0,0x7C,0xF3,0x09,0x71,
		10065	0xAA,0x8F,0x56,0xEF,0x01,0x3E,0x7A,0xBC,
		10066	0x77,0xF9,0xEC,0xC4,0x2E,0x02,0x3E,0x72,
		10067	0x19,0xC7,0xD3,0xF4,0x15,0xD0,0x43,0x36,
		10068	0xD8,0xAB,0x86,0x4F,0x60,0x3E,0xBA,0xE1,
		10069	0x8E,0x51,0x9E,0x89,0xA7,0xEF,0x3B,0x08,
		10070	0x3B,0x92,0x1C,0x75,0xA8,0x6B,0x7A,0x44,
		10071	0xF9,0xFF,0x9F,0xD0,0x81,0xF8,0xD6,0x06,
		10072	0xCE,0x68,0xF7,0x0F,0xF4,0x36,0x3D,0x32,
		10073	0xCC,0xD1,0x00,0xD6,0x25,0x04,0x5C,0x77,
		10074	0x0C,0x5F,0x42,0x80,0x4F,0xD0,0x4B,0x04,
		10075	0xFA,0x9A,0xE1,0xD1,0x3D,0x02,0x60,0xAE,
		10076	0x18,0xEC,0x58,0xE0,0xC3,0x86,0xAF,0x01,
		10077	0xEC,0x5E,0xE0,0x30,0xF7,0x08,0x50,0x81,
		10078	0x7A,0x78,0xF0,0xD5,0xDE,0x23,0x40,0x71,
		10079	0xB2,0xF4,0xA1,0xC1,0x03,0xB5,0xAA,0x33,
		10080	0x26,0x94,0x23,0x26,0x3F,0x9B,0xF9,0x26,
		10081	0x81,0xB9,0x5D,0xFA,0x26,0x01,0x37,0xCF,
		10082	0x2C,0x50,0x49,0x20,0xF4,0xFF,0xBF,0x49,
		10083	0xC0,0x85,0xE9,0xF2,0x32,0x43,0xE7,0x7F,
		10084	0xE0,0xBE,0xD5,0x79,0x84,0x3E,0x44,0x30,
		10085	0x94,0xF7,0x3C,0x9F,0xC2,0xF8,0x19,0xC2,
		10086	0x07,0x4C,0x76,0xA6,0xE0,0x67,0x4D,0xDC,
		10087	0x1D,0xC0,0x28,0x6F,0x9E,0x9E,0x00,0x3B,
		10088	0x7F,0x1A,0xF9,0xDD,0xE0,0x5D,0xC0,0xD3,
		10089	0xF7,0xBD,0x88,0x9F,0x28,0xC0,0x17,0xEC,
		10090	0x4E,0x07,0x05,0xFA,0x84,0x3C,0x22,0xA3,
		10091	0xFA,0x88,0xC0,0x2F,0x49,0x60,0x3C,0x92,
		10092	0xF8,0x40,0x01,0x84,0xEE,0x05,0xA8,0xD3,
		10093	0x07,0x47,0x3D,0xE3,0x17,0x54,0x63,0xBE,
		10094	0x5B,0x3D,0xC2,0x79,0x72,0x98,0xCB,0x01,
		10095	0x8B,0x73,0x4D,0x02,0xD5,0x71,0x97,0x8F,
		10096	0x0E,0xEE,0xB5,0x15,0xFB,0xFF,0x27,0x38,
		10097	0xB8,0x77,0x96,0x77,0x3E,0x43,0x79,0x90,
		10098	0xE0,0xBB,0xB6,0x82,0xE3,0xAA,0x06,0xE3,
		10099	0xD8,0xC2,0x2F,0x79,0x80,0x9D,0x61,0x71,
		10100	0xC1,0x7F,0x0F,0x03,0x51,0x89,0x30,0x28,
		10101	0x02,0xCB,0xBB,0xB7,0x52,0xF8,0x43,0x06,
		10102	0xE3,0x4D,0x81,0x4F,0x1A,0x3B,0x6A,0xE0,
		10103	0xFB,0xFF,0x1F,0x35,0xD8,0x86,0x8A,0xBB,
		10104	0x29,0x82,0x75,0xAA,0x98,0x21,0xF0,0x60,
		10105	0x0F,0x00,0x9F,0xAF,0x7C,0x06,0x50,0x14,
		10106	0x18,0xD4,0xA1,0x1D,0xCE,0x6D,0x18,0x70,
		10107	0x30,0x62,0xDC,0xA5,0x10,0xEE,0x94,0xDF,
		10108	0x51,0x62,0x3F,0x97,0xB3,0xE9,0xE2,0xAE,
		10109	0xE6,0x3E,0x9D,0xB0,0x0B,0x32,0x8C,0xB3,
		10110	0xC0,0x23,0xC0,0xAB,0x39,0xBF,0x20,0x3F,
		10111	0x17,0xBF,0x10,0x3C,0x26,0x85,0x78,0x53,
		10112	0x7A,0x25,0x36,0xC6,0x93,0x71,0x73,0xB7,
		10113	0x62,0x72,0xDE,0x79,0x41,0x36,0xC6,0xD1,
		10114	0x44,0x8C,0x72,0x6E,0x0F,0x03,0x91,0x5F,
		10115	0x90,0x7D,0x3F,0x79,0x21,0x88,0x18,0xCD,
		10116	0x10,0x41,0x9F,0x97,0x8D,0x15,0x28,0xDE,
		10117	0x0B,0x32,0x13,0xF8,0x56,0xD0,0xC1,0xC5,
		10118	0x17,0x64,0xEC,0xFF,0xFF,0x82,0x0C,0x30,
		10119	0xE2,0x64,0x04,0xF8,0x3C,0x71,0xE0,0xCE,
		10120	0x35,0x30,0xFE,0xFF,0x97,0x6A,0xD8,0x27,
		10121	0x1B,0xC0,0xD9,0xD0,0x7D,0xB2,0x01,0xF7,
		10122	0x68,0xE1,0x1D,0x4D,0x10,0x27,0x1B,0x0A,
		10123	0xE4,0xE0,0xEB,0xA2,0x70,0x3C,0xF4,0x49,
		10124	0x84,0x1E,0x9D,0x7C,0x94,0xC4,0x9D,0x19,
		10125	0x3C,0x91,0x77,0x16,0x8F,0xE2,0x65,0xD0,
		10126	0xF7,0x82,0x13,0x79,0x7D,0xB0,0x9C,0x63,
		10127	0x24,0xA8,0x46,0xE2,0xE3,0x03,0xFC,0xEB,
		10128	0x8B,0x8F,0x91,0xF0,0xF9,0xFC,0xC3,0xF2,
		10129	0x60,0x0C,0xF9,0xFF,0x7F,0x8A,0xC4,0x80,
		10130	0x3C,0xBB,0x3C,0x86,0xF0,0x0B,0x24,0xDC,
		10131	0xD3,0xCC,0x01,0x60,0x64,0x5D,0x1E,0xD1,
		10132	0x67,0x47,0x8E,0x11,0xD7,0x17,0x45,0x5F,
		10133	0x81,0x7D,0x10,0x38,0x9F,0xE7,0x44,0xB0,
		10134	0x8E,0x9A,0x1F,0x6D,0xF8,0xF8,0x39,0xF8,
		10135	0x5B,0xC1,0x03,0xA5,0x8F,0x45,0x21,0x1E,
		10136	0x91,0xF8,0x39,0x11,0x5C,0x26,0xCE,0x89,
		10137	0x40,0xE2,0xD0,0x0B,0xE3,0xB4,0x80,0x1B,
		10138	0x88,0xCF,0x94,0xD8,0x29,0x9F,0x08,0x3B,
		10139	0x97,0x60,0x46,0x07,0xAE,0xCB,0xBD,0x47,
		10140	0x07,0xFE,0x93,0x00,0x1E,0xEB,0xFF,0xFF,
		10141	0x78,0x07,0xBE,0x93,0xBA,0xEF,0x26,0xBE,
		10142	0xC8,0xF8,0x50,0xF4,0x7C,0x07,0xF8,0x0F,
		10143	0x77,0xB8,0x43,0xC5,0x39,0xDF,0x01,0xD2,
		10144	0xFE,0xFF,0xE7,0x3B,0x60,0x79,0xB6,0x7E,
		10145	0xBE,0x03,0xBB,0xC8,0xF3,0x1D,0x40,0xAC,
		10146	0xFF,0xFF,0xF9,0x0E,0xB0,0x73,0x46,0xC3,
		10147	0x9D,0xEF,0xC0,0x76,0xB4,0x01,0xCC,0x4D,
		10148	0xE3,0xD1,0x06,0xDC,0xC3,0x85,0x3D,0x0C,
		10149	0xAE,0xD0,0xA6,0x4F,0x8D,0x46,0xAD,0x1A,
		10150	0x94,0xA9,0x51,0xE6,0xFF,0xDF,0xA0,0x56,
		10151	0x9F,0x4A,0x8D,0x19,0xCB,0x0E,0xA5,0x80,
		10152	0x8F,0x0A,0x8D,0xCD,0xF2,0x28,0x04,0x62,
		10153	0x31,0xAF,0x06,0x81,0x38,0x2C,0x08,0x8D,
		10154	0xF4,0xCA,0x11,0x88,0x25,0x3F,0xFB,0x05,
		10155	0x62,0xB9,0x6F,0x06,0x81,0x38,0xE0,0x1B,
		10156	0x4C,0xE0,0xE4,0x61,0x25,0x70,0xF2,0x6E,
		10157	0x10,0x88,0x23,0x83,0x50,0xA1,0x3A,0x40,
		10158	0x58,0x4C,0x10,0x1A,0xCA,0x07,0x08,0x93,
		10159	0xFE,0x48,0x10,0x20,0x31,0x02,0xC2,0xC2,
		10160	0xBD,0xBF,0x04,0x62,0x69,0xEF,0x09,0x81,
		10161	0x58,0x88,0x15,0x10,0x16,0x17,0x84,0x86,
		10162	0xD3,0x02,0xC2,0x24,0x99,0x01,0x61,0x81,
		10163	0x40,0xA8,0x7C,0x35,0x20,0x4C,0xA4,0x1B,
		10164	0x40,0xBA,0x7A,0x81,0x38,0x88,0x1E,0x10,
		10165	0x26,0xC3,0x0F,0x08,0x0B,0x0D,0x42,0xA3,
		10166	0x3D,0x30,0x04,0x48,0x0C,0x81,0xB0,0xF8,
		10167	0x8E,0x40,0x98,0xF8,0x57,0x91,0x40,0x9C,
		10168	0xDF,0x12,0xC4,0x4D,0x69,0x88,0x35,0x01,
		10169	0x31,0x0D,0x9E,0x80,0x98,0x22,0x10,0x01,
		10170	0x39,0xF6,0xD3,0x43,0x40,0xD6,0x60,0x0A,
		10171	0x88,0x45,0x07,0x11,0x90,0x85,0xA8,0x02,
		10172	0x62,0x79,0x5D,0x01,0xB1,0xF0,0x20,0x02,
		10173	0x72,0xE6,0x97,0x9F,0x80,0xAC,0xE0,0xA5,
		10174	0xF3,0x10,0xC0,0xDE,0x10,0x81,0x48,0x72,
		10175	0x10,0x01,0x39,0xB0,0x2F,0x20,0x16,0x1F,
		10176	0x44,0x40,0xCE,0xFA,0x28,0x14,0x90,0x83,
		10177	0x83,0x68,0x10,0xE4,0x6B,0x26,0x20,0xA7,
		10178	0x07,0x11,0x10,0xF9,0x04,0x05,0x21,0x6A,
		10179	0xBD,0x81,0x30,0x3D,0x8F,0x42,0x0D,0x85,
		10180	0x80,0x50,0xE5,0xEA,0xCE,0x31,0x2C,0x07,
		10181	0x08,0xCD,0x05,0x22,0x30,0xAB,0x70,0x07,
		10182	0xC4,0x54,0x81,0x08,0xC8,0x09,0x80,0xC8,
		10183	0xFF,0x9F,0x60,0x2A,0x10,0x9A,0x12,0x8C,
		10184	0xEA,0x92,0x07,0xC4,0x12,0x80,0xD0,0x54,
		10185	0x20,0x34,0x25,0x88,0x00,0xAD,0xCA,0x1E,
		10186	0x10,0x53,0x0A,0x42,0x95,0x83,0xD0,0x74,
		10187	0x20,0x54,0xB6,0xBE,0xC3,0x02,0x05,0x11,
		10188	0x90,0xA3,0x83,0x50,0xE1,0xFE,0x40,0x98,
		10189	0xDE,0x97,0x86,0x00,0x9D,0x0E,0x44,0x40,
		10190	0x4E,0x0C,0x42,0x15,0x7C,0x32,0x82,0x10,
		10191	0xB1,0x20,0x54,0xC1,0x27,0x23,0x28,0xD1,
		10192	0xF2,0xB2,0x13,0x90,0xF5,0x81,0x50,0xBD,
		10193	0x20,0x02,0x73,0x36,0x20,0x9A,0x17,0x84,
		10194	0xE6,0x07,0xA3,0x5A,0x8D,0x02,0x31,0xFD,
		10195	0x20,0x34,0x0F,0x88,0xC0,0xAC,0xE0,0xF9,
		10196	0x71,0xC0,0x0C,0x84,0xAA,0x04,0x11,0x98,
		10197	0x73,0x01,0xD1,0xAC,0x20,0x34,0x3B,0x18,
		10198	0xD5,0xFE,0x0F,0xD1,0x00,0x08,0x08,0xCD,
		10199	0x07,0xA2,0xC3,0x00,0x79,0x96,0x09,0xC8,
		10200	0x1A,0x41,0xA8,0x66,0x10,0x81,0x39,0x27,
		10201	0x10,0xCD,0x0E,0x42,0x95,0xFD,0x4D,0x82,
		10202	0x91,0x8C,0x0F,0xD0,0x40,0x24,0x37,0x08,
		10203	0xD5,0xF1,0x0C,0x0A,0x46,0x74,0x83,0x08,
		10204	0xC8,0x59,0x40,0x68,0x36,0x30,0x9A,0x4C,
		10205	0xED,0x91,0x80,0xBA,0x05,0x61,0xE9,0x41,
		10206	0x68,0x3A,0xBB,0x83,0xA7,0x20,0x54,0x81,
		10207	0x5E,0x30,0xA6,0x19,0x44,0x87,0x05,0x02,
		10208	0x42,0x73,0x81,0x51,0x1D,0xAF,0x96,0x40,
		10209	0x44,0x1B,0x08,0xD5,0x0A,0xA2,0x81,0x93,
		10210	0x1F,0x53,0x10,0x92,0x14,0x84,0xFC,0xFF,
		10211	0x07,0xAA,0xC7,0x9C,0x40,0xAC,0xFA,0x5B,
		10212	0x25,0x50,0x27,0x01,0xA1,0xC9,0x40,0x74,
		10213	0x7C,0x20,0x0F,0xB8,0x83,0x64,0x20,0x54,
		10214	0x29,0x88,0xC0,0xAC,0xF4,0x63,0xA4,0x23,
		10215	0x05,0x51,0x7D,0xBC,0xA0,0x20,0x34,0xD1,
		10216	0x3B,0x2C,0x08,0x7B,0xB8,0x69,0xA8,0xE4,
		10217	0x59,0xA5,0xA1,0x12,0x10,0x9A,0x0D,0x44,
		10218	0xC7,0x04,0xF2,0xAA,0x79,0x4C,0x60,0x20,
		10219	0x54,0x2F,0x08,0xCD,0x01,0x42,0x13,0x83,
		10220	0x08,0xD4,0xA9,0xBF,0x37,0x1A,0x2A,0xF9,
		10221	0x5B,0x09,0xC4,0xCA,0x5E,0x69,0x02,0xB1,
		10222	0xDE,0xA7,0x4E,0x20,0xE6,0x1D,0x98,0xA9,
		10223	0x05,0xA1,0xEA,0x41,0x04,0xE6,0xB4,0x40,
		10224	0x54,0x81,0x78,0x10,0xA6,0x08,0x44,0x60,
		10225	0x4E,0x02,0x44,0xD3,0x81,0xD0,0xEC,0x60,
		10226	0x54,0xE7,0xA3,0x4D,0x40,0xD6,0x0E,0x42,
		10227	0xB3,0x80,0x08,0xCC,0x59,0x1E,0x69,0x02,
		10228	0xB1,0x92,0x2F,0x9D,0x0E,0x24,0x04,0x84,
		10229	0x26,0xD3,0x7F,0x68,0xA1,0x05,0x80,0x99,
		10230	0x84,0x04,0x20,0x4C,0x16,0x88,0x0E,0x27,
		10231	0xD6,0x08,0x22,0x40,0xC7,0x01,0xA3,0xD1,
		10232	0x40,0x68,0x5C,0x40,0x9A,0x1D,0x90,0x2A,
		10233	0x6D,0x00,0xC6,0x54,0x83,0xD0,0x24,0x20,
		10234	0x02,0x74,0x2C,0x10,0x01,0x5A,0x74,0x04,
		10235	0x30,0x16,0x01,0x84,0x46,0x05,0xA1,0xC9,
		10236	0x2A,0x80,0xB2,0x9C,0x20,0x1A,0x20,0xC9,
		10237	0x30,0x60,0x0A,0x42,0x33,0x81,0xD0,0x8C,
		10238	0x20,0x54,0x7C,0x07,0x10,0x16,0x04,0x84,
		10239	0x86,0x03,0xD1,0x00,0xFE,0xFF,0x8F,0x0C,
		10240	0x02,0xD1,0x00,0x9C,0x23,0xC4,0x61,0x85,
		10241	0x82,0xD0,0xF4,0x20,0x34,0x6C,0x09,0x50,
		10242	0x16,0x1D,0x44,0xC7,0x23,0x92,0x02,0x8C,
		10243	0x05,0x02,0xA1,0x31,0x41,0x68,0x6C,0x10,
		10244	0x1A,0x29,0x06,0x28,0x13,0x54,0xE3,0x50,
		10245	0x44,0x7B,0x80,0x31,0x99,0x20,0x54,0x36,
		10246	0x88,0xC0,0x1C,0x14,0x88,0x86,0x07,0xA1,
		10247	0x62,0x82,0x00,0x52,0x10,0x01,0x12,0x20,
		10248	0x1A,0x1E,0x84,0x8A,0x29,0x32,0x74,0x0A,
		10249	0x42,0x55,0x24,0x39,0x9A,0x50,0x10,0x1D,
		10250	0x4D,0x08,0x08,0xCD,0x07,0x46,0x75,0x35,
		10251	0x39,0x6E,0x50,0x10,0xAA,0x1D,0x84,0x06,
		10252	0x05,0xA1,0x39,0xA2,0x80,0xB2,0xEC,0x20,
		10253	0x02,0xB2,0x9E,0x2A,0x87,0x0A,0x0A,0x22,
		10254	0x30,0xA7,0x02,0xA2,0x49,0x41,0xA8,0x8E,
		10255	0x2C,0x47,0x0A,0x9A,0x06,0x84,0x25,0x06,
		10256	0xA1,0xC9,0xDA,0x80,0xB0,0x0C,0x75,0x0E,
		10257	0x24,0x14,0x84,0xE6,0x04,0xA1,0x4A,0xF2,
		10258	0x0C,0x8F,0x82,0xE8,0x38,0x42,0x80,0x68,
		10259	0x7A,0x10,0xAA,0xA6,0xCF,0x00,0x28,0x88,
		10260	0x06,0x40,0x40,0x68,0x4E,0x30,0xAA,0xA8,
		10261	0xD1,0xD1,0x84,0x82,0x50,0xDD,0x2F,0x4E,
		10262	0x81,0xF8,0xFF,0x0F,
		10263	}) // END MBUF
		10264
		10265	} //end DefinitionBlock
		10266

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/tests/misc/grammar.asl – Rev 2216