rpms/acpica-tools
7
0
Fork 0
Code Issues Pull Requests Releases Activity
e064ea65fd
acpica-tools/tests/grammar2/grammar2.asl
Al Stone 69fdad5b24 Start adding in CI tests with some basic smoke tests 
Signed-off-by: Al Stone <ahs3@redhat.com>
2018-08-08 09:20:02 -06:00

11653 lines
369 KiB
Plaintext
Executable File
Raw Blame History

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20180313 (32-bit version)
* Copyright (c) 2000 - 2018 Intel Corporation
*
* Disassembling to symbolic ASL+ operators
*
* Disassembly of grammar.xxx, Thu Mar 22 09:44:49 2018
*
* Original Table Header:
* Signature "DSDT"
* Length 0x0002192B (137515)
* Revision 0x01 **** 32-bit table (V1), no 64-bit math support
* Checksum 0x2C **** Incorrect checksum, should be 0x5D
* OEM ID "Intel"
* OEM Table ID "GRMTEST"
* OEM Revision 0x20090511 (537462033)
* Compiler ID "INTL"
* Compiler Version 0x20180313 (538444563)
*/
/*
* Some or all of this work - Copyright (c) 2006 - 2018, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* */
/* */
/* Grammar.asl - Minimally excercises most ASL constructs */
/* */
/* NOTE -- use: iasl -f -of grammar.asl to compile */
/* */
/* This 1) Ignores errors (checks compiler error handling) */
/* 2) Disables constant folding */
/* */
/* */
/*******************************************************************************
Compilation should look like this:
C:\acpica\tests\misc>iasl -f -of grammar.asl
Intel ACPI Component Architecture
ASL Optimizing Compiler version 20090422 [Apr 22 2009]
Copyright (C) 2000 - 2009 Intel Corporation
Supports ACPI Specification Revision 3.0a
grammar.asl 187: Name (_NPK, Package (8)
Warning 1098 - ^ Unknown reserved name (_NPK)
grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn")
Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn")
Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
grammar.asl 601: Method (RCIV, 1)
Warning 1087 - ^ Not all control paths return a value (RCIV)
grammar.asl 608: RCIV (Subtract (Arg0, 1))
Remark 5073 - ^ Recursive method call (RCIV)
grammar.asl 937: Method (_ERR, 2)
Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3)
grammar.asl 1377: Store (0x1234567887654321, QWD2)
Warning 1032 - ^ 64-bit integer in 32-bit table, truncating
grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321))
Warning 1032 - 64-bit integer in 32-bit table, truncating ^
grammar.asl 1459: SizeOf (BUFO)
Warning 1105 - ^ Result is not used, operator has no effect
grammar.asl 1485: Acquire (MTX2, 1)
Warning 1104 - ^ Possible operator timeout is ignored
grammar.asl 1633: Add (Local0, Local1)
Warning 1105 - ^ Result is not used, operator has no effect
grammar.asl 1804: Method (COND)
Warning 1087 - ^ Not all control paths return a value (COND)
grammar.asl 6010: Name (_HID, "*PNP0A06")
Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06)
grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
Warning 1038 - Invalid or unknown escape sequence ^
grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1
Error 4050 - ^ Method local variable is not initialized (Local0)
grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID
Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A)
ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
***************************************************************************************************/
DefinitionBlock ("", "DSDT", 1, "Intel", "GRMTEST", 0x20090511)
{
External (\ABCD, UnknownObj)
/* Device with _STA and _INI */
Device (A1)
{
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
Return (Zero)
}
}
/* Device with no _STA, has _INI */
Device (A2)
{
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
Return (Zero)
}
}
/* Device with _STA, no _INI */
Device (A3)
{
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}
}
/* Device with _STA and _INI, but not present */
Device (A4)
{
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (Zero)
}
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
Return (Zero)
}
}
/* Resource descriptors */
Device (IRES)
{
Name (PRT0, ResourceTemplate ()
{
IRQ (Edge, ActiveHigh, Exclusive, )
{3,4,5,6,7,9,10,11,14,15}
StartDependentFn (0x01, 0x01)
{
IRQNoFlags ()
{0,1,2}
}
EndDependentFn ()
})
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Debug = "_CRS:"
Debug = PRT0 /* \IRES.PRT0 */
Return (PRT0) /* \IRES.PRT0 */
}
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
{
Debug = "_SRS:"
Debug = Arg0
Return (Zero)
}
}
Name (_NPK, Package (0x04)
{
0x1111,
0x2222,
0x3333,
0x4444
})
Device (RES)
{
Name (_PRT, Package (0x04) // _PRT: PCI Routing Table
{
Package (0x04)
{
0x0002FFFF,
Zero,
Zero,
Zero
},
Package (0x04)
{
0x0002FFFF,
One,
Zero,
Zero
},
Package (0x04)
{
0x000AFFFF,
Zero,
Zero,
Zero
},
Package (0x04)
{
0x000BFFFF,
Zero,
Zero,
Zero
}
})
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
{
Name (PRT0, ResourceTemplate ()
{
WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
0x0000, // Granularity
0xFFF2, // Range Minimum
0xFFF3, // Range Maximum
0x0032, // Translation Offset
0x0002, // Length
,, _Y00)
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
0x0000, // Granularity
0x0000, // Range Minimum
0x00FF, // Range Maximum
0x0000, // Translation Offset
0x0100, // Length
,, )
WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
0x0000, // Granularity
0xA000, // Range Minimum
0xBFFF, // Range Maximum
0x0000, // Translation Offset
0x2000, // Length
,, )
IO (Decode16,
0x0CF8, // Range Minimum
0x0CFF, // Range Maximum
0x01, // Alignment
0x08, // Length
)
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000, // Granularity
0x0000, // Range Minimum
0x0CF7, // Range Maximum
0x0000, // Translation Offset
0x0CF8, // Length
,, , TypeStatic, DenseTranslation)
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000, // Granularity
0x0D00, // Range Minimum
0xFFFF, // Range Maximum
0x0000, // Translation Offset
0xF300, // Length
,, , TypeStatic, DenseTranslation)
DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x00000000, // Granularity
0x00000000, // Range Minimum
0x00000CF7, // Range Maximum
0x00000000, // Translation Offset
0x00000CF8, // Length
,, , TypeStatic, DenseTranslation)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000C8000, // Range Minimum
0x000EFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00028000, // Length
,, , AddressRangeMemory, TypeStatic)
DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
0x00000000, // Granularity
0x000C8000, // Range Minimum
0x000EFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00028000, // Length
,, )
QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000000000000000, // Granularity
0x0000000000000000, // Range Minimum
0x0000000000000CF7, // Range Maximum
0x0000000000000000, // Translation Offset
0x0000000000000CF8, // Length
0x44, "This is a ResouceSource string", , TypeStatic, DenseTranslation)
QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000000000000000, // Granularity
0x0000000000000000, // Range Minimum
0x0000000000000CF7, // Range Maximum
0x0000000000000000, // Translation Offset
0x0000000000000CF8, // Length
,, , TypeStatic, DenseTranslation)
QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x0000000000000000, // Granularity
0x0000000000100000, // Range Minimum
0x00000000FFDFFFFF, // Range Maximum
0x0000000000000000, // Translation Offset
0x00000000FFD00000, // Length
,, , AddressRangeMemory, TypeStatic)
QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
0x0000000000000000, // Granularity
0x0000000000000000, // Range Minimum
0x0000000000000CF7, // Range Maximum
0x0000000000000000, // Translation Offset
0x0000000000000CF8, // Length
,, )
ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000000000000000, // Granularity
0x0000000000000000, // Range Minimum
0x0000000000000CF7, // Range Maximum
0x0000000000000000, // Translation Offset
0x0000000000000CF8, // Length
0x0000000000000000, // Type-Specific Attributes
, TypeStatic, DenseTranslation)
ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x0000000000000000, // Granularity
0x0000000000100000, // Range Minimum
0x00000000FFDFFFFF, // Range Maximum
0x0000000000000000, // Translation Offset
0x00000000FFD00000, // Length
0x0000000000000000, // Type-Specific Attributes
, AddressRangeMemory, TypeStatic)
ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
0x0000000000000000, // Granularity
0x0000000000100000, // Range Minimum
0x00000000FFDFFFFF, // Range Maximum
0x0000000000000000, // Translation Offset
0x00000000FFD00000, // Length
0x0000000000000000, // Type-Specific Attributes
)
IO (Decode16,
0x0010, // Range Minimum
0x0020, // Range Maximum
0x01, // Alignment
0x10, // Length
)
IO (Decode16,
0x0090, // Range Minimum
0x00A0, // Range Maximum
0x01, // Alignment
0x10, // Length
)
FixedIO (
0x0061, // Address
0x01, // Length
)
IRQNoFlags ()
{2}
DMA (Compatibility, BusMaster, Transfer8_16, )
{4}
DMA (Compatibility, BusMaster, Transfer8, )
{2,5,7}
Memory32Fixed (ReadWrite,
0x00100000, // Address Base
0x00000000, // Address Length
)
Memory32Fixed (ReadOnly,
0xFFFE0000, // Address Base
0x00020000, // Address Length
)
Memory32 (ReadOnly,
0x00020000, // Range Minimum
0xFFFE0000, // Range Maximum
0x00000004, // Alignment
0x00000200, // Length
)
Memory24 (ReadOnly,
0x1111, // Range Minimum
0x2222, // Range Maximum
0x0004, // Alignment
0x0200, // Length
)
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0x0E, "\\_SB_.TEST", )
{
0x00000E01,
}
Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x06, "xxxx", )
{
0x00000601,
0x00000003,
0x00000002,
0x00000001,
}
Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive, ,, )
{
0xFFFF0000,
0x00000003,
0x00000002,
0x00000001,
0x00000005,
0x00000007,
0x00000009,
}
VendorShort () // Length = 0x03
{
0x01, 0x02, 0x03 // ...
}
VendorLong () // Length = 0x09
{
/* 0000 */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // ........
/* 0008 */ 0x09 // .
}
Register (SystemIO,
0x08, // Bit Width
0x00, // Bit Offset
0x00000000000000B2, // Address
,_Y01)
Register (SystemMemory,
0x08, // Bit Width
0x00, // Bit Offset
0x00000000000000B2, // Address
,)
StartDependentFnNoPri ()
{
IRQNoFlags ()
{0,1,2}
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11,14,15}
}
EndDependentFn ()
})
CreateWordField (PRT0, \RES._CRS._Y00._MIN, BMIN) // _MIN: Minimum Base Address
CreateByteField (PRT0, \RES._CRS._Y01._ASZ, RSIZ) // _ASZ: Access Size
BMIN = 0x03
Return (PRT0) /* \RES_._CRS.PRT0 */
}
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
{
Name (BUF0, ResourceTemplate ()
{
StartDependentFn (0x01, 0x02)
{
IO (Decode16,
0x03D8, // Range Minimum
0x03F8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{4}
}
StartDependentFn (0x02, 0x01)
{
IO (Decode16,
0x03D8, // Range Minimum
0x03E8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{4}
}
StartDependentFn (0x00, 0x02)
{
IO (Decode16,
0x02E8, // Range Minimum
0x02F8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{3}
}
StartDependentFn (0x00, 0x02)
{
IO (Decode16,
0x02D8, // Range Minimum
0x02E8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{3}
}
StartDependentFn (0x02, 0x00)
{
IO (Decode16,
0x0100, // Range Minimum
0x03F8, // Range Maximum
0x08, // Alignment
0x08, // Length
)
IRQNoFlags ()
{1,3,4,5,6,7,8,10,11,12,13,14,15}
}
EndDependentFn ()
})
Return (BUF0) /* \RES_._PRS.BUF0 */
}
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
{
Return (Zero)
}
}
Name (\_S0, Package (0x04) // _S0_: S0 System State
{
0x00,
0x00,
0x00,
0x00
})
Name (\_S3, Package (0x04) // _S3_: S3 System State
{
0x05,
0x05,
0x00,
0x00
})
Name (\_S4, Package (0x04) // _S4_: S4 System State
{
0x06,
0x06,
0x00,
0x00
})
Name (\_S5, Package (0x04) // _S5_: S5 System State
{
0x07,
0x07,
0x00,
0x00
})
/* Examine this table header (DSDT) */
/*
DataTableRegion (HDR, "DSDT", "", "")
Field (HDR, AnyAcc, NoLock, Preserve)
{
SIG, 32,
LENG, 32,
REV, 8,
SUM, 8,
OID, 48,
OTID, 64,
OREV, 32,
CID, 32,
CREV, 32
}
Method (SIZE)
{
If (LLess (REV, 2))
{
Store ("32-bit table", Debug)
}
else
{
Store ("64-bit table", Debug)
}
Return (0)
}
*/
Name (SIZE, 0x00)
/* Custom operation region */
OperationRegion (MYOP, 0x80, 0xFD60, 0x06)
Field (MYOP, ByteAcc, NoLock, Preserve)
{
MFLD, 8
}
Method (TCOP, 0, Serialized)
{
Name (_STR, Unicode ("test")) // _STR: Description String
MFLD = 0x04
Local0 = MFLD /* \MFLD */
}
Name (ERRS, 0x00)
/* Warning should be issued for premature string termination */
Name (ESC1, "abcdefghijklmn")
Name (ESC2, "abcdefghijklmn")
Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\x1A")
Name (CRSA, ResourceTemplate ()
{
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
0x0000, // Granularity
0x0019, // Range Minimum
0x001D, // Range Maximum
0x0000, // Translation Offset
0x0005, // Length
,, )
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, NonISAOnlyRanges,
0x0000, // Granularity
0xC000, // Range Minimum
0xCFFF, // Range Maximum
0x0000, // Translation Offset
0x1000, // Length
,, , TypeStatic, DenseTranslation)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
0x00000000, // Granularity
0xD8000000, // Range Minimum
0xDBFFFFFF, // Range Maximum
0x00000000, // Translation Offset
0x04000000, // Length
,, , AddressRangeMemory, TypeStatic)
})
Name (CRSB, ResourceTemplate ()
{
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
0x00000000, // Granularity
0xD8000000, // Range Minimum
0xDBFFFFFF, // Range Maximum
0x00000000, // Translation Offset
0x04000000, // Length
,, , AddressRangeMemory, TypeStatic)
})
Name (CRSC, ResourceTemplate ()
{
VendorShort () // Length = 0x03
{
0x01, 0x02, 0x03 // ...
}
})
Name (CRSD, ResourceTemplate ()
{
VendorLong () // Length = 0x09
{
/* 0000 */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // ........
/* 0008 */ 0x09 // .
}
})
Name (CRSE, ResourceTemplate ()
{
IRQNoFlags ()
{3,4,10,11}
IRQNoFlags ()
{3,4,10,11}
})
Name (CRSR, Buffer ((SizeOf (CRSA) + SizeOf (CRSB))){})
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (CRSR) /* \CRSR */
}
/* */
/* Unnamed scope */
/* */
Scope (\)
{
Name (BXXX, 0xFFFFFFFF)
}
Name (LANS, 0x00)
PowerResource (LANP, 0x01, 0x0000)
{
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (((LANS & 0x30) == 0x30))
{
Return (One)
}
Else
{
Return (Zero)
}
}
Method (_ON, 0, NotSerialized) // _ON_: Power On
{
If (!_STA ())
{
LANS = 0x30
}
}
Method (_OFF, 0, NotSerialized) // _OFF: Power Off
{
If (_STA ())
{
LANS = 0x00
}
}
}
/* Can a method define another method? */
/**********************************
Method (TASK, 2, SERIALIZED)
{
Sleep (100)
Method (TAS2)
{
Sleep (100)
}
TAS2()
Return
}
************************************/
/* A recursive method */
Method (RCIV, 1, NotSerialized)
{
Debug = Arg0
If ((Arg0 == 0x00))
{
Return (Zero)
}
RCIV ((Arg0 - 0x01))
}
Method (RTOP, 0, NotSerialized)
{
RCIV (0x64)
}
Scope (\_PR)
{
Processor (CPU0, 0x00, 0xFFFFFFFF, 0x00){}
}
Name (B1TP, 0xFFFFFFFF)
Name (B2TP, 0xFFFFFFFF)
Name (ADPS, 0xFFFFFFFF)
Name (B1PS, 0xFFFFFFFF)
Name (B1RS, 0xFFFFFFFF)
Name (B1CS, 0xFFFFFFFF)
Name (B2PS, 0xFFFFFFFF)
Name (B2RS, 0xFFFFFFFF)
Name (B2CS, 0xFFFFFFFF)
Name (B1DC, 0x0BB8)
Name (B2DC, 0x0A28)
Name (B1LF, 0x0BB8)
Name (B2LF, 0x0A28)
Name (BPIF, 0x00)
Name (PBLL, 0x00)
Name (RBIF, Package (0x0D)
{
0x01,
0x0898,
0x0898,
0x01,
0x2A30,
0x00,
0x00,
0x01,
0x01,
"CA54200-5003/5",
"1",
"LION",
"Fujitsu"
})
Method (SMWE, 4, NotSerialized)
{
Return (Ones)
}
Method (SMRE, 4, NotSerialized)
{
Return (Ones)
}
/*
Method(RDBT,0,Serialized){
If(LNot(SMWE(0x09,0x15,1,1))){
Store(0x18,Local2)
}
}
*/
Scope (_SB)
{
Name (SBUF, Buffer (0x80){})
CreateBitField (SBUF, 0x03, BITY)
CreateByteField (SBUF, 0x01, BYTY)
CreateWordField (SBUF, 0x02, WRDZ)
CreateDWordField (SBUF, 0x04, DWDZ)
CreateQWordField (SBUF, 0x08, QWDZ)
CreateField (SBUF, 0x80, 0x0C, FLDZ)
CreateField (SBUF, 0x94, 0x60, FLDY)
CreateField (SBUF, 0x94, 0x60, \_SB.FLDW)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
CreateField (\_SB.SBUF, 0x94, 0x60, FLDV)
}
Device (PCI0)
{
Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID
Name (_ADR, 0x00) // _ADR: Address
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
{
Name (PRT0, ResourceTemplate ()/* PRT0 */ /*Minimum bus number suported under this bridge. */
{
WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
0x0000, // Granularity
0xFFF1, // Range Minimum
0xFFF2, // Range Maximum
0x0032, // Translation Offset
0x0002, // Length
,, _Y02)
})
CreateWordField (PRT0, \_SB.PCI0._CRS._Y02._MIN, BMIN) // _MIN: Minimum Base Address
BMIN = 0x03
Return (PRT0) /* \_SB_.PCI0._CRS.PRT0 */
} /* _CRS */
Method (_SRS, 0, NotSerialized) // _SRS: Set Resource Settings
{
Return (Zero)
}
Device (EIO)
{
OperationRegion (FJIO, SystemIO, 0xFD60, 0x06)
Field (FJIO, ByteAcc, NoLock, Preserve)
{
GIDX, 8,
GDTA, 8,
PIDX, 8,
PDTA, 8,
SIDX, 8,
SDTA, 8
}
IndexField (GIDX, GDTA, ByteAcc, NoLock, Preserve)
{
Offset (0x02),
, 5,
VGAS, 2,
Offset (0x04),
, 4,
DCKE, 1,
Offset (0x05),
, 6,
ACPW, 1,
Offset (0x0A),
B1P, 1,
B2P, 1,
B1C, 1,
B2C, 1,
B1ER, 1,
B2ER, 1,
Offset (0x0B),
B1CP, 8,
B2CP, 8,
BCP, 8,
B1VH, 8,
B1VL, 8,
B2VH, 8,
B2VL, 8,
B1TM, 8,
B2TM, 8,
B1CH, 8,
B1CL, 8,
B2CH, 8,
B2CL, 8
}
}
}
}
Method (RDBT, 3, Serialized)
{
Local1 = 0x1FFF
If (Arg0)
{
Local1 = 0x2FFF
}
Local2 = 0x18
If (Arg1)
{
Local2 = 0x10
}
If (!SMRE (0x09, 0x15, 0x01, RefOf (Local0)))
{
If (!SMWE (0x08, 0x14, 0x01, Local1))
{
If (!SMRE (0x09, 0x17, Local2, RefOf (Local3)))
{
Arg2 = Local1
}
}
Local0 |= 0x0FFF
SMWE (0x08, 0x14, 0x01, Local0)
}
}
Method (MKWD, 2, NotSerialized)
{
If ((Arg1 & 0x80))
{
Local0 = (0xFFFF0000 | Arg0)
Local0 |= (Arg1 << 0x08)
Local0 = (Zero - Local0)
}
Else
{
Local0 = Arg0
Local0 |= (Arg1 << 0x08)
}
Return (Local0)
}
Device (CMB1)
{
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID
Name (_UID, 0x01) // _UID: Unique ID
Alias (\_SB.PCI0.EIO.B1P, \_SB.PCI0.XXXX)
Alias (\_SB.PCI0.EIO.B1P, B1P)
Alias (\_SB.PCI0.EIO.B1C, B1C)
Alias (\_SB.PCI0.EIO.B1CH, B1CH)
Alias (\_SB.PCI0.EIO.B1CL, B1CL)
Alias (\_SB.PCI0.EIO.B1VH, B1VH)
Alias (\_SB.PCI0.EIO.B1VL, B1VL)
Alias (\_SB.PCI0.EIO.B1CP, B1CP)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
B1PS = B1P /* \CMB1.B1P_ */
B1RS = B1CP /* \CMB1.B1CP */
B1CS = B1C /* \CMB1.B1C_ */
}
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
{
RDBT (Zero, Zero, RefOf (B1DC))
RDBT (Zero, One, RefOf (B1LF))
RBIF [0x01] = B1DC /* \B1DC */
RBIF [0x02] = B1LF /* \B1LF */
RBIF [0x09] = "CA54200-5003/5"
RBIF [0x0A] = "1"
Return (RBIF) /* \RBIF */
}
Method (_BST, 0, Serialized) // _BST: Battery Status
{
_INI ()
Local0 = Zero
If ((B1P && !B1C))
{
Local0 |= 0x01
}
If ((B1P && B1C))
{
Local0 |= 0x02
}
If ((B1CP <= 0x01))
{
Local0 |= 0x04
}
Local1 = MKWD (B1CL, B1CH)
Store ((((B1CP * B1LF) + 0x63) / 0x64), Local2)
Local3 = MKWD (B1VL, B1VH)
Name (STAT, Package (0x04){})
STAT [0x00] = Local0
STAT [0x01] = Local1
STAT [0x02] = Local2
STAT [0x03] = Local3
If (!BPIF)
{
/* \_SB.PCI0.EIO.EC0.IECT() */
/* \_SB.PCI0.EIO.EC0.SECT() */
BPIF = One
}
Return (STAT) /* \CMB1._BST.STAT */
}
}
Device (DEV1)
{
}
Scope (\_TZ)
{
ThermalZone (TZ1)
{
Name (_PSL, Package (0x01) // _PSL: Passive List
{
\_PR.CPU0
})
}
}
Method (TZ2, 0, Serialized)
{
Name (_PSL, Package (0x01) // _PSL: Passive List
{
\_PR.CPU0
})
Return (_PSL) /* \TZ2_._PSL */
}
ThermalZone (THM1)
{
}
Method (NOTI, 0, NotSerialized)
{
Notify (\DEV1, 0x00) // Bus Check
Notify (\THM1, 0x00) // Bus Check
Notify (\_PR.CPU0, 0x00) // Bus Check
}
Method (_ERR, 3, NotSerialized)
{
ERRS++
Debug = "Run-time exception:"
Debug = Arg0
Debug = Arg1
Return (0x00) /* Map error to AE_OK */
}
Method (DIV0, 0, NotSerialized)
{
Local0 = 0x01
Local1 = 0x00
Divide (Local0, Local1, Local3)
Debug = "DIV0 - noabort"
}
Method (ERR, 2, NotSerialized)
{
Local0 = ToDecimalString (Arg1)
If ((Arg0 == 0x00))
{
Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Results not equal!")
}
If ((Arg0 == 0x01))
{
Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Numeric result is incorrect!")
}
If ((Arg0 == 0x02))
{
Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Operand was clobbered!")
}
Notify (DEV1, Arg0)
ERRS++
}
Method (R226, 2, NotSerialized)
{
}
Method (R225, 2, NotSerialized)
{
R226 (Arg0, Arg1)
}
Method (R224, 2, NotSerialized)
{
R225 (Arg1, Arg0)
}
Method (R223, 2, NotSerialized)
{
R224 (Arg0, Arg1)
}
Method (R222, 2, NotSerialized)
{
R223 (Arg1, Arg0)
}
Method (R111, 0, NotSerialized)
{
Local0 = 0x01010101
R222 (0xABAB, Local0)
Local1 = Local0
}
Method (MAIN, 0, NotSerialized)
{
/* SIZE() */
Local0 = NUM1 ()
\CMB1._BST ()
RDBT (0x01, 0x02, 0x03)
OBJ1 (0x01)
OBJ2 (0x02)
CHEK ()
RETZ ()
BITZ ()
LOGS ()
REFS ()
COND ()
TZ2 ()
/* */
/* iPCO tests added */
/* */
Local0 = \IFEL.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x040D)
Return (Local0)
}
Local0 = \NOSV.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0414)
Return (Local0)
}
Local0 = \IDXF.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x041B)
Return (Local0)
}
Local0 = \_SB.NSTL.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0422)
Return (Local0)
}
Local0 = \RTBF.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0429)
Return (Local0)
}
Local0 = \_SB.RTLV.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0430)
Return (Local0)
}
Local0 = \_SB.RETP.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0437)
Return (Local0)
}
Local0 = \WHLR.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x043E)
Return (Local0)
}
Local0 = \ANDO.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0445)
Return (Local0)
}
Local0 = \BRKP.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x044C)
Return (Local0)
}
Local0 = \ADSU.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0453)
Return (Local0)
}
Local0 = \INDC.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x045A)
Return (Local0)
}
Local0 = \LOPS.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0461)
Return (Local0)
}
Local0 = \FDSO.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0468)
Return (Local0)
}
Local0 = \MLDV.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x046F)
Return (Local0)
}
Local0 = \NBIT.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0476)
Return (Local0)
}
Local0 = \SHFT.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x047D)
Return (Local0)
}
Local0 = \XORD.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0484)
Return (Local0)
}
Local0 = \CRBF.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x048B)
Return (Local0)
}
Local0 = \IDX4.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0492)
Return (Local0)
}
Local0 = \EVNT.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x0499)
Return (Local0)
}
Local0 = \SZLV.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04A0)
Return (Local0)
}
Local0 = \_SB.BYTF.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04A7)
Return (Local0)
}
Local0 = \DWDF.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04AE)
Return (Local0)
}
Local0 = \DVAX.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04B5)
Return (Local0)
}
Local0 = \IDX6.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04BC)
Return (Local0)
}
Local0 = \IDX5.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04C3)
Return (Local0)
}
Local0 = \_SB.IDX0.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04CA)
Return (Local0)
}
Local0 = \_SB.IDX3.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04D1)
Return (Local0)
}
Local0 = \IDX7.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04D8)
Return (Local0)
}
Local0 = \MTCH.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04DF)
Return (Local0)
}
Local0 = \WHLB.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04E6)
Return (Local0)
}
Local0 = \_SB.IDX2.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04ED)
Return (Local0)
}
Local0 = \SIZO.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04F4)
Return (Local0)
}
Local0 = \_SB.SMIS.TEST ()
If ((Local0 > 0x00))
{
ERR (0x01, 0x04FB)
Return (Local0)
}
If ((ERRS > 0x00))
{
Debug = "****** There were errors during the execution of the test ******"
}
/* Flush all notifies */
Sleep (0xFA)
/* */
/* Last Test */
/* */
Return (0x00) /* Success */
}
Method (OBJ1, 1, Serialized)
{
Local0 = 0x03
Name (BUFR, Buffer (Local0){})
Name (BUF1, Buffer (0x04)
{
0x01, 0x02, 0x03, 0x04 // ....
})
Name (BUF2, Buffer (0x04){})
BUF2 = BUF1 /* \OBJ1.BUF1 */
Mutex (MTX1, 0x04)
Alias (MTX1, MTX2)
}
Mutex (MTXT, 0x00)
Mutex (MTXX, 0x00)
/*
* Field Creation
*/
Method (FLDS, 0, Serialized)
{
Debug = "++++++++ Creating BufferFields"
Name (BUF2, Buffer (0x80){})
CreateBitField (BUF2, 0x03, BIT2)
CreateByteField (BUF2, 0x01, BYT2)
CreateWordField (BUF2, 0x02, WRD2)
CreateDWordField (BUF2, 0x04, DWD2)
CreateQWordField (BUF2, 0x08, QWD2)
CreateField (BUF2, 0x80, 0x0C, FLD2)
CreateField (BUF2, 0x94, 0x60, FLD3)
BIT2 = 0x01
Local0 = BIT2 /* \FLDS.BIT2 */
If ((Local0 != 0x01))
{
ERR (0x01, 0x0537)
}
Else
{
Local0 = DerefOf (BUF2 [0x00])
If ((Local0 != 0x08))
{
ERR (0x01, 0x053E)
}
Else
{
Debug = "++++++++ Bit BufferField I/O PASS"
}
}
BYT2 = 0x1A
Local0 = BYT2 /* \FLDS.BYT2 */
If ((Local0 != 0x1A))
{
ERR (0x01, 0x054A)
}
Else
{
Debug = "++++++++ Byte BufferField I/O PASS"
}
WRD2 = 0x1234
Local0 = WRD2 /* \FLDS.WRD2 */
If ((Local0 != 0x1234))
{
ERR (0x01, 0x0555)
}
Else
{
Debug = "++++++++ Word BufferField I/O PASS"
}
FLD2 = 0x0123
Local0 = FLD2 /* \FLDS.FLD2 */
If ((Local0 != 0x0123))
{
ERR (0x01, 0x0560)
}
Else
{
Debug = "++++++++ 12-bit BufferField I/O PASS"
}
DWD2 = 0x12345678
Local0 = DWD2 /* \FLDS.DWD2 */
If ((Local0 != 0x12345678))
{
ERR (0x01, 0x056B)
}
Else
{
Debug = "++++++++ Dword BufferField I/O PASS"
}
QWD2 = 0x1234567887654321
Local0 = QWD2 /* \FLDS.QWD2 */
If ((Local0 != 0x1234567887654321))
{
ERR (0x01, 0x0576)
}
Else
{
Debug = "++++++++ Qword BufferField I/O PASS"
}
}
/* Field execution */
Method (FLDX, 0, Serialized)
{
Field (\_SB.MEM.SMEM, AnyAcc, NoLock, Preserve)
{
/* Field: SMEM overlay using 32-bit field elements */
SMD0, /* 32-bits */ 32,
SMD1, /* 32-bits */ 32,
SMD2, /* 32-bits */ 32,
SMD3, /* 32-bits */ 32
} /* Field: SMEM overlay using 32-bit field elements */
Field (\_SB.MEM.SMEM, AnyAcc, NoLock, Preserve)
{
/* Field: SMEM overlay using greater than 32-bit field elements */
SME0, /* larger than an integer (32 or 64) */ 69,
SME1, /* larger than an integer */ 97
} /* Field: SMEM overlay using greater than 32-bit field elements */
}
Method (MTX, 0, NotSerialized)
{
/* Test "Force release" of mutex on method exit */
Acquire (MTXT, 0xFFFF)
Acquire (MTXX, 0xFFFF)
Debug = "++++++++ Acquiring Mutex MTX2"
Acquire (_GL, 0xFFFF)
Debug = "++++++++ Releasing Mutex MTX2"
Release (_GL)
}
Method (OBJ2, 1, Serialized)
{
Debug = "++++++++ Creating Buffer BUFO"
Name (BUFO, Buffer (0x20){})
Debug = "++++++++ Creating OpRegion OPR2"
OperationRegion (OPR2, SystemMemory, Arg0, 0x0100)
Debug = "++++++++ Creating Field(s) in OpRegion OPR2"
Field (OPR2, ByteAcc, NoLock, Preserve)
{
IDX2, 8,
DAT2, 8,
BNK2, 4
}
Debug = "++++++++ Creating BankField BNK2 in OpRegion OPR2"
/* */
/* mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1 */
/* */
BankField (OPR2, BNK2, 0x00, ByteAcc, NoLock, Preserve)
{
FET0, 4,
FET1, 3
}
Debug = "++++++++ Creating IndexField"
IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
{
FET2, 4,
FET3, 3
}
Debug = "++++++++ SizeOf (BUFO)"
SizeOf (BUFO)
Debug = "++++++++ Store (SizeOf (BUFO), Local0)"
Local0 = SizeOf (BUFO)
Debug = "++++++++ Concatenate (\"abd\", \"def\", Local0)"
Concatenate ("abd", "def", Local0)
Debug = Local0
Debug = "++++++++ Concatenate (\"abd\", 0x7B, Local0)"
Concatenate ("abd", 0x7B, Local0)
Debug = Local0
Debug = "++++++++ Creating Event EVT2"
Event (EVT2)
Debug = "++++++++ Creating Mutex MTX2"
Mutex (MTX2, 0x00)
Debug = "++++++++ Creating Alias MTXA to MTX2"
Alias (MTX2, MTXA)
Debug = "++++++++ Acquiring Mutex MTX2"
Acquire (MTX2, 0xFFFF)
Debug = "++++++++ Acquiring Mutex MTX2 (2nd acquire)"
Acquire (MTX2, 0x0001)
Debug = "++++++++ Releasing Mutex MTX2"
Release (MTX2)
/* Type 1 opcodes */
Debug = "++++++++ Signalling Event EVT2"
Signal (EVT2)
Debug = "++++++++ Resetting Event EVT2"
Reset (EVT2)
Debug = "++++++++ Signalling Event EVT2"
Signal (EVT2)
Debug = "++++++++ Waiting Event EVT2"
Wait (EVT2, 0xFFFF)
Debug = "++++++++ Sleep"
Sleep (0x64)
Debug = "++++++++ Stall"
Stall (0xFE)
Debug = "++++++++ NoOperation"
Noop
/* Type 2 Opcodes */
Debug = "++++++++ Return from Method OBJ2"
Return (0x04)
}
Method (NUM1, 0, NotSerialized)
{
/* ADD */
Debug = "++++++++ Add (0x12345678, 0x11111111, Local0)"
Local0 = (0x12345678 + 0x11111111)
Debug = "++++++++ Store (Add (0x12345678, 0x11111111), Local1)"
Store ((0x12345678 + 0x11111111), Local1)
Debug = "++++++++ Checking result from ADD"
If ((Local0 != Local1))
{
ERR (0x00, 0x060E)
}
/* SUBTRACT */
Debug = "++++++++ Subtract (0x87654321, 0x11111111, Local4)"
Local4 = (0x87654321 - 0x11111111)
Debug = "++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)"
Store ((0x87654321 - 0x11111111), Local5)
Debug = "++++++++ Checking result from SUBTRACT"
If ((Local4 != Local5))
{
ERR (0x00, 0x061D)
}
/* MULTIPLY */
Debug = "++++++++ Multiply (33, 10, Local6)"
Local6 = (0x21 * 0x0A)
Debug = "++++++++ Store (Multiply (33, 10), Local7)"
Store ((0x21 * 0x0A), Local7)
Debug = "++++++++ Checking result from MULTIPLY"
If ((Local6 != Local7))
{
ERR (0x00, 0x062D)
}
/* DIVIDE */
Debug = "++++++++ Divide (100, 9, Local1, Local2)"
Divide (0x64, 0x09, Local1, Local2)
Debug = "++++++++ Store (Divide (100, 9), Local3)"
Store ((0x64 / 0x09), Local3)
Debug = "++++++++ Checking (quotient) result from DIVIDE"
If ((Local2 != Local3))
{
ERR (0x00, 0x063C)
}
/* INCREMENT */
Debug = "++++++++ Increment (Local0)"
Local0 = 0x01
Local1 = 0x02
Local0++
Debug = "++++++++ Checking result from INCREMENT"
If ((Local0 != Local1))
{
ERR (0x00, 0x064A)
}
/* DECREMENT */
Debug = "++++++++ Decrement (Local0)"
Local0 = 0x02
Local1 = 0x01
Local0--
Debug = "++++++++ Checking result from DECREMENT"
If ((Local0 != Local1))
{
ERR (0x00, 0x0658)
}
/* TOBCD */
/* FROMBCD */
Debug = "++++++++ ToBCD (0x1234, Local5)"
ToBCD (0x1234, Local5)
Debug = "++++++++ FromBCD (Local5, Local6)"
FromBCD (Local5, Local6)
Debug = "++++++++ Return (Local6)"
Return (Local6)
}
Method (CHEK, 0, NotSerialized)
{
Local0 = 0x03
Debug = 0x03
Debug = Local0
Local1 = 0x07
(Local0 + Local1)
If ((Local0 != 0x03))
{
ERR (0x02, 0x0675)
}
If ((Local1 != 0x07))
{
ERR (0x02, 0x0679)
}
Local2 = (Local0 + Local1)
If ((Local0 != 0x03))
{
ERR (0x02, 0x0680)
}
If ((Local1 != 0x07))
{
ERR (0x02, 0x0684)
}
}
Method (RET1, 0, NotSerialized)
{
Local0 = 0x03
Return (Local0)
}
Method (RET2, 0, NotSerialized)
{
Return (RET1 ())
}
Method (RETZ, 0, NotSerialized)
{
RET2 ()
}
Method (BITZ, 0, NotSerialized)
{
Debug = "++++++++ FindSetLeftBit (0x00100100, Local0)"
FindSetLeftBit (0x00100100, Local0)
If ((Local0 != 0x15))
{
ERR (0x01, 0x06A0)
}
Debug = "++++++++ FindSetRightBit (0x00100100, Local1)"
FindSetRightBit (0x00100100, Local1)
If ((Local1 != 0x09))
{
ERR (0x01, 0x06A7)
}
Debug = "++++++++ And (0xF0F0F0F0, 0x11111111, Local2)"
Local2 = (0xF0F0F0F0 & 0x11111111)
If ((Local2 != 0x10101010))
{
ERR (0x01, 0x06AE)
}
Debug = "++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)"
NAnd (0xF0F0F0F0, 0x11111111, Local3)
If ((Local3 != 0xEFEFEFEF))
{
ERR (0x01, 0x06B5)
}
Debug = "++++++++ Or (0x11111111, 0x22222222, Local4)"
Local4 = (0x11111111 | 0x22222222)
If ((Local4 != 0x33333333))
{
ERR (0x01, 0x06BC)
}
Debug = "++++++++ NOr (0x11111111, 0x22222222, Local5)"
NOr (0x11111111, 0x22222222, Local5)
If ((Local5 != 0xCCCCCCCC))
{
ERR (0x01, 0x06C3)
}
Debug = "++++++++ XOr (0x11113333, 0x22222222, Local6)"
Local6 = (0x11113333 ^ 0x22222222)
If ((Local6 != 0x33331111))
{
ERR (0x01, 0x06CA)
}
Debug = "++++++++ ShiftLeft (0x11112222, 2, Local7)"
Local7 = (0x11112222 << 0x02)
If ((Local7 != 0x44448888))
{
ERR (0x01, 0x06D1)
}
Debug = "++++++++ ShiftRight (Local7, 2, Local7)"
Local7 >>= 0x02
If ((Local7 != 0x11112222))
{
ERR (0x01, 0x06D8)
}
Debug = "++++++++ Not (Local0, Local1)"
Local0 = 0x22224444
Local1 = ~Local0
If ((Local0 != 0x22224444))
{
ERR (0x02, 0x06E1)
}
If ((Local1 != 0xDDDDBBBB))
{
ERR (0x01, 0x06E6)
}
Return (Local7)
}
Method (LOGS, 0, NotSerialized)
{
Debug = "++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)"
Local0 = (0xFFFFFFFF && 0x11111111)
Debug = "++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)"
Local1 = (0xFFFFFFFF == 0x11111111)
Debug = "++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)"
Local2 = (0xFFFFFFFF > 0x11111111)
Debug = "++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)"
Local3 = (0xFFFFFFFF >= 0x11111111)
Debug = "++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)"
Local4 = (0xFFFFFFFF < 0x11111111)
Debug = "++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)"
Local5 = (0xFFFFFFFF <= 0x11111111)
Debug = "++++++++ Store (LNot (0x31313131), Local6)"
Local6 = 0x1111
Local7 = !Local6
If ((Local6 != 0x1111))
{
ERR (0x02, 0x0707)
}
If ((Local7 != 0x00))
{
ERR (0x01, 0x070C)
}
Debug = "++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)"
Local7 = (0xFFFFFFFF != 0x11111111)
Debug = "++++++++ Lor (0x0, 0x1)"
If ((0x00 || 0x01))
{
Debug = "+_+_+_+_+ Lor (0x0, 0x1) returned TRUE"
}
Return (Local7)
}
Method (COND, 0, NotSerialized)
{
Debug = "++++++++ Store (0x4, Local0)"
Local0 = 0x04
Debug = "++++++++ While (Local0)"
While (Local0)
{
Debug = "++++++++ Decrement (Local0)"
Local0--
}
Debug = "++++++++ Store (0x3, Local6)"
Local6 = 0x03
Debug = "++++++++ While (Subtract (Local6, 1))"
While ((Local6 - 0x01))
{
Debug = "++++++++ Decrement (Local6)"
Local6--
}
Debug = "++++++++ [LVL1] If (LGreater (0x2, 0x1))"
If ((0x02 > 0x01))
{
Debug = "++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))"
If ((0x11111111 == 0x22222222))
{
Debug = "++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE"
}
Else
{
Debug = "++++++++ [LVL3] If (LNot (0x0))"
If (!0x00)
{
Debug = "++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))"
If ((0xEEEEEEEE && 0x02))
{
Debug = "++++++++ [LVL5] If (LLess (0x44444444, 0x3))"
If ((0x44444444 < 0x03))
{
Debug = "++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE"
}
Else
{
Debug = "++++++++ Exiting from nested IF/ELSE statements"
}
}
}
}
}
Debug = "++++++++ [LVL1] If (LGreater (0x2, 0x1))"
If ((0x02 > 0x01))
{
Debug = "++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))"
If ((0x11111111 == 0x22222222))
{
Debug = "++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE"
}
Else
{
Debug = "++++++++ [LVL3] If (LNot (0x0))"
If (!0x00)
{
Debug = "++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))"
If ((0xEEEEEEEE && 0x02))
{
Debug = "++++++++ [LVL5] If (LLess (0x44444444, 0x3))"
If ((0x44444444 < 0x03))
{
Debug = "++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE"
}
Else
{
Debug = "++++++++ Returning from nested IF/ELSE statements"
Return (Local6)
}
}
}
}
}
}
Method (REFS, 0, Serialized)
{
Name (BBUF, Buffer (0x08)
{
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7 // ........
})
Name (NEST, Package (0x02)
{
Package (0x06)
{
0x01,
0x02,
0x03,
0x04,
0x05,
0x06
},
Package (0x06)
{
0x11,
0x12,
0x12,
0x14,
0x15,
0x16
}
})
Local5 = RefOf (MAIN)
/* For this to work, ABCD must NOT exist. */
Local1 = CondRefOf (ABCD, Local0)
If ((Local1 != 0x00))
{
ERR (0x02, 0x0791)
}
Local1 = CondRefOf (BBUF, Local0)
If ((Local1 != Ones))
{
ERR (0x02, 0x0797)
}
Local6 = DerefOf (BBUF [0x03])
If ((Local6 != 0xB3))
{
ERR (0x02, 0x079D)
}
Local0 = DerefOf (DerefOf (NEST [0x01]) [0x03])
If ((Local0 != 0x14))
{
ERR (0x02, 0x07A3)
}
Local0 = 0x11223344
Local1 = RefOf (Local0)
Local2 = DerefOf (Local1)
If ((Local2 != 0x11223344))
{
ERR (0x02, 0x07AD)
}
/* Parser thinks this is a method invocation!! */
/* RefOf (MAIN) */
/* RefOf (R___) */
/* RefOf (BBUF) */
/* Store (RefOf (Local0), Local1) */
/* CondRefOf (BBUF, Local2) */
/* CondRefOf (R___, Local3) */
/* Store (DerefOf (Local1), Local4) */
/* Return (Local4) */
}
Method (INDX, 0, Serialized)
{
Name (STAT, Package (0x04){})
STAT [0x00] = 0x44443333
}
/*================================================================= */
/*================================================================= */
/*===================== iPCO TESTS ================================ */
/*================================================================= */
/*================================================================= */
/* */
/* */
/* test IfElseOp.asl */
/* */
/* test for IfOp and ElseOp, including validation of object stack cleanup */
/* */
Device (IFEL)
{
Name (DWRD, 0x01)
Name (RSLT, 0x00)
/* IFNR control method executes IfOp branch with NO nested Return */
/* and no Else branch */
Method (IFNR, 0, NotSerialized)
{
RSLT = DWRD /* \IFEL.DWRD */
If ((DWRD == 0x01))
{
RSLT = 0x00
}
} /* IFNR */
/* NINR control method does not execute If branch and has no Else branch */
Method (NINR, 0, NotSerialized)
{
RSLT = 0x00
If ((DWRD != 0x01))
{
RSLT = DWRD /* \IFEL.DWRD */
}
} /* NINR */
/* IENR control method executes IfOp branch with NO nested Return */
Method (IENR, 0, NotSerialized)
{
If ((DWRD == 0x01))
{
RSLT = 0x00
}
Else
{
RSLT = DWRD /* \IFEL.DWRD */
}
} /* IENR */
/* ELNR control method executes ElseOp branch with NO nested Return */
Method (ELNR, 0, NotSerialized)
{
If ((DWRD != 0x01))
{
RSLT = DWRD /* \IFEL.DWRD */
}
Else
{
RSLT = 0x00
}
} /* ELNR */
/* IFRT control method executes IfOp branch with nested Return with */
/* no Else branch */
Method (IFRT, 0, NotSerialized)
{
If ((DWRD == 0x01))
{
Return (0x00)
}
Return (DWRD) /* \IFEL.DWRD */
} /* IFRT */
/* IERT control method executes IfOp branch with nested Return with */
/* Else branch */
Method (IERT, 0, NotSerialized)
{
If ((DWRD == 0x01))
{
Return (0x00)
}
Else
{
Return (DWRD) /* \IFEL.DWRD */
}
} /* IERT */
/* ELRT control method executes ElseOp branch with nested Return */
Method (ELRT, 0, NotSerialized)
{
If ((DWRD != 0x01))
{
Return (DWRD) /* \IFEL.DWRD */
}
Else
{
Return (0x00)
}
} /* ELRT */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IfElseOp Test"
/* IfOp with NO return value */
IFNR ()
If ((RSLT != 0x00))
{
Return (RSLT) /* \IFEL.RSLT */
}
/* IfOp with NO return value */
NINR ()
If ((RSLT != 0x00))
{
Return (RSLT) /* \IFEL.RSLT */
}
/* IfOp with NO return value */
IENR ()
If ((RSLT != 0x00))
{
Return (RSLT) /* \IFEL.RSLT */
}
/* ElseOp with NO return value */
ELNR ()
If ((RSLT != 0x00))
{
Return (RSLT) /* \IFEL.RSLT */
}
/* IfOp with return value */
RSLT = IFRT ()
If ((RSLT != 0x00))
{
Return (RSLT) /* \IFEL.RSLT */
}
/* IfOp with return value */
RSLT = IERT ()
If ((RSLT != 0x00))
{
Return (RSLT) /* \IFEL.RSLT */
}
/* ElseOp with return value */
RSLT = ELRT ()
If ((RSLT != 0x00))
{
Return (RSLT) /* \IFEL.RSLT */
}
Return (0x00)
} /* TEST */
} /* IFEL */
/* */
/* test NoSave.asl */
/* */
/* */
/* Internal test cases to validate IfOp (Operator (,,)) where Operator */
/* target is ZeroOp to throw away the results. */
/* Includes internal test cases for logical operators with no destination */
/* operands. */
/* */
Device (NOSV)
{
Method (TEST, 0, Serialized)
{
Debug = "++++++++ NoSave Test"
Name (WRD, 0x1234)
/* */
/* Begin test of nested operators without saving results */
/* */
/* Test If (And ()) with no save of And result */
If ((0x03 & 0x01))
{
WRD = 0x01 /* pass -- just do something */
}
Else
{
Return (0x01) /* fail */
}
/* Test If (And ()) with no save of And result */
If ((0x04 & 0x01))
{
Return (0x02) /* fail */
}
Else
{
WRD = 0x02 /* pass -- just do something */
}
/* Test If (NAnd ()) with no save of NAnd result */
If (NAnd (0x03, 0x01))
{
WRD = 0x03 /* pass -- just do something */
}
Else
{
Return (0x03) /* fail */
}
/* Test If (NAnd ()) with no save of NAnd result */
If (NAnd (0xFFFFFFFF, 0xFFFFFFFF))
{
Return (0x04) /* fail */
}
Else
{
WRD = 0x04 /* pass -- just do something */
}
/* Test If (NOr ()) with no save of NOr result */
If (NOr (0x00, 0x01))
{
WRD = 0x05 /* pass -- just do something */
}
Else
{
Return (0x05) /* fail */
}
/* Test If (NOr ()) with no save of NOr result */
If (NOr (0xFFFFFFFE, 0x01))
{
Return (0x06) /* fail */
}
Else
{
WRD = 0x06 /* pass -- just do something */
}
/* Test If (Not ()) with no save of Not result */
If (~0x01)
{
WRD = 0x07 /* pass -- just do something */
}
Else
{
Return (0x07) /* fail */
}
/* Test If (Not ()) with no save of Not result */
If (~0xFFFFFFFF)
{
Return (0x08) /* fail */
}
Else
{
WRD = 0x08 /* pass -- just do something */
}
/* Test If (Or ()) with no save of Or result */
If ((0x03 | 0x01))
{
WRD = 0x09 /* pass -- just do something */
}
Else
{
Return (0x09) /* fail */
}
/* Test If (Or ()) with no save of Or result */
If ((0x00 | 0x00))
{
Return (0x0A) /* fail */
}
Else
{
WRD = 0x0A /* pass -- just do something */
}
/* Test If (XOr ()) with no save of XOr result */
If ((0x03 ^ 0x01))
{
WRD = 0x0B /* pass -- just do something */
}
Else
{
Return (0x0B) /* fail */
}
/* Test If (XOr ()) with no save of XOr result */
If ((0x03 ^ 0x03))
{
Return (0x0C) /* fail */
}
Else
{
WRD = 0x0C /* pass -- just do something */
}
/* */
/* Begin test of logical operators with no destination operands */
/* */
/* Test If (LAnd ()) with no save of LAnd result */
If ((0x03 && 0x03))
{
WRD = 0x15 /* pass -- just do something */
}
Else
{
Return (0x15) /* fail */
}
/* Test If (LAnd ()) with no save of LAnd result */
If ((0x03 && 0x00))
{
Return (0x16) /* fail */
}
Else
{
WRD = 0x16 /* pass -- just do something */
}
/* Test If (LAnd ()) with no save of LAnd result */
If ((0x00 && 0x03))
{
Return (0x17) /* fail */
}
Else
{
WRD = 0x17 /* pass -- just do something */
}
/* Test If (LAnd ()) with no save of LAnd result */
If ((0x00 && 0x00))
{
Return (0x18) /* fail */
}
Else
{
WRD = 0x18 /* pass -- just do something */
}
/* Test If (LEqual ()) with no save of LEqual result */
If ((0x03 == 0x03))
{
WRD = 0x1F /* pass -- just do something */
}
Else
{
Return (0x1F) /* fail */
}
/* Test If (LEqual ()) with no save of LEqual result */
If ((0x01 == 0x03))
{
Return (0x20) /* fail */
}
Else
{
WRD = 0x20 /* pass -- just do something */
}
/* Test If (LGreater ()) with no save of LGreater result */
If ((0x03 > 0x01))
{
WRD = 0x29 /* pass -- just do something */
}
Else
{
Return (0x29) /* fail */
}
/* Test If (LGreater ()) with no save of LGreater result */
If ((0x04 > 0x04))
{
Return (0x2A) /* fail */
}
Else
{
WRD = 0x2A /* pass -- just do something */
}
/* Test If (LGreater ()) with no save of LGreater result */
If ((0x01 > 0x04))
{
Return (0x2B) /* fail */
}
Else
{
WRD = 0x2B /* pass -- just do something */
}
/* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */
If ((0x03 >= 0x01))
{
WRD = 0x2C /* pass -- just do something */
}
Else
{
Return (0x2C) /* fail */
}
/* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */
If ((0x03 >= 0x03))
{
WRD = 0x2D /* pass -- just do something */
}
Else
{
Return (0x2D) /* fail */
}
/* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */
If ((0x03 >= 0x04))
{
Return (0x2E) /* fail */
}
Else
{
WRD = 0x2E /* pass -- just do something */
}
/* Test If (LLess ()) with no save of LLess result */
If ((0x01 < 0x03))
{
WRD = 0x33 /* pass -- just do something */
}
Else
{
Return (0x33) /* fail */
}
/* Test If (LLess ()) with no save of LLess result */
If ((0x02 < 0x02))
{
Return (0x34) /* fail */
}
Else
{
WRD = 0x34 /* pass -- just do something */
}
/* Test If (LLess ()) with no save of LLess result */
If ((0x04 < 0x02))
{
Return (0x35) /* fail */
}
Else
{
WRD = 0x35 /* pass -- just do something */
}
/* Test If (LLessEqual ()) with no save of LLessEqual result */
If ((0x01 <= 0x03))
{
WRD = 0x36 /* pass -- just do something */
}
Else
{
Return (0x36) /* fail */
}
/* Test If (LLessEqual ()) with no save of LLessEqual result */
If ((0x02 <= 0x02))
{
WRD = 0x37 /* pass -- just do something */
}
Else
{
Return (0x37) /* fail */
}
/* Test If (LLessEqual ()) with no save of LLessEqual result */
If ((0x04 <= 0x02))
{
Return (0x38) /* fail */
}
Else
{
WRD = 0x38 /* pass -- just do something */
}
/* Test If (LNot ()) with no save of LNot result */
If (!0x00)
{
WRD = 0x3D /* pass -- just do something */
}
Else
{
Return (0x3D) /* fail */
}
/* Test If (LNot ()) with no save of LNot result */
If (!0x01)
{
Return (0x3E) /* fail */
}
Else
{
WRD = 0x3E /* pass -- just do something */
}
/* Test If (LNotEqual ()) with no save of LNotEqual result */
If ((0x03 != 0x03))
{
Return (0x3F) /* fail */
}
Else
{
WRD = 0x3F /* pass -- just do something */
}
/* Test If (LNotEqual ()) with no save of LNotEqual result */
If ((0x01 != 0x03))
{
WRD = 0x40 /* pass -- just do something */
}
Else
{
Return (0x40) /* fail */
}
/* Test If (LOr ()) with no save of LOr result */
If ((0x03 || 0x01))
{
WRD = 0x47 /* pass -- just do something */
}
Else
{
Return (0x47) /* fail */
}
/* Test If (LOr ()) with no save of LOr result */
If ((0x00 || 0x01))
{
WRD = 0x48 /* pass -- just do something */
}
Else
{
Return (0x48) /* fail */
}
/* Test If (LOr ()) with no save of LOr result */
If ((0x03 || 0x00))
{
WRD = 0x49 /* pass -- just do something */
}
Else
{
Return (0x49) /* fail */
}
/* Test If (LOr ()) with no save of LOr result */
If ((0x00 || 0x00))
{
Return (0x4A) /* fail */
}
Else
{
WRD = 0x4A /* pass -- just do something */
}
Return (0x00)
} /* TEST */
} /* NOSV */
/* */
/* test IndxFld.asl */
/* */
/* IndexFld test */
/* This is just a subset of the many RegionOp/Index Field test cases. */
/* Tests index field element AccessAs macro. */
/* */
Device (IDXF)
{
/* Test device name */
OperationRegion (SIO, SystemIO, 0x0100, 0x02)
Field (SIO, ByteAcc, NoLock, Preserve)
{
INDX, 8,
DATA, 8
}
IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
{
AccessAs (ByteAcc, 0x00),
IFE0, 8,
IFE1, 8,
IFE2, 8,
IFE3, 8,
IFE4, 8,
IFE5, 8,
IFE6, 8,
IFE7, 8,
IFE8, 8,
IFE9, 8
}
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IndxFld Test"
Local0 = IFE0 /* \IDXF.IFE0 */
Local1 = IFE1 /* \IDXF.IFE1 */
Local2 = IFE2 /* \IDXF.IFE2 */
Return (0x00)
} /* TEST */
} /* IDXF */
/* */
/* test NestdLor.asl */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
Name (ZER0, 0x00)
Name (ZER1, 0x00)
Name (ZER2, 0x00)
Name (ONE0, 0x01)
Device (NSTL)
{
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ NestdLor Test"
If ((ZER0 || (ZER1 || (ZER2 || ONE0))))
{
/* Indicate Pass */
Local0 = 0x00
}
Else
{
/* Indicate Fail */
Local0 = 0x01
}
Return (Local0)
} /* End Method TEST */
} /* Device NSTL */
} /* _SB system bus */
/* */
/* test RetBuf.asl */
/* */
/* Test ReturnOp(Buffer) */
/* This is required to support Control Method Batteries on */
/* Dell Latitude Laptops (e.g., CP1-A) */
/* */
Device (RTBF)
{
Method (SUBR, 1, NotSerialized)
{
Return (Arg0)
}
Method (RBUF, 0, Serialized)
{
/* RBUF: Return Buffer from local variable */
Name (ABUF, Buffer (0x11)
{
"ARBITRARY_BUFFER"
})
/* store local buffer ABUF into Local0 */
Local0 = ABUF /* \RTBF.RBUF.ABUF */
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Buffer */
If ((Local1 != 0x03)) /* Buffer type is 3 */
{
Return (0x01) /* failure */
}
/* store value returned by control method SUBR into Local0 */
Local0 = SUBR (ABUF)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Buffer */
If ((Local1 != 0x03)) /* Buffer type is 3 */
{
Return (0x02) /* failure */
}
/* allocate buffer using Local1 as buffer size (run-time evaluation) */
Local1 = 0x05
Name (BUFR, Buffer (Local1){})
/* store value returned by control method SUBR into Local0 */
Local0 = SUBR (BUFR)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Buffer */
If ((Local1 != 0x03)) /* Buffer type is 3 */
{
Return (0x03) /* failure */
}
/* store BUFR Buffer into Local0 */
Local0 = BUFR /* \RTBF.RBUF.BUFR */
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Buffer */
If ((Local1 != 0x03)) /* Buffer type is 3 */
{
Return (0x04) /* failure */
}
/* return Local0 Buffer */
Return (Local0)
} /* RBUF */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ RetBuf Test"
/* store RBUF Buffer return value into Local0 */
Local0 = RBUF ()
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Buffer */
If ((Local1 != 0x03)) /* Buffer type is 3 */
{
Return (0x0A) /* failure */
}
Else
{
Return (0x00) /* success */
}
} /* TEST */
} /* RTBF */
/* */
/* test RetLVal.asl */
/* */
/* Test ReturnOp(Lvalue) */
/* This is required to support _PSR on IBM ThinkPad 560D and */
/* _DCK on Toshiba Tecra 8000. */
/* */
Device (GPE2)
{
Method (_L03, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
Debug = "Method GPE2._L03 invoked"
Return (Zero)
}
Method (_E05, 0, NotSerialized) // _Exx: Edge-Triggered GPE
{
Debug = "Method GPE2._E05 invoked"
Return (Zero)
}
}
Device (PRW2)
{
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
Package (0x02)
{
\GPE2,
0x05
},
0x03
})
}
Scope (\_GPE)
{
Name (ACST, 0xFF)
Method (_L08, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
Debug = "Method _GPE._L08 invoked"
Return (Zero)
}
Method (_E09, 0, NotSerialized) // _Exx: Edge-Triggered GPE
{
Debug = "Method _GPE._E09 invoked"
Return (Zero)
}
Method (_E11, 0, NotSerialized) // _Exx: Edge-Triggered GPE
{
Debug = "Method _GPE._E11 invoked"
Notify (\PRW1, 0x02) // Device Wake
}
Method (_L22, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
Debug = "Method _GPE._L22 invoked"
Return (Zero)
}
Method (_L33, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
Debug = "Method _GPE._L33 invoked"
Return (Zero)
}
Method (_E64, 0, NotSerialized) // _Exx: Edge-Triggered GPE
{
Debug = "Method _GPE._E64 invoked"
Return (Zero)
}
} /* _GPE */
Device (PRW1)
{
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x11,
0x03
})
}
Device (PWRB)
{
Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x33,
0x03
})
}
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
Device (ACAD)
{
/* ACAD: AC adapter device */
Name (_HID, "ACPI0003" /* Power Source Device */) /* AC adapter device */ // _HID: Hardware ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
OperationRegion (AREG, SystemIO, 0x0372, 0x02)
Field (AREG, ByteAcc, NoLock, Preserve)
{
AIDX, 8,
ADAT, 8
}
IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
{
, 1,
ACIN, 1,
, 2,
CHAG, 1,
Offset (0x01),
, 7,
ABAT, 1
} /* IndexField */
Method (_PSR, 0, NotSerialized) // _PSR: Power Source
{
Local0 = \_GPE.ACST
Local1 = ACIN /* \_SB_.ACAD.ACIN */
If ((\_GPE.ACST != Local1))
{
\_GPE.ACST = Local1
/* This Notify is commented because it causes a */
/* method error when running on a system without the */
/* specific device. */
/* Notify (\_SB_.ACAD, 0) */
}
Return (Local0)
} /* _PSR */
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
\_GPE.ACST = ACIN /* \_SB_.ACAD.ACIN */
}
} /* ACAD: AC adapter device */
/* test implicit return from control method */
Method (DIS, 1, NotSerialized)
{
Local0 = Arg0
}
Device (RTLV)
{
/* test implicit return inside nested if with explicit return of Lvalue */
Method (_DCK, 1, NotSerialized) // _DCK: Dock Present
{
If (Arg0)
{
/* dock */
Local0 = 0x87
If (Local0)
{
DIS (0x23)
Return (0x01)
}
Return (0x00)
} /* dock */
Else
{
/* undock */
Local0 = Arg0
If (Local0)
{
DIS (0x23)
Return (0x01)
}
Return (0x00)
} /* undock */
} /* _DCK control method */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ RetLVal Test"
/* store _PSR return value into Local0 */
Local0 = \_SB.ACAD._PSR ()
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number/Integer type is 1 */
{
Return (0x01) /* failure */
}
/* test implicit return inside nested if with explicit return of Lvalue */
Local2 = _DCK (0x01)
/* save Local2 object type value into Local3 */
Local3 = ObjectType (Local2)
/* validate Local2 is a Number */
If ((Local3 != 0x01)) /* Number/Integer type is 1 */
{
Return (0x02) /* failure */
}
If ((Local2 != 0x01))
{
Return (0x03) /* failure */
}
Return (0x00) /* success */
} /* TEST */
} /* RTLV */
} /* _SB system bus */
/* */
/* test RetPkg.asl */
/* */
/* Test ReturnOp(Package) */
/* This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1) */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
Device (LNKA)
{
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
Name (_UID, 0x01) // _UID: Unique ID
}
Device (LNKB)
{
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
Name (_UID, 0x02) // _UID: Unique ID
}
Device (LNKC)
{
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
Name (_UID, 0x03) // _UID: Unique ID
}
Device (LNKD)
{
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
Name (_UID, 0x04) // _UID: Unique ID
}
Device (PCI1)
{
/* PCI1: Root PCI Bus */
Name (_HID, "PNP0A03" /* PCI Bus */) /* Need _HID for root device (String format) */ // _HID: Hardware ID
Name (_ADR, 0x00) // _ADR: Address
Name (_CRS, 0x00) // _CRS: Current Resource Settings
Name (_PRT, Package (0x0C) // _PRT: PCI Routing Table
{
Package (0x04)
{
0x0004FFFF,
0x00,
LNKA,
0x00
}, /* Slot 1, INTA */
Package (0x04)
{
0x0004FFFF,
0x01,
LNKB,
0x00
}, /* Slot 1, INTB */
Package (0x04)
{
0x0004FFFF,
0x02,
LNKC,
0x00
}, /* Slot 1, INTC */
Package (0x04)
{
0x0004FFFF,
0x03,
LNKD,
0x00
}, /* Slot 1, INTD */
Package (0x04)
{
0x0005FFFF,
0x00,
\_SB.LNKB,
0x00
}, /* Slot 2, INTA */
Package (0x04)
{
0x0005FFFF,
0x01,
\_SB.LNKC,
0x00
}, /* Slot 2, INTB */
Package (0x04)
{
0x0005FFFF,
0x02,
\_SB.LNKD,
0x00
}, /* Slot 2, INTC */
Package (0x04)
{
0x0006FFFF,
0x03,
\_SB.LNKA,
0x00
}, /* Slot 2, INTD */
Package (0x04)
{
0x0006FFFF,
0x00,
LNKC,
0x00
}, /* Slot 3, INTA */
Package (0x04)
{
0x0006FFFF,
0x01,
LNKD,
0x00
}, /* Slot 3, INTB */
Package (0x04)
{
0x0006FFFF,
0x02,
LNKA,
0x00
}, /* Slot 3, INTC */
Package (0x04)
{
0x0006FFFF,
0x03,
LNKB,
0x00
} /* Slot 3, INTD */
})
Device (PX40)
{
/* Map f0 space, Start PX40 */
Name (_ADR, 0x00070000) /* Address+function. */ // _ADR: Address
}
} /* PCI0: Root PCI Bus */
Device (RETP)
{
Method (RPKG, 0, NotSerialized)
{
/* RPKG: Return Package from local variable */
/* store _PRT package into Local0 */
Local0 = \_SB.PCI1._PRT
/* return Local0 Package */
Return (Local0)
} /* RPKG */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ RetPkg Test"
/* store RPKG package return value into Local0 */
Local0 = RPKG ()
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Package */
If ((Local1 != 0x04)) /* Package type is 4 */
{
Return (0x01)
} /* failure */
Else
{
Return (0x00)
} /* success */
} /* TEST */
} /* RETP */
} /* _SB_ */
/* */
/* test WhileRet.asl */
/* */
/* WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp. */
/* */
Device (WHLR)
{
Name (LCNT, 0x00)
Method (WIR, 0, NotSerialized)
{
/* WIR: control method that returns inside of IfOp inside of WhileOp */
While ((LCNT < 0x04))
{
If ((LCNT == 0x02))
{
Return (0x00)
}
LCNT++
}
Return (LCNT) /* \WHLR.LCNT */
} /* WIR: control method that returns inside of IfOp inside of WhileOp */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ WhileRet Test"
Local0 = WIR ()
Return (Local0)
} /* TEST */
} /* WHLR */
/* */
/* test AndOrOp.asl */
/* */
/*This code tests the bitwise AndOp and OrOp Operator terms */
/* */
/*Syntax of Andop term */
/*And - Bitwise And */
/*AndTerm := And( */
/* Source1, //TermArg=>Integer */
/* Source2, //TermArg=>Integer */
/* Result //Nothing | SuperName */
/*) => Integer */
/*Source1 and Source2 are evaluated as integer data types, */
/* a bit-wise AND is performed, and the result is optionally */
/*stored into Result. */
/* */
/* */
/*Syntax of OrOp */
/*Or - Bit-wise Or */
/*OrTerm := Or( */
/* Source1, //TermArg=>Integer */
/* Source2 //TermArg=>Integer */
/* Result //Nothing | SuperName */
/*) => Integer */
/*Source1 and Source2 are evaluated as integer data types, */
/* a bit-wide OR is performed, and the result is optionally */
/*stored in Result */
/* */
Device (ANDO)
{
OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
Field (TMEM, ByteAcc, NoLock, Preserve)
{
, 3,
TOUD, 13
}
/*Create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
}/* Field(RAM) */
/*And with Byte Data */
Name (BYT1, 0xFF)
Name (BYT2, 0xFF)
Name (BRSL, 0x00)
/*And with Word Data */
Name (WRD1, 0xFFFF)
Name (WRD2, 0xFFFF)
Name (WRSL, 0x00)
/*And with DWord Data */
Name (DWD1, 0xFFFFFFFF)
Name (DWD2, 0xFFFFFFFF)
Name (DRSL, 0x00)
Method (ANDP, 0, NotSerialized)
{
/*Check with 1 And 1 on byte data */
BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */
If ((BRSL != 0xFF))
{
Return (0x01)
}
/*Check with 1 And 1 on Word data */
WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */
If ((WRSL != 0xFFFF))
{
Return (0x01) /* failure */
}
/*Check with 1 And 1 Dword */
DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */
If ((DRSL != 0xFFFFFFFF))
{
Return (0x01) /* failure */
}
/*Check with 0 And 0 on byte data */
BYT1 = 0x00
BYT2 = 0x00
BRSL = 0x00
BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */
If ((BRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 0 And 0 on Word data */
WRD1 = 0x00
WRD2 = 0x00
WRSL = 0x00
WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */
If ((WRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 0 And 0 Dword */
DWD1 = 0x00
DWD2 = 0x00
DRSL = 0x00
DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */
If ((DRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 1 And 0 on byte data */
BYT1 = 0x55
BYT2 = 0xAA
BRSL = 0x00
BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */
If ((BRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 1 And 0 on Word data */
WRD1 = 0x5555
WRD2 = 0xAAAA
WRSL = 0x00
WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */
If ((WRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 1 And 0 on Dword */
DWD1 = 0x55555555
DWD2 = 0xAAAAAAAA
DRSL = 0x00
DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */
If ((DRSL != 0x00))
{
Return (0x01) /* failure */
}
TOUD = 0x1FFF
Local0 = TOUD /* \ANDO.TOUD */
If ((Local0 != 0x1FFF))
{
Return (0x01) /* failure */
}
/*TBD- Do We need to check for system memory data also for each test case ?? */
Return (0x00)
}/*ANDP */
Method (OROP, 0, NotSerialized)
{
/*Check with 1 Ored with 1 on byte data */
BYT1 = 0xFF
BYT2 = 0xFF
BRSL = 0x00
BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */
If ((BRSL != 0xFF))
{
Return (0x01) /* failure */
}
/*Check with 1 Ored with 1 on Word data */
WRD1 = 0xFFFF
WRD2 = 0xFFFF
WRSL = 0x00
WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */
If ((WRSL != 0xFFFF))
{
Return (0x01) /* failure */
}
/*Check with 1 Ored with 1 on Dword data */
DWD1 = 0xFFFFFFFF
DWD2 = 0xFFFFFFFF
DRSL = 0x00
DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */
If ((DRSL != 0xFFFFFFFF))
{
Return (0x01) /* failure */
}
/*Check with 0 Ored with 0 on byte data */
BYT1 = 0x00
BYT2 = 0x00
BRSL = 0x00
BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */
If ((BRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 0 Ored with 0 on Word data */
WRD1 = 0x00
WRD2 = 0x00
WRSL = 0x00
WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */
If ((WRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 0 Ored with 0 Dword data */
DWD1 = 0x00
DWD2 = 0x00
DRSL = 0x00
DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */
If ((DRSL != 0x00))
{
Return (0x01) /* failure */
}
/*Check with 1 Ored with 0 on byte data */
BYT1 = 0x55
BYT2 = 0xAA
BRSL = 0x00
BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */
If ((BRSL != 0xFF))
{
Return (0x01) /* failure */
}
/*Check with 1 Ored with 0 on Word data */
WRD1 = 0x5555
WRD2 = 0xAAAA
WRSL = 0x00
WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */
If ((WRSL != 0xFFFF))
{
Return (0x01) /* failure */
}
/*Check with 1 Ored with 0 on Dword data */
DWD1 = 0x55555555
DWD2 = 0xAAAAAAAA
DRSL = 0x00
DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */
If ((DRSL != 0xFFFFFFFF))
{
Return (0x01) /* failure */
}
/*TBD - Do We need to check for system memory data also for each test case ?? */
Return (0x00)
}/*OROP */
Method (TEST, 0, Serialized)
{
Debug = "++++++++ AndOrOp Test"
Name (RSLT, 0x01)
/*Call Andop method */
RSLT = ANDP ()
If ((RSLT == 0x01))
{
Return (RSLT) /* \ANDO.TEST.RSLT */
}
/*Call OrOp Method */
RSLT = OROP ()
If ((RSLT == 0x01))
{
Return (RSLT) /* \ANDO.TEST.RSLT */
}
/* */
/* Return original conditions to allow iterative execution */
/* */
BYT1 = 0xFF
BYT2 = 0xFF
BRSL = 0x00
WRD1 = 0xFFFF
WRD2 = 0xFFFF
WRSL = 0x00
DWD1 = 0xFFFFFFFF
DWD2 = 0xFFFFFFFF
DRSL = 0x00
Return (0x00)
} /*TEST */
} /*ANDO */
/* */
/* test BreakPnt.asl */
/* */
/* This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is */
/* BreakPointTerm := BreakPoint */
/* Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger. */
/* In the non-debug version of the interpreter, BreakPoint is equivalent to Noop. */
/* */
Device (BRKP)
{
Name (CNT0, 0x00)
Method (BK1, 0, NotSerialized)
{
BreakPoint
Return (0x00)
}
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ BreakPnt Test"
CNT0 = 0x00
/*Check BreakPoint statement */
While ((CNT0 < 0x0A))
{
CNT0++
}
/*Check the BreakPoint statement */
If ((CNT0 == 0x0A))
{
/* BreakPoint */
Return (0x00)
}
/*failed */
Return (0x01)
}
}
/* */
/* test AddSubOp.asl */
/* */
Device (ADSU)
{
/* create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
} /* Field(RAM) */
Method (TEST, 0, Serialized)
{
Debug = "++++++++ AddSubOp Test"
Name (DWRD, 0x12345678)
Name (WRD, 0x1234)
Name (BYT, 0x12)
/* Test AddOp with DWORD data */
DWRD = 0x12345678
DWRD += 0x07
If ((DWRD != 0x1234567F))
{
Return (DWRD) /* \ADSU.TEST.DWRD */
}
/* Test AddOp with WORD data */
WRD += 0x05
If ((WRD != 0x1239))
{
Return (WRD) /* \ADSU.TEST.WRD_ */
}
/* Test AddOp with BYTE data */
BYT += 0x03
If ((BYT != 0x15))
{
Return (BYT) /* \ADSU.TEST.BYT_ */
}
/* Test SubtractOp with DWORD data */
DWRD -= 0x07
If ((DWRD != 0x12345678))
{
Return (DWRD) /* \ADSU.TEST.DWRD */
}
/* Test SubtractOp with WORD data */
WRD -= 0x03
If ((WRD != 0x1236))
{
Return (WRD) /* \ADSU.TEST.WRD_ */
}
/* Test SubtractOp with BYTE data */
BYT -= 0x03
If ((BYT != 0x12))
{
Return (BYT) /* \ADSU.TEST.BYT_ */
}
/* test AddOp with DWORD SystemMemory OpRegion */
SMDW = 0x01234567
SMDW += 0x08
If ((SMDW != 0x0123456F))
{
Return (SMDW) /* \ADSU.SMDW */
}
/* test SubtractOp with DWORD SystemMemory OpRegion */
SMDW -= 0x07
If ((SMDW != 0x01234568))
{
Return (SMDW) /* \ADSU.SMDW */
}
/* test AddOp with WORD SystemMemory OpRegion */
SMWD = 0x0123
SMWD += 0x06
If ((SMWD != 0x0129))
{
Return (SMWD) /* \ADSU.SMWD */
}
/* test SubtractOp with WORD SystemMemory OpRegion */
SMWD -= 0x05
If ((SMWD != 0x0124))
{
Return (SMWD) /* \ADSU.SMWD */
}
/* test AddOp with BYTE SystemMemory OpRegion */
SMBY = 0x01
SMBY += 0x04
If ((SMBY != 0x05))
{
Return (SMBY) /* \ADSU.SMBY */
}
/* test SubtractOp with BYTE SystemMemory OpRegion */
SMBY -= 0x03
If ((SMBY != 0x02))
{
Return (SMBY) /* \ADSU.SMBY */
}
Return (0x00)
} /* TEST */
} /* ADSU */
/* */
/* test IncDecOp.asl */
/* */
Device (INDC)
{
/* create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
} /* Field(RAM) */
Method (TEST, 0, Serialized)
{
Debug = "++++++++ IncDecOp Test"
Name (DWRD, 0x12345678)
Name (WRD, 0x1234)
Name (BYT, 0x12)
/* Test IncrementOp with DWORD data */
DWRD = 0x12345678
DWRD++
If ((DWRD != 0x12345679))
{
Return (DWRD) /* \INDC.TEST.DWRD */
}
/* Test IncrementOp with WORD data */
WRD++
If ((WRD != 0x1235))
{
Return (WRD) /* \INDC.TEST.WRD_ */
}
/* Test IncrementOp with BYTE data */
BYT++
If ((BYT != 0x13))
{
Return (BYT) /* \INDC.TEST.BYT_ */
}
/* Test DecrementOp with DWORD data */
DWRD--
If ((DWRD != 0x12345678))
{
Return (DWRD) /* \INDC.TEST.DWRD */
}
/* Test DecrementOp with WORD data */
WRD--
If ((WRD != 0x1234))
{
Return (WRD) /* \INDC.TEST.WRD_ */
}
/* Test DecrementOp with BYTE data */
BYT--
If ((BYT != 0x12))
{
Return (BYT) /* \INDC.TEST.BYT_ */
}
/* test IncrementOp with DWORD SystemMemory OpRegion */
SMDW = 0x01234567
SMDW++
If ((SMDW != 0x01234568))
{
Return (SMDW) /* \INDC.SMDW */
}
/* test DecrementOp with DWORD SystemMemory OpRegion */
SMDW--
If ((SMDW != 0x01234567))
{
Return (SMDW) /* \INDC.SMDW */
}
/* test IncrementOp with WORD SystemMemory OpRegion */
SMWD = 0x0123
SMWD++
If ((SMWD != 0x0124))
{
Return (SMWD) /* \INDC.SMWD */
}
/* test DecrementOp with WORD SystemMemory OpRegion */
SMWD--
If ((SMWD != 0x0123))
{
Return (SMWD) /* \INDC.SMWD */
}
/* test IncrementOp with BYTE SystemMemory OpRegion */
SMBY = 0x01
SMBY++
If ((SMBY != 0x02))
{
Return (SMBY) /* \INDC.SMBY */
}
/* test DecrementOp with BYTE SystemMemory OpRegion */
SMBY--
If ((SMBY != 0x01))
{
Return (SMBY) /* \INDC.SMBY */
}
Return (0x00)
} /* TEST */
} /* INDC */
/* */
/* test LOps.asl */
/* */
/*This source tests all the logical operators. Logical operators in ASL are as follows. */
/*LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr. */
/* Success will return 0 and failure will return a non zero number. Check the source code for */
/* non zero number to find where the test failed */
Device (LOPS)
{
/*Create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
}/* Field(RAM) */
/*And with Byte Data */
Name (BYT1, 0xFF)
Name (BYT2, 0xFF)
Name (BRSL, 0x00)
/*And with Word Data */
Name (WRD1, 0xFFFF)
Name (WRD2, 0xFFFF)
Name (WRSL, 0x00)
/*And with DWord Data */
Name (DWD1, 0xFFFFFFFF)
Name (DWD2, 0xFFFFFFFF)
Name (DRSL, 0x00)
Name (RSLT, 0x01)
Method (ANDL, 2, NotSerialized)
{
/*test with the arguments passed */
If ((Arg0 == Arg1))
{
RSLT = (Arg0 && Arg1)
If ((Ones != RSLT))
{
Return (0x0B)
}
}
/*test with he locals */
Local0 = Arg0
Local1 = Arg1
If ((Local0 == Local1))
{
RSLT = (Local0 && Local1)
If ((Ones != RSLT))
{
Return (0x0C)
}
}
/*test with BYTE data */
If ((BYT1 == BYT2))
{
BRSL = (BYT1 && BYT2)
If ((Ones != BRSL))
{
Return (0x0D)
}
}
/*test with WORD data */
If ((WRD1 == WRD2))
{
WRSL = (WRD1 && WRD2)
If ((Ones != WRSL))
{
Return (0x0E)
}
}
/*test with DWORD data */
If ((DWD1 == DWD2))
{
DRSL = (DWD1 && DWD2)
If ((Ones != DRSL))
{
Return (0x0F)
}
}
/*Test for system memory data for each test case. */
BYT1 = 0xFF
SMBY = 0xFF
BRSL = 0x00
/*test with BYTE system memory data */
If ((BYT1 == SMBY))
{
BRSL = (BYT1 && SMBY)
If ((Ones != BRSL))
{
Return (0x10)
}
}
WRD1 = 0xFFFF
SMWD = 0xFFFF
WRSL = 0x00
/*test with WORD system memory data */
If ((WRD1 == SMWD))
{
WRSL = (WRD1 && SMWD)
If ((Ones != WRSL))
{
Return (0x11)
}
}
DRSL = 0x00
DWD1 = 0x00FFFFFF
SMDW = 0x00FFFFFF
/*test with DWORD system memory data */
If ((DWD1 == SMDW))
{
DRSL = (DWD1 && SMDW)
If ((Ones != DRSL))
{
Return (0x12)
}
}
Return (0x00)
}/*ANDL */
/*Test the LOr Operator */
Method (ORL, 2, NotSerialized)
{
/*ORL_ */
/*test with the arguments passed */
If ((Arg0 == Arg1))
{
RSLT = (Arg0 || Arg1)
If ((Ones != RSLT))
{
Return (0x15)
}
}
/*test with he locals */
Local0 = Arg0
Local1 = Arg1
If ((Local0 == Local1))
{
RSLT = (Local0 || Local1)
If ((Ones != RSLT))
{
Return (0x16)
}
}
/*Check with 1 LOred with 0 on byte data */
BYT1 = 0xFF
BYT2 = 0x00
BRSL = 0x00
If ((BYT1 != BYT2))
{
BRSL = (BYT1 || BYT2)
If ((Ones != BRSL))
{
Return (0x17)
}
}
/*Check with 1 LOred with 0 on WORD data */
WRD1 = 0xFFFF
WRD2 = 0x00
WRSL = 0x00
If ((WRD1 != WRD2))
{
WRSL = (WRD1 || WRD2)
If ((Ones != WRSL))
{
Return (0x18)
}
}
/*Check with 1 LOred with 0 on DWORD data */
DWD1 = 0xFFFFFFFF
DWD2 = 0x00
DRSL = 0x00
If ((DWD1 != DWD2))
{
DRSL = (DWD1 || DWD2)
If ((Ones != DRSL))
{
Return (0x19)
}
}
BYT1 = 0x00
SMBY = 0xFF
BRSL = 0x00
/*test with BYTE system memory data */
If ((BYT1 == SMBY))
{
BRSL = (BYT1 || SMBY)
If ((Ones != BRSL))
{
Return (0x1A)
}
}
WRD1 = 0x00
SMWD = 0xFFFF
WRSL = 0x00
/*test with WORD system memory data */
If ((WRD1 == SMWD))
{
WRSL = (WRD1 || SMWD)
If ((Ones != WRSL))
{
Return (0x1B)
}
}
DWD1 = 0x00
SMDW = 0xFFFFFFFF
DRSL = 0x00
/*test with DWORD system memory data */
If ((DWD1 == SMDW))
{
DRSL = (DWD1 && SMDW)
If ((Ones != DRSL))
{
Return (0x1C)
}
}
Return (0x00)
}/*ORL_ */
/*This method tests LGreater and LNot operator */
Method (LSGR, 2, NotSerialized)
{
/*LSGR */
/*Test on arguements passed */
/*in test data, Arg1 > Arg0 */
If ((Ones == (Arg1 <= Arg0)))
{
Return (0x1F)
}
/*test LLessEqual */
If ((Ones == !(Arg1 >= Arg0)))
{
Return (0x20)
}
If ((Ones == (Arg1 < Arg0)))
{
Return (0x21)
}
/*test LLessEqual */
If ((Ones == (Arg1 <= Arg0)))
{
Return (0x22)
}
Local0 = Arg0
Local1 = Arg1
/*test with the locals */
If ((Local1 <= Local0))
{
Return (0x23)
}
/*test on Byte data */
BYT1 = 0x12
BYT2 = 0x21
If ((BYT2 <= BYT1))
{
Return (0x24)
}
If ((BYT1 >= BYT2))
{
Return (0x25)
}
/*test LGreaterEqual with byte data */
If (!(BYT2 >= BYT1))
{
Return (0x26)
}
/*test LLessEqual byte data */
If (!(BYT1 <= BYT2))
{
Return (0x27)
}
/*test on Word data */
WRD1 = 0x1212
WRD2 = 0x2121
If ((WRD2 <= WRD1))
{
Return (0x0136)
}
If ((WRD1 >= WRD2))
{
Return (0x0137)
}
/*Test LGreaterEqual with Word Data */
If (!(WRD2 >= WRD1))
{
Return (0x0138)
}
/*Test LLessEqual with Word Data */
If (!(WRD1 <= WRD2))
{
Return (0x0139)
}
/*test on DWord data */
DWD1 = 0x12121212
DWD2 = 0x21212121
If ((DWD2 <= DWD1))
{
Return (0x013A)
}
If ((DWD1 >= DWD2))
{
Return (0x013B)
}
/*Test LGreaterEqual with Dword */
If (!(DWD2 >= DWD1))
{
Return (0x013C)
}
/*Test LLessEqual DWord */
If (!(DWD1 <= DWD2))
{
Return (0x013D)
}
Return (0x00)
}/*LSGR */
/*The test method */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ LOps Test"
RSLT = 0x00
/*Call LAndOp method */
RSLT = ANDL (0x02, 0x02)
If ((RSLT != 0x00))
{
Return (RSLT) /* \LOPS.RSLT */
}
/*Call LOrOp Method */
RSLT = ORL (0x05, 0x05)
If ((RSLT != 0x00))
{
Return (RSLT) /* \LOPS.RSLT */
}
/*Call LSGR Method */
RSLT = LSGR (0x05, 0x07)
If ((RSLT != 0x00))
{
Return (RSLT) /* \LOPS.RSLT */
}
Return (0x00)
}/*TEST */
}/*LOPS */
/* */
/* test FdSetOps.asl */
/* */
/* FindSetLeftBit - Find Set Left Bit */
/* FindSetLeftBitTerm := FindSetLeftBit */
/* ( Source, //TermArg=>Integer */
/* Result //Nothing | SuperName */
/* ) => Integer */
/* Source is evaluated as integer data type, and the one-based bit location of */
/* the first MSb (most significant set bit) is optionally stored into Result. */
/* The result of 0 means no bit was set, 1 means the left-most bit set is the */
/* first bit, 2 means the left-most bit set is the second bit, and so on. */
/* FindSetRightBit - Find Set Right Bit */
/* FindSetRightBitTerm := FindSetRightBit */
/* ( Source, //TermArg=>Integer */
/* Result //Nothing | SuperName */
/* ) => Integer */
/* Source is evaluated as integer data type, and the one-based bit location of */
/* the most LSb (least significant set bit) is optionally stored in Result. */
/* The result of 0 means no bit was set, 32 means the first bit set is the */
/* 32nd bit, 31 means the first bit set is the 31st bit, and so on. */
/* If the Control method is success Zero is returned. Otherwise a non-zero */
/* number is returned. */
/* */
Device (FDSO)
{
/* FDSO */
/* Create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
} /* Field(RAM) */
/* Byte Data */
Name (BYT1, 0x01)
Name (BRSL, 0x00)
/* Word Data */
Name (WRD1, 0x0100)
Name (WRSL, 0x00)
/* DWord Data */
Name (DWD1, 0x00010000)
Name (DRSL, 0x00)
Name (RSLT, 0x01)
Name (CNTR, 0x01)
Method (SHFT, 2, NotSerialized)
{
/* SHFT */
Local0 = Arg0
Local1 = Arg1
FindSetLeftBit (Arg0, BRSL) /* \FDSO.BRSL */
If ((BRSL != Arg1))
{
Return (0x11)
}
If ((Arg0 != Local0))
{
Return (0x12)
}
FindSetLeftBit (Local0, BRSL) /* \FDSO.BRSL */
If ((BRSL != Local1))
{
Return (0x13)
}
If ((Arg0 != Local0))
{
Return (0x14)
}
/* test the byte value for SetLeftBit */
BYT1 = 0x07
FindSetLeftBit (BYT1, BRSL) /* \FDSO.BRSL */
If ((BRSL != 0x03))
{
Return (0x15)
}
If ((BYT1 != 0x07))
{
Return (0x16)
}
BYT1 = 0x01
CNTR = 0x01
While ((CNTR <= 0x08))
{
/* FindSetLeftBit check loop for byte data */
FindSetLeftBit (BYT1, BRSL) /* \FDSO.BRSL */
If ((BRSL != CNTR))
{
Return (0x17)
}
/* Shift the bits to check the same */
BYT1 <<= 0x01
CNTR++
} /* FindSetLeftBit check loop for byte data */
/* Check BYTE value for SetRightBit */
BYT1 = 0x07
FindSetRightBit (BYT1, BRSL) /* \FDSO.BRSL */
If ((BRSL != 0x01))
{
Return (0x21)
}
If ((BYT1 != 0x07))
{
Return (0x22)
}
CNTR = 0x01
BYT1 = 0xFF
While ((CNTR <= 0x08))
{
/* FindSetRightBit check loop for byte data */
FindSetRightBit (BYT1, BRSL) /* \FDSO.BRSL */
If ((BRSL != CNTR))
{
Return (0x23)
}
BYT1 <<= 0x01
CNTR++
} /* FindSetRightBit check loop for byte data */
/* Test Word value for SetLeftBit */
CNTR = 0x09
WRD1 = 0x0100
While ((CNTR <= 0x10))
{
/* FindSetLeftBit check loop for Word data */
FindSetLeftBit (WRD1, WRSL) /* \FDSO.WRSL */
If ((WRSL != CNTR))
{
Return (0x31)
}
/* Shift the bits to check the same */
WRD1 <<= 0x01
CNTR++
} /* FindSetLeftBit check loop for Word data */
/* Check Word value for SetRightBit */
CNTR = 0x09
WRD1 = 0xFF00
While ((CNTR <= 0x10))
{
/* FindSetRightBit check loop for Word data */
FindSetRightBit (WRD1, WRSL) /* \FDSO.WRSL */
If ((WRSL != CNTR))
{
Return (0x32)
}
WRD1 <<= 0x01
CNTR++
} /* FindSetRightBit check loop for Word data */
/* Test the DWord value for SetLeftBit */
CNTR = 0x11
DWD1 = 0x00010000
While ((CNTR <= 0x20))
{
/* FindSetLeftBit check loop for Dword */
FindSetLeftBit (DWD1, DRSL) /* \FDSO.DRSL */
If ((DRSL != CNTR))
{
Return (0x41)
}
/* Shift the bits to check the same */
DWD1 <<= 0x01
CNTR++
} /* FindSetLeftBit check loop for Dword */
/* Check DWord value for SetRightBit */
CNTR = 0x11
DWD1 = 0xFFFF0000
While ((CNTR <= 0x20))
{
/* FindSetRightBit Check loop for DWORD */
FindSetRightBit (DWD1, DRSL) /* \FDSO.DRSL */
If ((DRSL != CNTR))
{
Return (0x42)
}
DWD1 <<= 0x01
CNTR++
} /* FindSetRightBit Check loop for DWORD */
Return (0x00)
} /* SHFT */
/* Test method called from amlexec */
Method (TEST, 0, NotSerialized)
{
/* TEST */
Debug = "++++++++ FdSetOps Test"
RSLT = SHFT (0x80, 0x08)
If ((RSLT != 0x00))
{
Return (RSLT) /* \FDSO.RSLT */
}
Return (0x00) /* pass */
} /* TEST */
} /* Device FDSO */
/* */
/* test MulDivOp.asl */
/* */
Device (MLDV)
{
/* create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
} /* Field(RAM) */
Method (TEST, 0, Serialized)
{
Debug = "++++++++ MulDivOp Test"
Name (RMDR, 0x00)
Name (DWRD, 0x12345678)
Name (WRD, 0x1234)
Name (BYT, 0x12)
/* Test MultiplyOp with DWORD data */
DWRD = 0x12345678
DWRD *= 0x03
If ((DWRD != 0x369D0368))
{
Return (DWRD) /* \MLDV.TEST.DWRD */
}
/* Test MultiplyOp with WORD data */
WRD *= 0x04
If ((WRD != 0x48D0))
{
Return (WRD) /* \MLDV.TEST.WRD_ */
}
/* Test MultiplyOp with BYTE data */
BYT *= 0x05
If ((BYT != 0x5A))
{
Return (BYT) /* \MLDV.TEST.BYT_ */
}
/* Test DivideOp with DWORD data */
Divide (DWRD, 0x03, DWRD, RMDR) /* \MLDV.TEST.RMDR */
If ((DWRD != 0x12345678))
{
Return (DWRD) /* \MLDV.TEST.DWRD */
}
If ((RMDR != 0x00))
{
Return (RMDR) /* \MLDV.TEST.RMDR */
}
/* Test DivideOp with WORD data */
Divide (WRD, 0x04, WRD, RMDR) /* \MLDV.TEST.RMDR */
If ((WRD != 0x1234))
{
Return (WRD) /* \MLDV.TEST.WRD_ */
}
If ((RMDR != 0x00))
{
Return (RMDR) /* \MLDV.TEST.RMDR */
}
/* Test DivideOp with BYTE data */
Divide (BYT, 0x05, BYT, RMDR) /* \MLDV.TEST.RMDR */
If ((BYT != 0x12))
{
Return (BYT) /* \MLDV.TEST.BYT_ */
}
If ((RMDR != 0x00))
{
Return (RMDR) /* \MLDV.TEST.RMDR */
}
/* test MultiplyOp with DWORD SystemMemory OpRegion */
SMDW = 0x01234567
SMDW *= 0x02
If ((SMDW != 0x02468ACE))
{
Return (SMDW) /* \MLDV.SMDW */
}
/* test DivideOp with DWORD SystemMemory OpRegion */
Divide (SMDW, 0x03, SMDW, RMDR) /* \MLDV.TEST.RMDR */
If ((SMDW != 0x00C22E44))
{
Return (SMDW) /* \MLDV.SMDW */
}
If ((RMDR != 0x02))
{
Return (RMDR) /* \MLDV.TEST.RMDR */
}
/* test MultiplyOp with WORD SystemMemory OpRegion */
SMWD = 0x0123
SMWD *= 0x03
If ((SMWD != 0x0369))
{
Return (SMWD) /* \MLDV.SMWD */
}
/* test DivideOp with WORD SystemMemory OpRegion */
Divide (SMWD, 0x02, SMWD, RMDR) /* \MLDV.TEST.RMDR */
If ((SMWD != 0x01B4))
{
Return (SMWD) /* \MLDV.SMWD */
}
If ((RMDR != 0x01))
{
Return (RMDR) /* \MLDV.TEST.RMDR */
}
/* test MultiplyOp with BYTE SystemMemory OpRegion */
SMBY = 0x01
SMBY *= 0x07
If ((SMBY != 0x07))
{
Return (SMBY) /* \MLDV.SMBY */
}
/* test DivideOp with BYTE SystemMemory OpRegion */
Divide (SMBY, 0x04, SMBY, RMDR) /* \MLDV.TEST.RMDR */
If ((SMBY != 0x01))
{
Return (SMBY) /* \MLDV.SMBY */
}
If ((RMDR != 0x03))
{
Return (RMDR) /* \MLDV.TEST.RMDR */
}
Return (0x00)
} /* TEST */
} /* MLDV */
/* */
/* test NBitOps.asl */
/* */
/*NAnd - Bit-wise NAnd */
/*NAndTerm := NAnd( */
/* Source1, //TermArg=>Integer */
/* Source2 //TermArg=>Integer */
/* Result //Nothing | SuperName */
/*) => Integer */
/*Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally */
/*stored in Result. */
/*NOr - Bitwise NOr */
/*NOrTerm := NOr( */
/* Source1, //TermArg=>Integer */
/* Source2 //TermArg=>Integer */
/* Result //Nothing | SuperName */
/*) => Integer */
/*Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally */
/*stored in Result. */
/* Not - Not */
/*NotTerm := Not( */
/* Source, //TermArg=>Integer */
/* Result //Nothing | SuperName */
/*) => Integer */
/*Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in */
/*Result. */
/*If the Control method is success Zero is returned else a non-zero number is returned */
Device (NBIT)
{
/*NBIT */
/*Create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
}/* Field(RAM) */
/*And with Byte Data */
Name (BYT1, 0xFF)
Name (BYT2, 0xFF)
Name (BRSL, 0x00)
/*And with Word Data */
Name (WRD1, 0xFFFF)
Name (WRD2, 0xFFFF)
Name (WRSL, 0x00)
/*And with DWord Data */
Name (DWD1, 0xFFFFFFFF)
Name (DWD2, 0xFFFFFFFF)
Name (DRSL, 0x00)
Name (RSLT, 0x01)
Name (ARSL, 0x00)
Name (LRSL, 0x00)
Method (NNDB, 2, NotSerialized)
{
/*NNDB */
SMDW = 0xFFFFFFFF
SMWD = 0xFFFF
SMBY = 0xFF
NAnd (Arg0, Arg1, ARSL) /* \NBIT.ARSL */
If ((ARSL != 0xFFFFFFFD))
{
Return (0x0B)
}
Local0 = Arg0
Local1 = Arg1
NAnd (Local0, Local1, LRSL) /* \NBIT.LRSL */
If ((LRSL != 0xFFFFFFFD))
{
Return (0x0C)
}
/*Byte data */
NAnd (BYT1, BYT2, BRSL) /* \NBIT.BRSL */
If ((BRSL != 0xFFFFFF00))
{
Return (0x0D)
}
/*Word Data */
NAnd (WRD1, WRD2, WRSL) /* \NBIT.WRSL */
If ((WRSL != 0xFFFF0000))
{
Return (0x0E)
}
/*DWord Data */
NAnd (DWD1, DWD2, DRSL) /* \NBIT.DRSL */
If ((DRSL != 0x00))
{
Return (0x0F)
}
/*Byte data */
NAnd (SMBY, 0xFF, BRSL) /* \NBIT.BRSL */
If ((BRSL != 0xFFFFFF00))
{
Return (0x10)
}
/*Word Data */
NAnd (SMWD, 0xFFFF, WRSL) /* \NBIT.WRSL */
If ((WRSL != 0xFFFF0000))
{
Return (0x11)
}
/*DWord Data */
NAnd (SMDW, 0xFFFFFFFF, DRSL) /* \NBIT.DRSL */
If ((DRSL != 0x00))
{
Return (0x12)
}
Return (0x00)
}/*NNDB */
Method (NNOR, 2, NotSerialized)
{
/*NNOR */
NOr (Arg0, Arg1, ARSL) /* \NBIT.ARSL */
If ((ARSL != 0xFFFFFFFD))
{
Return (0x15)
}
Local0 = Arg0
Local1 = Arg1
NOr (Local0, Local1, LRSL) /* \NBIT.LRSL */
If ((LRSL != 0xFFFFFFFD))
{
Return (0x16)
}
/*Byte data */
NOr (BYT1, BYT2, BRSL) /* \NBIT.BRSL */
If ((BRSL != 0xFFFFFF00))
{
Return (0x17)
}
/*Word Data */
NOr (WRD1, WRD2, WRSL) /* \NBIT.WRSL */
If ((WRSL != 0xFFFF0000))
{
Return (0x18)
}
/*DWord Data */
NOr (DWD1, DWD2, DRSL) /* \NBIT.DRSL */
If ((DRSL != 0x00))
{
Return (0x19)
}
/*System Memory Byte data */
NOr (SMBY, 0xFF, BRSL) /* \NBIT.BRSL */
If ((BRSL != 0xFFFFFF00))
{
Return (0x1A)
}
/*System Memory Word Data */
NOr (SMWD, 0xFFFF, WRSL) /* \NBIT.WRSL */
If ((WRSL != 0xFFFF0000))
{
Return (0x1B)
}
/*System Memory DWord Data */
NOr (SMDW, 0xFFFFFFFF, DRSL) /* \NBIT.DRSL */
If ((DRSL != 0x00))
{
Return (0x1C)
}
Return (0x00)
}/*NNOR */
Method (NNOT, 2, NotSerialized)
{
/*NNOT */
ARSL = (Arg0 | Arg1)
ARSL = ~ARSL /* \NBIT.ARSL */
If ((ARSL != 0xFFFFFFFD))
{
Return (0x1F)
}
Local0 = Arg0
Local1 = Arg1
LRSL = (Local0 | Local1)
LRSL = ~LRSL /* \NBIT.LRSL */
If ((LRSL != 0xFFFFFFFD))
{
Return (0x20)
}
/*Byte data */
BRSL = (BYT1 | BYT2) /* \NBIT.BYT2 */
BRSL = ~BRSL /* \NBIT.BRSL */
If ((BRSL != 0xFFFFFF00))
{
Return (0x21)
}
/*Word Data */
WRSL = (WRD1 | WRD2) /* \NBIT.WRD2 */
WRSL = ~WRSL /* \NBIT.WRSL */
If ((WRSL != 0xFFFF0000))
{
Return (0x22)
}
/*DWord Data */
DRSL = (DWD1 | DWD2) /* \NBIT.DWD2 */
DRSL = ~DRSL /* \NBIT.DRSL */
If ((DRSL != 0x00))
{
Return (0x23)
}
/*System Memory Byte data */
BRSL = (SMBY | 0xFF)
BRSL = ~BRSL /* \NBIT.BRSL */
If ((BRSL != 0xFFFFFF00))
{
Return (0x24)
}
/*System Memory Word Data */
WRSL = (SMWD | 0xFFFF)
WRSL = ~WRSL /* \NBIT.WRSL */
If ((WRSL != 0xFFFF0000))
{
Return (0x25)
}
/*System Memory DWord Data */
DRSL = (SMDW | 0xFFFFFFFF)
DRSL = ~DRSL /* \NBIT.DRSL */
If ((DRSL != 0x00))
{
Return (0x26)
}
Return (0x00)
}/*NNOT */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ NBitOps Test"
RSLT = NNDB (0x02, 0x02)
If ((RSLT != 0x00))
{
Return (RSLT) /* \NBIT.RSLT */
}
RSLT = NNOR (0x02, 0x02)
If ((RSLT != 0x00))
{
Return (RSLT) /* \NBIT.RSLT */
}
RSLT = NNOT (0x02, 0x02)
If ((RSLT != 0x00))
{
Return (RSLT) /* \NBIT.RSLT */
}
Return (0x00)
}
}/*Device NBIT */
/* */
/* test ShftOp.asl */
/* */
/*ShiftRightTerm := ShiftRight( */
/* Source, //TermArg=>Integer */
/* ShiftCount //TermArg=>Integer */
/* Result //Nothing | SuperName */
/*) => Integer */
/*Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit */
/*zeroed ShiftCount times. The result is optionally stored into Result. */
/*ShiftLeft( */
/* Source, //TermArg=>Integer */
/* ShiftCount //TermArg=>Integer */
/* Result //Nothing | SuperName */
/*) => Integer */
/*Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant */
/*bit zeroed ShiftCount times. The result is optionally stored into Result. */
/*If the Control method is success Zero is returned else a non-zero number is returned */
Device (SHFT)
{
/*SHFT */
/*Create System Memory Operation Region and field overlays */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
SMDW, /* 32-bit DWORD */ 32,
SMWD, /* 16-bit WORD */ 16,
SMBY, /* 8-bit BYTE */ 8
}/* Field(RAM) */
Name (SHFC, 0x00)
/*And with Byte Data */
Name (BYT1, 0xFF)
Name (BRSL, 0x00)
/*And with Word Data */
Name (WRD1, 0xFFFF)
Name (WRSL, 0x00)
/*And with DWord Data */
Name (DWD1, 0xFFFFFFFF)
Name (DRSL, 0x00)
Name (RSLT, 0x01)
Name (ARSL, 0x00)
Name (LRSL, 0x00)
Method (SLFT, 2, NotSerialized)
{
/*SLFT */
SMDW = 0xFFFFFFFF
SMWD = 0xFFFF
SMBY = 0xFF
/*Arg0-> 2 & Arg1->2 */
ARSL = (Arg0 << Arg1)
If ((ARSL != 0x08))
{
Return (0x0B)
}
Local0 = Arg0
Local1 = Arg1
/*Local0->8 and Local1->2 */
LRSL = (Local0 << Local1)
If ((LRSL != 0x08))
{
Return (0x0C)
}
SHFC = 0x02
/*Byte data */
BRSL = (BYT1 << SHFC) /* \SHFT.SHFC */
If ((BRSL != 0x03FC))
{
Return (0x0D)
}
SHFC = 0x04
/*Word Data */
WRSL = (WRD1 << SHFC) /* \SHFT.SHFC */
If ((WRSL != 0x000FFFF0))
{
Return (0x0E)
}
SHFC = 0x08
/*DWord Data */
DRSL = (DWD1 << SHFC) /* \SHFT.SHFC */
If ((DRSL != 0xFFFFFF00))
{
Return (0x0F)
}
/*System Memory Byte data */
SHFC = 0x04
BRSL = (SMBY << SHFC) /* \SHFT.SHFC */
If ((BRSL != 0x0FF0))
{
Return (0x10)
}
/*Word Data */
SHFC = 0x04
WRSL = (SMWD << SHFC) /* \SHFT.SHFC */
If ((WRSL != 0x000FFFF0))
{
Return (0x11)
}
/*DWord Data */
SHFC = 0x08
DRSL = (SMDW << SHFC) /* \SHFT.SHFC */
If ((DRSL != 0xFFFFFF00))
{
Return (0x12)
}
Return (0x00)
}/*SLFT */
Method (SRGT, 2, NotSerialized)
{
/*SRGT */
/*And with Byte Data */
BYT1 = 0xFF
BRSL = 0x00
/*And with Word Data */
WRD1 = 0xFFFF
WRSL = 0x00
/*And with DWord Data */
DWD1 = 0xFFFFFFFF
DRSL = 0x00
/*Reinitialize the result objects */
ARSL = 0x00
LRSL = 0x00
SMDW = 0xFFFFFFFF
SMWD = 0xFFFF
SMBY = 0xFF
/*Arg0-> 2 & Arg1->2 */
ARSL = (Arg0 >> Arg1)
If ((ARSL != 0x00))
{
Return (0x15)
}
Local0 = Arg0
Local1 = Arg1
/*Local0->8 and Local1->2 */
LRSL = (Local0 >> Local1)
If ((LRSL != 0x00))
{
Return (0x16)
}
SHFC = 0x02
/*Byte data */
BRSL = (BYT1 >> SHFC) /* \SHFT.SHFC */
If ((BRSL != 0x3F))
{
Return (0x17)
}
SHFC = 0x04
/*Word Data */
WRSL = (WRD1 >> SHFC) /* \SHFT.SHFC */
If ((WRSL != 0x0FFF))
{
Return (0x18)
}
SHFC = 0x08
/*DWord Data */
DRSL = (DWD1 >> SHFC) /* \SHFT.SHFC */
If ((DRSL != 0x00FFFFFF))
{
Return (0x19)
}
/*System Memory Byte data */
SHFC = 0x04
BRSL = (SMBY >> SHFC) /* \SHFT.SHFC */
If ((BRSL != 0x0F))
{
Return (0x1A)
}
/*Word Data */
SHFC = 0x04
WRSL = (SMWD >> SHFC) /* \SHFT.SHFC */
If ((WRSL != 0x0FFF))
{
Return (0x1B)
}
/*DWord Data */
SHFC = 0x08
DRSL = (SMDW >> SHFC) /* \SHFT.SHFC */
If ((DRSL != 0x00FFFFFF))
{
Return (0x1C)
}
Return (0x00)
}/*SRGT */
/*Test method called from amlexec */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ ShftOp Test"
RSLT = SLFT (0x02, 0x02)
If ((RSLT != 0x00))
{
Return (RSLT) /* \SHFT.RSLT */
}
RSLT = SRGT (0x02, 0x02)
If ((RSLT != 0x00))
{
Return (RSLT) /* \SHFT.RSLT */
}
Return (0x00)
}
}/*Device SHFT */
/* */
/* test Xor.asl and slightly modified */
/* */
/*This code tests the XOR opcode term */
/*Syntax of XOR term */
/* XOr( */
/* Source1 //TermArg=>BufferTerm */
/* Source2 //TermArg=>Integer */
/* Result //NameString */
/* ) */
/*"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in */
/* Result */
Device (XORD)
{
/*This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD */
Method (TEST, 0, Serialized)
{
Debug = "++++++++ Xor Test"
/*Overlay in system memory */
OperationRegion (RAM, SystemMemory, 0x00800000, 0x0100)
Field (RAM, ByteAcc, NoLock, Preserve)
{
RES1, /*Offset */ 1,
BYT1, /*First BYTE */ 8,
BYT2, /*Second BYTE */ 8,
RBYT, /*Result Byte */ 8,
RES2, /*Offset */ 1,
WRD1, /*First WORD field */ 16,
WRD2, /*Second WORD field */ 16,
RWRD, /*RSLT WORD field */ 16,
RES3, /*Offset */ 1,
DWD1, /*First Dword */ 32,
DWD2, /*Second Dword */ 32,
RDWD, /*Result Dword */ 32,
RES4, /*Offset */ 1
}
/* Store bits in the single bit fields for checking */
/* at the end */
RES1 = 0x01
RES2 = 0x01
RES3 = 0x01
RES4 = 0x01
/* Check the stored single bits */
If ((RES1 != 0x01))
{
Return (0x01)
}
If ((RES2 != 0x01))
{
Return (0x01)
}
If ((RES3 != 0x01))
{
Return (0x01)
}
If ((RES4 != 0x01))
{
Return (0x01)
}
/************************************************* */
/* (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition */
BYT1 = 0x00
BYT2 = 0x00
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
RBYT = Local0
If ((RBYT != 0x00))
{
Return (0x01)
}
/* (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition */
BYT1 = 0xFF
BYT2 = 0xFF
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
RBYT = Local0
If ((RBYT != 0x00))
{
Return (0x01)
}
/* (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition */
BYT1 = 0x55
BYT2 = 0xAA
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
RBYT = Local0
If ((RBYT != 0xFF))
{
Return (0x01)
}
/*(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition */
BYT1 = 0xAA
BYT2 = 0x55
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
RBYT = Local0
If ((RBYT != 0xFF))
{
Return (0x01)
}
BYT1 = 0x12
BYT2 = 0xED
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
RBYT = Local0
If ((RBYT != 0xFF))
{
Return (0x01)
}
/* Store known values for checking later */
BYT1 = 0x12
If ((BYT1 != 0x12))
{
Return (0x01)
}
BYT2 = 0xFE
If ((BYT2 != 0xFE))
{
Return (0x01)
}
RBYT = 0xAB
If ((RBYT != 0xAB))
{
Return (0x01)
}
/************************************************ */
/* (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition */
WRD1 = 0x00
WRD2 = 0x00
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
If ((RWRD != 0x00))
{
Return (0x01)
}
/* (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition */
WRD1 = 0xFFFF
WRD2 = 0xFFFF
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
If ((RWRD != 0x00))
{
Return (0x01)
}
/* (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition */
WRD1 = 0x5555
WRD2 = 0xAAAA
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
If ((RWRD != 0xFFFF))
{
Return (0x01)
}
/*(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition */
WRD1 = 0xAAAA
WRD2 = 0x5555
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
If ((RWRD != 0xFFFF))
{
Return (0x01)
}
WRD1 = 0x1234
WRD2 = 0xEDCB
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
If ((RWRD != 0xFFFF))
{
Return (0x01)
}
/* Store known values for checking later */
WRD1 = 0x1234
If ((WRD1 != 0x1234))
{
Return (0x01)
}
WRD2 = 0xFEDC
If ((WRD2 != 0xFEDC))
{
Return (0x01)
}
RWRD = 0x87AB
If ((RWRD != 0x87AB))
{
Return (0x01)
}
/*************************************************** */
/* (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition */
DWD1 = 0x00
DWD2 = 0x00
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
If ((RDWD != 0x00))
{
Return (0x01)
}
/* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition */
DWD1 = 0xFFFFFFFF
DWD2 = 0xFFFFFFFF
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
If ((RDWD != 0x00))
{
Return (0x01)
}
/* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition */
DWD1 = 0x55555555
DWD2 = 0xAAAAAAAA
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
If ((RDWD != 0xFFFFFFFF))
{
Return (0x01)
}
/*(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition */
DWD1 = 0xAAAAAAAA
DWD2 = 0x55555555
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
If ((RDWD != 0xFFFFFFFF))
{
Return (0x01)
}
/* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition */
DWD1 = 0x12345678
DWD2 = 0xEDCBA987
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
If ((RDWD != 0xFFFFFFFF))
{
Return (0x01)
}
DWD1 = 0x12345678
If ((DWD1 != 0x12345678))
{
Return (0x01)
}
DWD2 = 0xFEDCBA98
If ((DWD2 != 0xFEDCBA98))
{
Return (0x01)
}
RDWD = 0x91827364
If ((RDWD != 0x91827364))
{
Return (0x01)
}
/***************************************************** */
/* Check the stored single bits */
If ((RES1 != 0x01))
{
Return (0x01)
}
If ((RES2 != 0x01))
{
Return (0x01)
}
If ((RES3 != 0x01))
{
Return (0x01)
}
If ((RES4 != 0x01))
{
Return (0x01)
}
/* Change all of the single bit fields to zero */
RES1 = 0x00
RES2 = 0x00
RES3 = 0x00
RES4 = 0x00
/* Now, check all of the fields */
/* Byte */
If ((BYT1 != 0x12))
{
Return (0x01)
}
If ((BYT2 != 0xFE))
{
Return (0x01)
}
If ((RBYT != 0xAB))
{
Return (0x01)
}
/* Word */
If ((WRD1 != 0x1234))
{
Return (0x01)
}
If ((WRD2 != 0xFEDC))
{
Return (0x01)
}
If ((RWRD != 0x87AB))
{
Return (0x01)
}
/* Dword */
If ((DWD1 != 0x12345678))
{
Return (0x01)
}
If ((DWD2 != 0xFEDCBA98))
{
Return (0x01)
}
If ((RDWD != 0x91827364))
{
Return (0x01)
}
/* Bits */
If ((RES1 != 0x00))
{
Return (0x01)
}
If ((RES2 != 0x00))
{
Return (0x01)
}
If ((RES3 != 0x00))
{
Return (0x01)
}
If ((RES4 != 0x00))
{
Return (0x01)
}
Return (0x00)
} /* TEST */
} /* XORD */
/* */
/* test CrBytFld.asl */
/* */
/* CrBytFld test */
/* Test for CreateByteField. */
/* Tests creating byte field overlay of buffer stored in Local0. */
/* Tests need to be added for Arg0 and Name buffers. */
/* */
Device (CRBF)
{
/* Test device name */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ CrBytFld Test"
/* Local0 is unitialized buffer with 4 elements */
Local0 = Buffer (0x04){}
/* create Byte Field named BF0 based on Local0 element 0 */
CreateByteField (Local0, 0x00, BF0)
/* validate CreateByteField did not alter Local0 */
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
{
Return (0x02)
}
/* store something into BF0 */
BF0 = 0x01
/* validate Store did not alter Local0 object type */
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
{
Return (0x03)
}
/* verify that the Store into BF0 was successful */
If ((BF0 != 0x01))
{
Return (0x04)
}
/* create Byte Field named BF1 based on Local0 element 1 */
CreateByteField (Local0, 0x01, BF1)
/* validate CreateByteField did not alter Local0 */
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
{
Return (0x0A)
}
/* store something into BF1 */
BF1 = 0x05
/* validate Store did not alter Local0 object type */
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
{
Return (0x0B)
}
/* verify that the Store into BF1 was successful */
If ((BF1 != 0x05))
{
Return (0x0C)
}
/* verify that the Store into BF1 did not alter BF0 */
If ((BF0 != 0x01))
{
Return (0x0D)
}
/* store something into BF0 */
BF0 = 0xFFFF
/* verify that the Store into BF0 was successful */
If ((BF0 != 0xFF))
{
Return (0x14)
}
/* verify that the Store into BF0 did not alter BF1 */
If ((BF1 != 0x05))
{
Return (0x15)
}
Return (0x00)
} /* TEST */
} /* CRBF */
/* */
/* test IndexOp4.asl */
/* */
/* IndexOp4 test */
/* This is just a subset of the many RegionOp/Index Field test cases. */
/* Tests access of index fields smaller than 8 bits. */
/* */
Device (IDX4)
{
/* Test device name */
/* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */
/* Tests OperationRegion memory access using misaligned BYTE, */
/* WORD, and DWORD field element accesses. Validation is performed */
/* using both misaligned field entries and aligned field entries. */
/* */
/* MADM returns 0 if all test cases pass or non-zero identifying */
/* the failing test case for debug purposes. This non-zero numbers */
/* are not guaranteed to be in perfect sequence (i.e., test case */
/* index), but are guaranteed to be unique so the failing test */
/* case can be uniquely identified. */
/* */
Method (MADM, 1, Serialized)
{
/* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */
OperationRegion (RAM, SystemMemory, Arg0, 0x0100)
Field (RAM, DWordAcc, NoLock, Preserve)
{
/* aligned field definition (for verification) */
DWD0, /* aligned DWORD field */ 32,
DWD1, /* aligned DWORD field */ 32
}
Field (RAM, ByteAcc, NoLock, Preserve)
{
/* bit access field definition */
BIT0, /* single bit field entry */ 1,
BIT1, /* single bit field entry */ 1,
BIT2, /* single bit field entry */ 1,
BIT3, /* single bit field entry */ 1,
BIT4, /* single bit field entry */ 1,
BIT5, /* single bit field entry */ 1,
BIT6, /* single bit field entry */ 1,
BIT7, /* single bit field entry */ 1,
BIT8, /* single bit field entry */ 1,
BIT9, /* single bit field entry */ 1,
BITA, /* single bit field entry */ 1,
BITB, /* single bit field entry */ 1,
BITC, /* single bit field entry */ 1,
BITD, /* single bit field entry */ 1,
BITE, /* single bit field entry */ 1,
BITF, /* single bit field entry */ 1,
BI10, /* single bit field entry */ 1,
BI11, /* single bit field entry */ 1,
BI12, /* single bit field entry */ 1,
BI13, /* single bit field entry */ 1,
BI14, /* single bit field entry */ 1,
BI15, /* single bit field entry */ 1,
BI16, /* single bit field entry */ 1,
BI17, /* single bit field entry */ 1,
BI18, /* single bit field entry */ 1,
BI19, /* single bit field entry */ 1,
BI1A, /* single bit field entry */ 1,
BI1B, /* single bit field entry */ 1,
BI1C, /* single bit field entry */ 1,
BI1D, /* single bit field entry */ 1,
BI1E, /* single bit field entry */ 1,
BI1F, /* single bit field entry */ 1
} /* bit access field definition */
Field (RAM, ByteAcc, NoLock, Preserve)
{
/* two-bit access field definition */
B2_0, /* single bit field entry */ 2,
B2_1, /* single bit field entry */ 2,
B2_2, /* single bit field entry */ 2,
B2_3, /* single bit field entry */ 2,
B2_4, /* single bit field entry */ 2,
B2_5, /* single bit field entry */ 2,
B2_6, /* single bit field entry */ 2,
B2_7, /* single bit field entry */ 2,
B2_8, /* single bit field entry */ 2,
B2_9, /* single bit field entry */ 2,
B2_A, /* single bit field entry */ 2,
B2_B, /* single bit field entry */ 2,
B2_C, /* single bit field entry */ 2,
B2_D, /* single bit field entry */ 2,
B2_E, /* single bit field entry */ 2,
B2_F, /* single bit field entry */ 2
} /* bit access field definition */
/* initialize memory contents using aligned field entries */
DWD0 = 0x5AA55AA5
DWD1 = 0x5AA55AA5
/* set memory contents to known values using misaligned field entries */
BIT0 = 0x00
/* verify memory contents using misaligned field entries */
If ((BIT0 != 0x00))
{
Return (0x01)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55AA4))
{
Return (0x02)
}
/* set memory contents to known values using misaligned field entries */
BIT1 = 0x01
/* verify memory contents using misaligned field entries */
If ((BIT1 != 0x01))
{
Return (0x03)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55AA6))
{
Return (0x04)
}
/* set memory contents to known values using misaligned field entries */
BIT2 = 0x00
/* verify memory contents using misaligned field entries */
If ((BIT2 != 0x00))
{
Return (0x05)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55AA2))
{
Return (0x06)
}
/* set memory contents to known values using misaligned field entries */
BIT3 = 0x01
/* verify memory contents using misaligned field entries */
If ((BIT3 != 0x01))
{
Return (0x07)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55AAA))
{
Return (0x08)
}
/* set memory contents to known values using misaligned field entries */
BIT4 = 0x01
/* verify memory contents using misaligned field entries */
If ((BIT4 != 0x01))
{
Return (0x09)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55ABA))
{
Return (0x0A)
}
/* set memory contents to known values using misaligned field entries */
BIT5 = 0x00
/* verify memory contents using misaligned field entries */
If ((BIT5 != 0x00))
{
Return (0x0B)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55A9A))
{
Return (0x0C)
}
/* set memory contents to known values using misaligned field entries */
BIT6 = 0x01
/* verify memory contents using misaligned field entries */
If ((BIT6 != 0x01))
{
Return (0x0D)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55ADA))
{
Return (0x0E)
}
/* set memory contents to known values using misaligned field entries */
BIT7 = 0x00
/* verify memory contents using misaligned field entries */
If ((BIT7 != 0x00))
{
Return (0x0F)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55A5A))
{
Return (0x10)
}
/* set memory contents to known values using misaligned field entries */
BIT8 = 0x01
/* verify memory contents using misaligned field entries */
If ((BIT8 != 0x01))
{
Return (0x11)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55B5A))
{
Return (0x12)
}
/* set memory contents to known values using misaligned field entries */
BIT9 = 0x00
/* verify memory contents using misaligned field entries */
If ((BIT9 != 0x00))
{
Return (0x13)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA5595A))
{
Return (0x14)
}
/* set memory contents to known values using misaligned field entries */
BITA = 0x01
/* verify memory contents using misaligned field entries */
If ((BITA != 0x01))
{
Return (0x15)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA55D5A))
{
Return (0x16)
}
/* set memory contents to known values using misaligned field entries */
BITB = 0x00
/* verify memory contents using misaligned field entries */
If ((BITB != 0x00))
{
Return (0x17)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA5555A))
{
Return (0x18)
}
/* set memory contents to known values using misaligned field entries */
BITC = 0x00
/* verify memory contents using misaligned field entries */
If ((BITC != 0x00))
{
Return (0x19)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA5455A))
{
Return (0x1A)
}
/* set memory contents to known values using misaligned field entries */
BITD = 0x01
/* verify memory contents using misaligned field entries */
If ((BITD != 0x01))
{
Return (0x1B)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA5655A))
{
Return (0x1C)
}
/* set memory contents to known values using misaligned field entries */
BITE = 0x00
/* verify memory contents using misaligned field entries */
If ((BITE != 0x00))
{
Return (0x1D)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA5255A))
{
Return (0x1E)
}
/* set memory contents to known values using misaligned field entries */
BITF = 0x01
/* verify memory contents using misaligned field entries */
If ((BITF != 0x01))
{
Return (0x1F)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA5A55A))
{
Return (0x20)
}
/* set memory contents to known values using misaligned field entries */
BI10 = 0x00
/* verify memory contents using misaligned field entries */
If ((BI10 != 0x00))
{
Return (0x21)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA4A55A))
{
Return (0x22)
}
/* set memory contents to known values using misaligned field entries */
BI11 = 0x01
/* verify memory contents using misaligned field entries */
If ((BI11 != 0x01))
{
Return (0x23)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA6A55A))
{
Return (0x24)
}
/* set memory contents to known values using misaligned field entries */
BI12 = 0x00
/* verify memory contents using misaligned field entries */
If ((BI12 != 0x00))
{
Return (0x25)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AA2A55A))
{
Return (0x26)
}
/* set memory contents to known values using misaligned field entries */
BI13 = 0x01
/* verify memory contents using misaligned field entries */
If ((BI13 != 0x01))
{
Return (0x27)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5AAAA55A))
{
Return (0x28)
}
/* set memory contents to known values using misaligned field entries */
BI14 = 0x01
/* verify memory contents using misaligned field entries */
If ((BI14 != 0x01))
{
Return (0x29)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5ABAA55A))
{
Return (0x2A)
}
/* set memory contents to known values using misaligned field entries */
BI15 = 0x00
/* verify memory contents using misaligned field entries */
If ((BI15 != 0x00))
{
Return (0x2B)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5A9AA55A))
{
Return (0x2C)
}
/* set memory contents to known values using misaligned field entries */
BI16 = 0x01
/* verify memory contents using misaligned field entries */
If ((BI16 != 0x01))
{
Return (0x2D)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5ADAA55A))
{
Return (0x2E)
}
/* set memory contents to known values using misaligned field entries */
BI17 = 0x00
/* verify memory contents using misaligned field entries */
If ((BI17 != 0x00))
{
Return (0x2F)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5A5AA55A))
{
Return (0x30)
}
/* set memory contents to known values using misaligned field entries */
BI18 = 0x01
/* verify memory contents using misaligned field entries */
If ((BI18 != 0x01))
{
Return (0x31)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5B5AA55A))
{
Return (0x32)
}
/* set memory contents to known values using misaligned field entries */
BI19 = 0x00
/* verify memory contents using misaligned field entries */
If ((BI19 != 0x00))
{
Return (0x33)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x595AA55A))
{
Return (0x34)
}
/* set memory contents to known values using misaligned field entries */
BI1A = 0x01
/* verify memory contents using misaligned field entries */
If ((BI1A != 0x01))
{
Return (0x35)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x5D5AA55A))
{
Return (0x36)
}
/* set memory contents to known values using misaligned field entries */
BI1B = 0x00
/* verify memory contents using misaligned field entries */
If ((BI1B != 0x00))
{
Return (0x37)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x555AA55A))
{
Return (0x38)
}
/* set memory contents to known values using misaligned field entries */
BI1C = 0x00
/* verify memory contents using misaligned field entries */
If ((BI1C != 0x00))
{
Return (0x39)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x455AA55A))
{
Return (0x3A)
}
/* set memory contents to known values using misaligned field entries */
BI1D = 0x01
/* verify memory contents using misaligned field entries */
If ((BI1D != 0x01))
{
Return (0x3B)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x655AA55A))
{
Return (0x3C)
}
/* set memory contents to known values using misaligned field entries */
BI1E = 0x00
/* verify memory contents using misaligned field entries */
If ((BI1E != 0x00))
{
Return (0x3D)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x255AA55A))
{
Return (0x3E)
}
/* set memory contents to known values using misaligned field entries */
BI1F = 0x01
/* verify memory contents using misaligned field entries */
If ((BI1F != 0x01))
{
Return (0x3F)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55AA55A))
{
Return (0x40)
}
/* set memory contents to known values using misaligned field entries */
B2_0 = 0x03
/* verify memory contents using misaligned field entries */
If ((B2_0 != 0x03))
{
Return (0x41)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55AA55B))
{
Return (0x42)
}
/* set memory contents to known values using misaligned field entries */
B2_1 = 0x01
/* verify memory contents using misaligned field entries */
If ((B2_1 != 0x01))
{
Return (0x43)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55AA557))
{
Return (0x44)
}
/* set memory contents to known values using misaligned field entries */
B2_2 = 0x00
/* verify memory contents using misaligned field entries */
If ((B2_2 != 0x00))
{
Return (0x45)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55AA547))
{
Return (0x46)
}
/* set memory contents to known values using misaligned field entries */
B2_3 = 0x03
/* verify memory contents using misaligned field entries */
If ((B2_3 != 0x03))
{
Return (0x47)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55AA5C7))
{
Return (0x48)
}
/* set memory contents to known values using misaligned field entries */
B2_4 = 0x03
/* verify memory contents using misaligned field entries */
If ((B2_4 != 0x03))
{
Return (0x49)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55AA7C7))
{
Return (0x4A)
}
/* set memory contents to known values using misaligned field entries */
B2_5 = 0x00
/* verify memory contents using misaligned field entries */
If ((B2_5 != 0x00))
{
Return (0x4B)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55AA3C7))
{
Return (0x4C)
}
/* set memory contents to known values using misaligned field entries */
B2_6 = 0x01
/* verify memory contents using misaligned field entries */
If ((B2_6 != 0x01))
{
Return (0x4D)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55A93C7))
{
Return (0x4E)
}
/* set memory contents to known values using misaligned field entries */
B2_7 = 0x01
/* verify memory contents using misaligned field entries */
If ((B2_7 != 0x01))
{
Return (0x4F)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55A53C7))
{
Return (0x50)
}
/* set memory contents to known values using misaligned field entries */
B2_8 = 0x00
/* verify memory contents using misaligned field entries */
If ((B2_8 != 0x00))
{
Return (0x51)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55853C7))
{
Return (0x52)
}
/* set memory contents to known values using misaligned field entries */
B2_9 = 0x01
/* verify memory contents using misaligned field entries */
If ((B2_9 != 0x01))
{
Return (0x53)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA55453C7))
{
Return (0x54)
}
/* set memory contents to known values using misaligned field entries */
B2_A = 0x02
/* verify memory contents using misaligned field entries */
If ((B2_A != 0x02))
{
Return (0x55)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA56453C7))
{
Return (0x56)
}
/* set memory contents to known values using misaligned field entries */
B2_B = 0x02
/* verify memory contents using misaligned field entries */
If ((B2_B != 0x02))
{
Return (0x57)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA5A453C7))
{
Return (0x58)
}
/* set memory contents to known values using misaligned field entries */
B2_C = 0x03
/* verify memory contents using misaligned field entries */
If ((B2_C != 0x03))
{
Return (0x59)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xA7A453C7))
{
Return (0x5A)
}
/* set memory contents to known values using misaligned field entries */
B2_D = 0x03
/* verify memory contents using misaligned field entries */
If ((B2_D != 0x03))
{
Return (0x5B)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0xAFA453C7))
{
Return (0x5C)
}
/* set memory contents to known values using misaligned field entries */
B2_E = 0x01
/* verify memory contents using misaligned field entries */
If ((B2_E != 0x01))
{
Return (0x5D)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x9FA453C7))
{
Return (0x5E)
}
/* set memory contents to known values using misaligned field entries */
B2_F = 0x00
/* verify memory contents using misaligned field entries */
If ((B2_F != 0x00))
{
Return (0x5F)
}
/* verify memory contents using aligned field entries */
If ((DWD0 != 0x1FA453C7))
{
Return (0x60)
}
Return (0x00) /* pass */
} /* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IndexOp4 Test"
/* MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments: */
/* Arg0 -- SystemMemory OperationRegion base address */
Local0 = MADM (0x00800000)
If ((Local0 != 0x00)) /* MADM returns zero if successful */
{
Return (Local0)
} /* failure: return MADM error code */
Return (Local0)
} /* TEST */
} /* IDX4 */
/* */
/* test Event.asl */
/* */
/* EventOp, ResetOp, SignalOp, and WaitOp test cases. */
/* */
Device (EVNT)
{
Event (EVNT) /* event synchronization object */
Method (TEVN, 1, NotSerialized)
{
/* TEVN control method to test ResetOp, SignalOp, and WaitOp */
/* reset EVNT to initialization (zero) state */
Reset (EVNT)
/* prime EVNT with two outstanding signals */
Signal (EVNT)
Signal (EVNT)
/* acquire existing signal */
Local0 = Wait (EVNT, Arg0)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x21)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 != 0x00)) /* Number is type 1 */
{
Return (0x22)
} /* timeout occurred without acquiring signal */
Debug = "Acquire 1st existing signal PASS"
/* acquire existing signal */
Local0 = Wait (EVNT, Arg0)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x31)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 != 0x00)) /* Number is type 1 */
{
Return (0x32)
} /* timeout occurred without acquiring signal */
Debug = "Acquire 2nd existing signal PASS"
/* ensure WaitOp timeout test cases do not hang */
If ((Arg0 == 0xFFFF))
{
Arg0 = 0xFFFE
}
/* acquire non-existing signal */
Local0 = Wait (EVNT, Arg0)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x41)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 == 0x00)) /* Number is type 1 */
{
Return (0x42)
} /* non-existant signal was acquired */
Debug = "Acquire signal timeout PASS"
/* prime EVNT with two outstanding signals */
Signal (EVNT)
Signal (EVNT)
/* reset EVNT to initialization (zero) state */
Reset (EVNT)
/* acquire non-existing signal */
Local0 = Wait (EVNT, Arg0)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x51)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 == 0x00)) /* Number is type 1 */
{
Return (0x52)
} /* non-existant signal was acquired */
Debug = "Reset signal PASS"
/* acquire non-existing signal using Lvalue timeout */
Local0 = Wait (EVNT, Zero)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x61)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 == 0x00)) /* Number is type 1 */
{
Return (0x62)
} /* non-existant signal was acquired */
Debug = "Zero Lvalue PASS"
/* acquire non-existing signal using Lvalue timeout */
Local0 = Wait (EVNT, One)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x71)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 == 0x00)) /* Number is type 1 */
{
Return (0x72)
} /* non-existant signal was acquired */
Debug = "One Lvalue PASS"
/* Lvalue Event test cases */
/* ILLEGAL SOURCE OPERAND Store (EVNT, Local2) */
/* validate Local2 is an Event */
Local1 = ObjectType (EVNT)
If ((Local1 != 0x07)) /* Event is type 7 */
{
Return (0x81)
} /* Local1 indicates Local0 is not a Number */
/* reset EVNT to initialization (zero) state */
Reset (EVNT)
/* prime EVNT with two outstanding signals */
Signal (EVNT)
/* acquire existing signal */
Local0 = Wait (EVNT, Arg0)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x82)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 != 0x00)) /* Number is type 1 */
{
Return (0x83)
} /* timeout occurred without acquiring signal */
Debug = "Acquire Lvalue existing signal PASS"
/* acquire non-existing signal */
Local0 = Wait (EVNT, Arg0)
/* validate Local0 is a Number */
Local1 = ObjectType (Local0)
If ((Local1 != 0x01)) /* Number is type 1 */
{
Return (0x84)
} /* Local1 indicates Local0 is not a Number */
If ((Local0 == 0x00)) /* Number is type 1 */
{
Return (0x85)
} /* non-existant signal was acquired */
Debug = "Acquire Lvalue signal timeout PASS"
Return (0x00) /* success */
} /* TEVN control method to test ResetOp, SignalOp, and WaitOp */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ Event Test"
Local0 = TEVN (0x64)
Return (Local0)
} /* TEST */
} /* EVNT */
/* */
/* test SizeOfLv.asl */
/* */
/* Test for SizeOf (Lvalue) */
/* */
/* This next section will contain the packages that the SizeOfOp will be */
/* exercised on. The first one, PKG0, is a regular package of 3 elements. */
/* The 2nd one, PKG1, is a nested package with 3 packages inside it, each */
/* with 3 elements. It is expected that SizeOf operator will return the */
/* same value for these two packages since they both have 3 elements. The */
/* final package, PKG2, has 4 elements and the SizeOf operator is expected */
/* to return different results for this package. */
Name (PKG0, Package (0x03)
{
0x0123,
0x4567,
0x89AB
}) /* PKG0 */
Name (PKG1, Package (0x03)
{
Package (0x03)
{
0x0123,
0x4567,
0x89AB
},
Package (0x03)
{
0xCDEF,
0xFEDC,
0xBA98
},
Package (0x03)
{
0x7654,
0x3210,
0x1234
}
}) /* PKG1 */
Name (PKG2, Package (0x04)
{
0x0123,
0x4567,
0x89AB,
0x8888
}) /* PKG2 */
Name (PKG3, Package (0x05)
{
0x0123,
0x4567,
0x89AB,
0x8888,
0x7777
}) /* PKG3 */
/* End Packages ********************************************************** */
/* The following section will declare the data strings that will be used to */
/* exercise the SizeOf operator. STR0 and STR1 are expected to be equal, */
/* STR2 is expected to have a different SizeOf value than STR0 and STR1. */
Name (STR0, "ACPI permits very flexible methods of expressing a system")
Name (STR1, "MIKE permits very flexible methods of expressing a system")
Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
/* This string is being made in case we want to do a SizeOf comparison */
/* between strings and packages or buffers */
Name (STR3, "12345")
/* End Strings ********************************************************** */
/* The following section will declare the buffers that will be used to exercise */
/* the SizeOf operator. */
Name (BUF0, Buffer (0x0A){})
Name (BUF1, Buffer (0x0A){})
Name (BUF2, Buffer (0x08){})
Name (BUF3, Buffer (0x05){})
/* End Buffers ********************************************************** */
Device (SZLV)
{
Method (CMPR, 2, NotSerialized)
{
/* CMPR is passed two arguments. If unequal, return 1 to indicate */
/* that, otherwise return 0 to indicate SizeOf each is equal. */
Local0 = 0x01
If ((SizeOf (Arg0) == SizeOf (Arg1)))
{
Local0 = 0x00
}
Return (Local0)
} /* CMPR */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ SizeOfLv Test"
/* TBD: SizeOf ("string") */
/* SizeOf (Buffer) */
/* SizeOf (Package) */
/* SizeOf (String) */
/* SizeOf (STR0) -- where Name (STR0,...) -- lot's of cases */
/* buffer, string, package, */
/* SizeOf (METH) -- where METH control method returns */
/* buffer, string, package, */
/* TBD: SLOC [SizeOf (Local0)] -- dup SARG */
/* Compare the elements that we expect to be the same. Exit out with an error */
/* code on the first failure. */
If ((0x00 != CMPR (STR0, STR1)))
{
Return (0x01)
}
If ((0x00 != CMPR (STR3, BUF3)))
{
Return (0x02)
}
If ((0x00 != CMPR (STR3, PKG3)))
{
Return (0x03)
}
/* In the following section, this test will cover the SizeOf */
/* operator for Local values. */
/* In this case, both Local0 and Local1 should have the same Size */
Local0 = STR0 /* \STR0 */
Local1 = STR1 /* \STR1 */
If ((SizeOf (Local0) != SizeOf (Local1)))
{
Return (0x04)
}
/* Now create a case where Local0 and Local1 are different */
Local1 = STR2 /* \STR2 */
If ((SizeOf (Local0) == SizeOf (Local1)))
{
Return (0x05)
}
/* Finally, check for the return of SizeOf for a known Buffer. Just */
/* in case we magically pass above cases due to all Buffers being Zero */
/* bytes in size, or Infinity, etc. */
If ((0x05 != SizeOf (BUF3)))
{
Return (0x06)
}
Return (0x00)
} /* TEST */
} /* SZLV */
/* */
/* test BytField.asl */
/* */
/* BytField test */
/* This is just a subset of the many RegionOp/Index Field test cases. */
/* Tests access of TBD. */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
Device (BYTF)
{
/* Test device name */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ BytField Test"
Return (\_TZ.C19B.RSLT)
} /* TEST */
} /* BYTF */
Device (C005)
{
/* Device C005 */
Device (C013)
{
/* Device C013 */
} /* Device C013 */
} /* Device C005 */
Method (C115, 0, NotSerialized)
{
/* C115 control method */
Acquire (\_GL, 0xFFFF)
Local0 = \_SB.C005.C013.C058.C07E
Release (\_GL)
Local0 &= 0x10
Store ((Local0 >> 0x04), Local1)
If ((Local1 == 0x00))
{
Return (0x01)
}
Else
{
Return (0x00)
}
} /* C115 control method */
} /* _SB system bus */
OperationRegion (C018, SystemIO, 0x5028, 0x04)
Field (C018, AnyAcc, NoLock, Preserve)
{
/* Field overlaying C018 */
C019, 32
} /* Field overlaying C018 */
OperationRegion (C01A, SystemIO, 0x5030, 0x04)
Field (C01A, ByteAcc, NoLock, Preserve)
{
/* Field overlaying C01A */
C01B, 8,
C01C, 8,
C01D, 8,
C01E, 8
} /* Field overlaying C01A */
Mutex (\C01F, 0x00)
Name (\C020, 0x00)
Name (\C021, 0x00)
Method (\C022, 0, NotSerialized)
{
/* \C022 control method */
Acquire (\C01F, 0xFFFF)
If ((\C021 == 0x00))
{
Local0 = C019 /* \C019 */
Local0 &= 0xFFFEFFFE
C019 = Local0
\C021++
}
Release (\C01F)
} /* \C022 control method */
Scope (\_SB.C005.C013)
{
/* Scope \_SB.C005.C013 */
Device (C058)
{
/* Device C058 */
Name (_HID, "*PNP0A06") // _HID: Hardware ID
OperationRegion (C059, SystemIO, 0xE0, 0x02)
Field (C059, ByteAcc, NoLock, Preserve)
{
/* Field overlaying C059 */
C05A, 8,
C05B, 8
} /* Field overlaying C059 */
OperationRegion (C05C, SystemIO, 0xE2, 0x02)
Field (C05C, ByteAcc, NoLock, Preserve)
{
/* Field overlaying C05C */
C05D, 8,
C05E, 8
} /* Field overlaying C05C */
IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
{
Offset (0x82),
/* IndexField overlaying C05D/C05E */
C05F, 8,
C060, 8,
C061, 8,
C062, 8,
C063, 8,
C064, 8,
C065, 8,
C066, 8,
C067, 8,
C068, 8,
C069, 8,
C06A, 8,
C06B, 8,
C06C, 8,
C06D, 8,
C06E, 8,
Offset (0xA0),
C06F, 8,
C070, 8,
C071, 8,
C072, 8,
C073, 8,
C074, 8,
C075, 8,
C076, 8,
C077, 8,
C078, 8,
C079, 8,
C07A, 8,
C07B, 8,
C07C, 8,
C07D, 8,
C07E, 8
} /* IndexField overlaying C05D/C05E */
OperationRegion (C07F, SystemIO, 0xE4, 0x02)
Field (C07F, ByteAcc, NoLock, Preserve)
{
/* Field overlaying C07F */
C080, 8,
C081, 8
} /* Field overlaying C07F */
OperationRegion (C082, SystemIO, 0xE0, 0x01)
Field (C082, ByteAcc, NoLock, Preserve)
{
/* Field overlaying C082 */
C083, 8
} /* Field overlaying C082 */
OperationRegion (C084, SystemIO, 0xFF, 0x01)
Field (C084, ByteAcc, NoLock, Preserve)
{
/* Field overlaying C084 */
C085, 8
} /* Field overlaying C084 */
OperationRegion (C086, SystemIO, 0xFD, 0x01)
Field (C086, ByteAcc, NoLock, Preserve)
{
/* Field overlaying C086 */
C087, 8
} /* Field overlaying C086 */
Mutex (C088, 0x00)
Mutex (C089, 0x00)
Mutex (C08A, 0x00)
Mutex (C08B, 0x00)
Mutex (C08C, 0x00)
Mutex (C08D, 0x00)
Name (C08E, 0xFFFFFFFD)
Name (C08F, 0x00)
Method (C0AA, 4, NotSerialized)
{
/* C0AA control method */
Local7 = Buffer (0x04){}
CreateByteField (Local7, 0x00, C0AB)
CreateByteField (Local7, 0x01, C0AC)
CreateByteField (Local7, 0x02, C0AD)
CreateByteField (Local7, 0x03, C0AE)
Acquire (^C08B, 0xFFFF)
Acquire (\_GL, 0xFFFF)
\C022 ()
\_SB.C005.C013.C058.C06B = 0x01
While ((0x00 != \_SB.C005.C013.C058.C06B))
{
Stall (0x64)
}
\_SB.C005.C013.C058.C06E = Arg3
\_SB.C005.C013.C058.C06D = Arg2
\_SB.C005.C013.C058.C06C = Arg1
\_SB.C005.C013.C058.C06B = Arg0
While ((0x00 != \_SB.C005.C013.C058.C06B))
{
Stall (0x64)
}
C0AB = \_SB.C005.C013.C058.C06E
C0AC = \_SB.C005.C013.C058.C06D
C0AD = \_SB.C005.C013.C058.C06C
C0AE = \_SB.C005.C013.C058.C06B
If ((Arg0 != 0x17))
{
\_SB.C005.C013.C058.C06B = 0x02
Stall (0x64)
}
Release (\_GL)
Release (^C08B)
Return (Local7)
} /* C0AA control method */
} /* Device C058 */
} /* Scope \_SB.C005.C013 */
Scope (\_TZ)
{
/* \_TZ thermal zone scope */
Name (C18B, Package (0x02)
{
Package (0x02)
{
Package (0x05)
{
0x05AC,
0x0CD2,
0x0D68,
0x0DE0,
0x0E4E
},
Package (0x05)
{
0x0D04,
0x0D9A,
0x0DFE,
0x0E80,
0x0FA2
}
},
Package (0x02)
{
Package (0x05)
{
0x05AC,
0x0CD2,
0x0D68,
0x0DE0,
0x0E4E
},
Package (0x05)
{
0x0D04,
0x0D9A,
0x0DFE,
0x0E80,
0x0FA2
}
}
}) /* C18B */
Name (C18C, Package (0x02)
{
Package (0x02)
{
Package (0x03)
{
0x64,
0x4B,
0x32
},
Package (0x03)
{
0x64,
0x4B,
0x32
}
}
}) /* C81C */
Name (C18D, 0x00)
Name (C18E, 0x00)
Name (C18F, 0x00)
Name (C190, 0x00)
Name (C191, 0x03)
Name (C192, 0x00)
Name (C193, 0x01)
Name (C194, 0x02)
Mutex (C195, 0x00)
Name (C196, 0x01)
Name (C197, 0x0B9C)
Name (C198, 0x0B9C)
Name (C199, 0xFFFFFFFD)
Name (C19A, 0x00)
Device (C19B)
{
/* Device C19B */
Name (RSLT, 0x00) /* default to zero */
Method (XINI, 0, NotSerialized)
{
/* _INI control method (Uses Global Lock -- can't run under AcpiExec) */
C19A = \_SB.C115 ()
\_TZ.C19C._SCP (0x00)
Local1 = (0x0EB2 - 0x0AAC) /* Local1 = AACh - EB2h */
Divide (Local1, 0x0A, Local0, Local2) /* Local0 = Local1 / 10 */
/* Local2 = Local1 % 10 */
\_SB.C005.C013.C058.C0AA (0x0E, Local2, 0x00, 0x00)
C18D = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x00])
C18E = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x01])
C18F = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x02])
RSLT = 0x01 /* set RSLT to 1 if _INI control method completes */
} /* _INI control method */
/* PowerResource (C19D) {...} */
} /* Device C19B */
ThermalZone (C19C)
{
Method (_SCP, 1, NotSerialized) // _SCP: Set Cooling Policy
{
/* _SCP control method */
Local0 = Arg0
If ((Local0 == 0x00))
{
\_TZ.C192 = 0x00
\_TZ.C193 = 0x01
\_TZ.C194 = 0x02
\_TZ.C191 = 0x03
}
Else
{
\_TZ.C191 = 0x00
\_TZ.C192 = 0x01
\_TZ.C193 = 0x02
\_TZ.C194 = 0x03
}
} /* _SCP control method */
} /* ThermalZone C19C */
} /* \_TZ thermal zone scope */
/* */
/* test DwrdFld.asl */
/* */
Name (BUFR, Buffer (0x0A)
{
/* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........
/* 0008 */ 0x00, 0x00 // ..
})
Device (DWDF)
{
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ DwrdFld Test"
CreateByteField (BUFR, 0x00, BYTE)
BYTE = 0xAA
CreateWordField (BUFR, 0x01, WORD)
WORD = 0xBBCC
CreateDWordField (BUFR, 0x03, DWRD)
DWRD = 0xDDEEFF00
CreateByteField (BUFR, 0x07, BYT2)
BYT2 = 0x11
CreateWordField (BUFR, 0x08, WRD2)
WRD2 = 0x2233
Return (0x00)
} /* End Method TEST */
} /* Device DWDF */
/* */
/* test DivAddx.asl */
/* */
Name (B1LO, 0xAA)
Name (B1HI, 0xBB)
Method (MKW, 2, NotSerialized)
{
/* This control method will take two bytes and make them into a WORD */
Local0 = (B1HI * 0x0100) /* Make high byte.....high */
Local0 |= B1LO /* OR in the low byte */ /* \B1LO */
Return (Local0) /* Return the WORD */
} /* MKW_ */
Device (DVAX)
{
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ DivAddx Test"
B1LO = 0x19
B1HI = 0x00
/* We'll multiply 25 * 3 to get 75, add 99 to it then divide */
/* by 100. We expect to get 74 for the remainder and 1 for */
/* the quotient. */
Divide (((0x03 * MKW (B1LO, B1HI)) + 0x63), /* Dividend, */
0x64, /* Divisor */Local4, /* Remainder */
Local2) /* Quotient */
If (((0x4A == Local4) && (0x01 == Local2)))
{
/* Indicate Pass */
Local0 = 0x00
}
Else
{
/* Indicate Fail */
Local0 = 0x01
}
Return (Local0)
} /* End Method TEST */
} /* Device DVAX */
/* */
/* test IndexFld.asl (IndexOp6.asl) */
/* */
/* IndexFld test */
/* This is just a subset of the many RegionOp/Index Field test cases. */
/* Tests index field element AccessAs macro. */
/* Also tests name resolution of index field elements with same names */
/* but different namespace scopes. */
/* */
Device (IDX6)
{
/* Test device name */
OperationRegion (SIO, SystemIO, 0x0100, 0x02)
Field (SIO, ByteAcc, NoLock, Preserve)
{
INDX, 8,
DATA, 8
}
IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
{
AccessAs (ByteAcc, 0x00),
IFE0, 8,
IFE1, 8,
IFE2, 8,
IFE3, 8,
IFE4, 8,
IFE5, 8,
IFE6, 8,
IFE7, 8,
IFE8, 8,
IFE9, 8
}
Device (TST)
{
/* TST_: provides a different namespace scope for IFE0 and IFE1 */
OperationRegion (SIO2, SystemIO, 0x0100, 0x02)
Field (SIO2, ByteAcc, NoLock, Preserve)
{
IND2, 8,
DAT2, 8
}
IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
{
IFE0, /* duplicate IndexField name with different scope */ 8,
IFE1, 8
}
} /* TST_: provides a different namespace scope for IFE0 and IFE1 */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IndexOp6 Test"
Local0 = IFE0 /* \IDX6.IFE0 */
Local1 = IFE1 /* \IDX6.IFE1 */
Local2 = IFE2 /* \IDX6.IFE2 */
/* validate name resolution of IndexFields with different scopes */
Local3 = \IDX6.IFE0
Local4 = \IDX6.IFE1
/* verioading of namespace can resolve following names */
Local5 = \IDX6.TST.IFE0
Local6 = \IDX6.TST.IFE1
Return (0x00)
} /* TEST */
} /* IDX6 */
/* */
/* test IndexOp5.asl */
/* */
/* IndexOp5 test */
/* This is just a subset of the many RegionOp/Index Field test cases. */
/* Tests copying string into buffer then performing IndexOp on result. */
/* */
Device (IDX5)
{
/* Test device name */
Name (OSFL, 0x00) /* 0 == Windows 98, 1 == Windows NT */
/* MCTH is a control method to compare two strings. It returns */
/* zero if the strings mismatch, or 1 if the strings match. */
/* This exercises the test case of copying a string into a buffer */
/* and performing an IndexOp on the resulting buffer. */
Method (MCTH, 2, Serialized)
{
/* MCTH: Control Method to compare two strings */
/* Arg0: first string to compare */
/* Arg1: second string to compare */
/* Return: zero if strings mismatch, 1 if strings match */
/* check if first string's length is less than second string's length */
If ((SizeOf (Arg0) < SizeOf (Arg1)))
{
Return (0x00)
}
/* increment length to include NULL termination character */
Local0 = (SizeOf (Arg0) + 0x01) /* Local0 = strlen(Arg0) + 1 */
/* create two buffers of size Local0 [strlen(Arg0)+1] */
Name (BUF0, Buffer (Local0){})
Name (BUF1, Buffer (Local0){})
/* copy strings into buffers */
BUF0 = Arg0
BUF1 = Arg1
/* validate BUF0 and BUF1 are still buffers */
Local1 = ObjectType (BUF0)
If ((Local1 != 0x03)) /* Buffer is type 3 */
{
Return (0x14)
}
Local1 = ObjectType (BUF1)
If ((Local1 != 0x03)) /* Buffer is type 3 */
{
Return (0x15)
}
/* Decrement because the Index base below is zero based */
/* while Local0 length is one based. */
Local0--
While (Local0)
{
/* loop through all BUF0 buffer elements */
Local0--
/* check if BUF0[n] == BUF1[n] */
If ((DerefOf (BUF0 [Local0]) == DerefOf (BUF1 [Local0]))){} /* this is how the code was really implemented */
Else
{
Return (Zero)
}
} /* loop through all BUF0 buffer elements */
Return (One) /* strings / buffers match */
} /* MCTH: Control Method to compare two strings */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IndexOp5 Test"
If (MCTH (\_OS, "Microsoft Windows NT"))
{
OSFL = 0x01
}
If ((OSFL != 0x01))
{
Return (0x0B)
}
Return (0x00)
} /* TEST */
} /* IDX5 */
/* */
/* test IndexOp.asl */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
Method (C097, 0, NotSerialized)
{
Return (0x01)
}
Device (PCI2)
{
/* Root PCI Bus */
Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID
Name (_ADR, 0x00) // _ADR: Address
Name (_CRS, Buffer (0x1A) // _CRS: Current Resource Settings
{
"_SB_.PCI2._CRS..........."
})
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}
Device (ISA)
{
/* ISA bridge */
Name (_ADR, 0x00030000) /* ISA bus ID */ // _ADR: Address
Device (EC0)
{
/* Embedded Controller */
Name (_GPE, 0x00) /* EC use GPE0 */ // _GPE: General Purpose Events
Name (_ADR, 0x00030000) /* PCI address */ // _ADR: Address
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
} /* EC is functioning */
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0062, // Range Minimum
0x0062, // Range Maximum
0x01, // Alignment
0x01, // Length
)
IO (Decode16,
0x0066, // Range Minimum
0x0066, // Range Maximum
0x01, // Alignment
0x01, // Length
)
})
/* create EC's region and field */
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
/* AC information */
ADP, /* AC Adapter 1:On-line, 0:Off-line */ 1,
AFLT, /* AC Adapter Fault 1:Fault 0:Normal */ 1,
BAT0, /* BAT0 1:present, 0:not present */ 1,
, 1,
Offset (0x04),
/* CMBatt information */
BPU0, /* Power Unit */ 32,
BDC0, /* Designed Capacity */ 32,
BFC0, /* Last Full Charge Capacity */ 32,
BTC0, /* Battery Technology */ 32,
BDV0, /* Design Voltage */ 32,
BST0, /* Battery State */ 32,
BPR0, /* Battery Present Rate */ 32,
/* (Designed Capacity)x(%)/{(h)x100} */
BRC0, /* Battery Remaining Capacity */ 32,
/* (Designed Capacity)(%)^100 */
BPV0, /* Battery Present Voltage */ 32,
BTP0, /* Trip Point */ 32,
BCW0, /* Design capacity of Warning */ 32,
BCL0, /* Design capacity of Low */ 32,
BCG0, /* capacity granularity 1 */ 32,
BG20, /* capacity granularity 2 */ 32,
BMO0, /* Battery model number field */ 32,
BIF0, /* OEM Information(00h) */ 32,
BSN0, /* Battery Serial Number */ 32,
BTY0, /* Battery Type (e.g., "Li-Ion") */ 32,
BTY1, /* Battery Type (e.g., "Li-Ion") */ 32
} /* Field */
} /* EC0: Embedded Controller */
} /* ISA bridge */
} /* PCI2 Root PCI Bus */
Device (IDX0)
{
/* Test device name */
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) /* Control Method Battey ID */ // _HID: Hardware ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
Method (_STA, 0, NotSerialized) // _STA: Status
{
/* _STA bits 0-3 indicate existence of battery slot */
/* _STA bit 4 indicates battery (not) present */
If (\_SB.PCI2.ISA.EC0.BAT0)
{
Return (0x1F)
} /* Battery present */
Else
{
Return (0x0F)
} /* Battery not present */
} /* _STA */
Method (_BIF, 0, Serialized) // _BIF: Battery Information
{
Name (BUFR, Package (0x0D){})
BUFR [0x00] = \_SB.PCI2.ISA.EC0.BPU0 /* Power Unit */
BUFR [0x01] = \_SB.PCI2.ISA.EC0.BDC0 /* Designed Capacity */
BUFR [0x02] = \_SB.PCI2.ISA.EC0.BFC0 /* Last Full Charge Capa. */
BUFR [0x03] = \_SB.PCI2.ISA.EC0.BTC0 /* Battery Technology */
BUFR [0x04] = \_SB.PCI2.ISA.EC0.BDV0 /* Designed Voltage */
BUFR [0x05] = \_SB.PCI2.ISA.EC0.BCW0 /* Designed warning level */
BUFR [0x06] = \_SB.PCI2.ISA.EC0.BCL0 /* Designed Low level */
BUFR [0x07] = \_SB.PCI2.ISA.EC0.BCG0 /* Capacity granularity 1 */
BUFR [0x08] = \_SB.PCI2.ISA.EC0.BG20 /* Capacity granularity 2 */
BUFR [0x09] = "" /* Model Number */
BUFR [0x0A] = "" /* Serial Number */
BUFR [0x0B] = "LiOn" /* Battery Type */
BUFR [0x0C] = "Chicony" /* OEM Information */
Return (BUFR) /* \_SB_.IDX0._BIF.BUFR */
} /* _BIF */
Method (_BST, 0, Serialized) // _BST: Battery Status
{
Name (BUFR, Package (0x04)
{
0x01,
0x0100,
0x76543210,
0x0180
})
Return (BUFR) /* \_SB_.IDX0._BST.BUFR */
} /* _BST */
Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point
{
\_SB.PCI2.ISA.EC0.BTP0 = Arg0 /* Set Battery Trip point */
}
Method (TEST, 0, Serialized)
{
Debug = "++++++++ IndexOp Test"
/* test storing into uninitialized package elements */
Name (PBUF, Package (0x04){}) /* leave unitialized */
PBUF [0x00] = 0x01234567
PBUF [0x01] = 0x89ABCDEF
PBUF [0x02] = 0xFEDCBA98
PBUF [0x03] = 0x76543210
/* verify values stored into uninitialized package elements */
If ((DerefOf (PBUF [0x00]) != 0x01234567))
{
Return (0x10)
}
If ((DerefOf (PBUF [0x01]) != 0x89ABCDEF))
{
Return (0x11)
}
If ((DerefOf (PBUF [0x02]) != 0xFEDCBA98))
{
Return (0x12)
}
If ((DerefOf (PBUF [0x03]) != 0x76543210))
{
Return (0x13)
}
/* store _BIF package return value into Local0 */
Local0 = _BIF ()
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Package */
If ((Local1 != 0x04)) /* Package type is 4 */
{
Return (0x21)
} /* failure */
/* test storing into buffer field elements */
Name (BUFR, Buffer (0x10)
{
/* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........
}) /* BUFR */
/* test storing into buffer field elements */
BUFR [0x00] = 0x01234567 /* should only store 0x67 */
BUFR [0x04] = 0x89ABCDEF /* should only store 0xEF */
BUFR [0x08] = 0xFEDCBA98 /* should only store 0x98 */
BUFR [0x0C] = 0x76543210 /* should only store 0x10 */
/* verify storing into buffer field elements */
If ((DerefOf (BUFR [0x00]) != 0x67))
{
Return (0x30)
}
If ((DerefOf (BUFR [0x01]) != 0x00))
{
Return (0x31)
}
If ((DerefOf (BUFR [0x04]) != 0xEF))
{
Return (0x34)
}
If ((DerefOf (BUFR [0x08]) != 0x98))
{
Return (0x38)
}
If ((DerefOf (BUFR [0x0C]) != 0x10))
{
Return (0x3C)
}
Return (0x00) /* pass */
} /* TEST */
} /* IDX0 */
} /* _SB system bus */
/* */
/* test BitIndex.asl */
/* */
/* BitIndex test */
/* This is a test case for accessing fields defined as single bits in */
/* memory. This is done by creating two index fields that overlay the */
/* same DWORD in memory. One field accesses the DWORD as a DWORD, the */
/* other accesses individual bits of the same DWORD field in memory. */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
OperationRegion (RAM, SystemMemory, 0x00800000, 0x0100)
Field (RAM, AnyAcc, NoLock, Preserve)
{
/* Any access */
TREE, 3,
WRD0, 16,
WRD1, 16,
WRD2, 16,
WRD3, 16,
WRD4, 16,
DWRD, /* DWORD field */ 32
}
Field (RAM, AnyAcc, NoLock, Preserve)
{
/* Any access */
THRE, 3,
WD00, 16,
WD01, 16,
WD02, 16,
WD03, 16,
WD04, 16,
BYT0, /* Start off with a BYTE */ 8,
BIT0, /* single-bit field */ 1,
BIT1, /* single-bit field */ 1,
BIT2, /* single-bit field */ 1,
BIT3, /* single-bit field */ 1,
BIT4, /* single-bit field */ 1,
BIT5, /* single-bit field */ 1,
BIT6, /* single-bit field */ 1,
BIT7, /* single-bit field */ 1,
BIT8, /* single-bit field */ 1,
BIT9, /* single-bit field */ 1,
BITA, /* single-bit field */ 1,
BITB, /* single-bit field */ 1,
BITC, /* single-bit field */ 1,
BITD, /* single-bit field */ 1,
BITE, /* single-bit field */ 1,
BITF, /* single-bit field */ 1,
BYTZ, /* End with a BYTE for a total of 32 bits */ 8
}
Device (BITI)
{
/* Test device name */
Method (MBIT, 0, NotSerialized)
{
If ((DWRD != 0x00))
{
Local0 = 0xFF00
}
Else
{
/* Prime Local0 with 0...assume passing condition */
Local0 = 0x00
/* set memory contents to known values using DWORD field */
DWRD = 0x5A5A5A5A
/* Given the value programmed into DWRD, only the odd bits */
/* of the lower nibble should be set. BIT1, BIT3 should be set. */
/* BIT0 and BIT2 should be clear */
If (BIT0)
{
Local0 |= 0x01
}
If (!BIT1)
{
Local0 |= 0x02
}
If (BIT2)
{
Local0 |= 0x04
}
If (!BIT3)
{
Local0 |= 0x08
}
/* Now check the upper nibble. Only the "even" bits should */
/* be set. BIT4, BIT6. BIT5 and BIT7 should be clear. */
If (!BIT4)
{
Local0 |= 0x10
}
If (BIT5)
{
Local0 |= 0x20
}
If (!BIT6)
{
Local0 |= 0x40
}
If (BIT7)
{
Local0 |= 0x80
}
} /* End Else DWRD zeroed out */
Return (Local0)
} /* MBIT: Test single bit memory accesses */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ BitIndex Test"
/* Zero out DWRD */
DWRD = 0x00
/* MBIT returns zero if successful */
/* This may be causing problems -- Return (MBIT) */
Local0 = MBIT ()
Return (Local0)
} /* TEST */
} /* BITI */
} /* _SB system bus */
/* */
/* test IndexOp3.asl */
/* */
/* Additional IndexOp test cases to support ACPICMB (control method battery */
/* test) on Compaq laptops. Test cases include storing a package into */
/* an IndexOp target and validating that changing source and destination */
/* package contents are independent of each other. */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
Name (C174, 0x0D)
Name (C175, 0x08)
Device (C158)
{
/* C158: AC Adapter device */
Name (_HID, "ACPI0003" /* Power Source Device */) /* AC Adapter device */ // _HID: Hardware ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
Method (_PSR, 0, NotSerialized) // _PSR: Power Source
{
Acquire (\_GL, 0xFFFF)
Release (\_GL)
Local0 &= 0x01 /* Local0 &= 1 */
Return (Local0)
} /* _PSR */
} /* C158: AC Adapter device */
Name (C176, Package (0x04)
{
"Primary",
"MultiBay",
"DockRight",
"DockLeft"
})
Name (C177, Package (0x04)
{
0x99F5,
0x99F5,
0x995F,
0x995F
})
Name (C178, Package (0x04)
{
Package (0x04)
{
0x00,
0x00,
0x966B,
0x4190
},
Package (0x04)
{
0x00,
0x00,
0x966B,
0x4190
},
Package (0x04)
{
0x00,
0x00,
0x966B,
0x4190
},
Package (0x04)
{
0x00,
0x00,
0x966B,
0x4190
}
}) /* C178 */
Name (C179, Package (0x04)
{
0x00,
0x00,
0x966B,
0x4190
})
Name (C17A, Package (0x04)
{
Package (0x03)
{
0x00,
0x00,
0x00
},
Package (0x03)
{
0x00,
0x00,
0x00
},
Package (0x03)
{
0x00,
0x00,
0x00
},
Package (0x03)
{
0x00,
0x00,
0x00
}
}) /* C17A */
Method (C17B, 1, Serialized)
{
/* C17B: _BIF implementation */
Name (C17C, Package (0x0D)
{
/* C17C: _BIF control method return package */
0x00, /* Power Unit (0 ==> mWh and mW) */
0x99F5, /* Design Capacity */
0x99F5, /* Last Full Charge Capacity */
0x01, /* Battery Technology (1 ==> rechargeable) */
0x3840, /* Design Voltage */
0x1280, /* Design Capacity of Warning */
0x0AC7, /* Design Capacity of Low */
0x01, /* Battery Capacity Granularity 1 (Low -- Warning) */
0x01, /* Battery Capacity Granularity 2 (Warning -- Full) */
"2891", /* Model Number (ASCIIZ) */
"(-Unknown-)", /* Serial Number (ASCIIZ) */
"LIon", /* Battery Type (ASCIIZ) */
0x00 /* OEM Information (ASCIIZ) */
}) /* C17C: _BIF control method return package */
Local0 = (Arg0 & 0x07) /* Local0 = Arg0 & 7 */
Local4 = (Local0 >> 0x01) /* Local4 = Local0 >> 1 */
C178 [Local4] = C179 /* C178->Local4 = C179 */ /* \_SB_.C179 */
/* verify source and destination packages can be altered independent */
/* of each other (i.e., changing one's contents does NOT change other's */
/* contents) */
C179 [0x02] = 0x1234 /* C179[2] = 0x1234 */
Local2 = DerefOf (C179 [0x02]) /* Local2 = C179[2] */
If ((Local2 != 0x1234))
{
Return (0x1234)
}
/* Local2 = C178[0,2] */
Local2 = DerefOf (DerefOf (C178 [0x00]) [0x02])
If ((Local2 != 0x966B))
{
Return (0x1234)
}
/* Restore data to allow iterative execution */
C179 [0x02] = 0x966B /* C179[2] = 0x966B */
/* C178[0,3] = 0x5678 */
DerefOf (C178 [0x00]) [0x03] = 0x5678
/* Local2 = C178[0,3] */
Local2 = DerefOf (DerefOf (C178 [0x00]) [0x03])
If ((Local2 != 0x5678))
{
Return (0x5678)
}
Local2 = DerefOf (C179 [0x03]) /* Local2 = C179[3] */
If ((Local2 != 0x4190))
{
Return (0x5678)
}
/* Restore data to allow iterative execution */
DerefOf (C178 [0x00]) [0x03] = 0x4190 /* C179[2] = 0x4190 */
Return (C17C) /* \_SB_.C17B.C17C */
} /* C17B: _BIF implementation */
Device (C154)
{
/* C154: Battery 0 */
Name (_HID, "*PNP0C0A") /* Control Method Battey ID */ // _HID: Hardware ID
Name (_UID, 0x00) /* first instance */ // _UID: Unique ID
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
{
/* _BIF */
Return (C17B (0x30))
} /* _BIF */
} /* C154: Battery 0 */
Device (IDX3)
{
Method (LCLB, 0, Serialized)
{
/* LCLB control method: test Index(Local#) where Local# is buffer */
/* Local0 is index counter */
/* Local1 is buffer */
/* Local2 receives BUFR[Local0] via Deref(Index(Local1...)) */
/* Local3 is Local1 or Local2 object type */
/* Local4 is return error code */
Name (BUFR, Buffer (0x0A)
{
/* 0000 */ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // ........
/* 0008 */ 0x08, 0x09 // ..
})
/* save PKG into Local1 */
Local1 = BUFR /* \_SB_.IDX3.LCLB.BUFR */
/* save Local2 object type value into Local3 */
Local3 = ObjectType (Local1)
/* validate Local1 is a Buffer */
If ((Local3 != 0x03)) /* Buffer type is 3 */
{
Return (0x9F)
}
Local0 = 0x00
While ((Local0 < 0x05))
{
/* While (Local0 < 5) */
/* Local2 = Local1[Local0] */
Local2 = DerefOf (Local1 [Local0])
/* save Local2 object type value into Local3 */
Local3 = ObjectType (Local2)
/* validate Local2 is a Number */
If ((Local3 != 0x01)) /* Number type is 1 */
{
Return (0x9E)
}
/* validate Local1[Local0] value == Local0 */
If ((Local0 != Local2))
{
/* Local0 != Local2 == PKG[Local0] */
/* Local4 = 0x90 + loop index (Local0) */
Local4 = (0x90 + Local0)
/* return 0x90 + loop index */
Return (Local4)
}
Local0++
} /* While (Local0 < 5) */
Debug = "DerefOf(Index(LocalBuffer,,)) PASS"
Return (0x00) /* Pass */
} /* LCLB control method: test Index(Local#) where Local# is buffer */
Method (LCLP, 0, Serialized)
{
/* LCLP control method: test Index(Local#) where Local# is package */
/* Local0 is index counter */
/* Local1 is package */
/* Local2 receives PKG[Local0] via Deref(Index(Local1...)) */
/* Local3 is Local1 or Local2 object type */
/* Local4 is return error code */
Name (PKG, Package (0x0A)
{
0x00,
0x01,
0x02,
0x03,
0x04,
0x05,
0x06,
0x07,
0x08,
0x09
})
/* save PKG into Local1 */
Local1 = PKG /* \_SB_.IDX3.LCLP.PKG_ */
/* save Local2 object type value into Local3 */
Local3 = ObjectType (Local1)
/* validate Local1 is a Package */
If ((Local3 != 0x04)) /* Package type is 4 */
{
Return (0x8F)
}
Local0 = 0x00
While ((Local0 < 0x05))
{
/* While (Local0 < 5) */
/* Local2 = Local1[Local0] */
Local2 = DerefOf (Local1 [Local0])
/* save Local2 object type value into Local3 */
Local3 = ObjectType (Local2)
/* validate Local2 is a Number */
If ((Local3 != 0x01)) /* Number type is 1 */
{
Return (0x8E)
}
/* validate Local1[Local0] value == Local0 */
If ((Local0 != Local2))
{
/* Local0 != Local2 == PKG[Local0] */
/* Local4 = 0x80 + loop index (Local0) */
Local4 = (0x80 + Local0)
/* return 0x80 + loop index */
Return (Local4)
}
Local0++
} /* While (Local0 < 5) */
Debug = "DerefOf(Index(LocalPackage,,)) PASS"
Return (0x00) /* Pass */
} /* LCLP control method: test Index(Local#) where Local# is package */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IndexOp3 Test"
/* store _BIF package return value into Local0 */
Local0 = \_SB.C154._BIF ()
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Package */
If ((Local1 != 0x04)) /* Package type is 4 */
{
/* failure: did not return a Package (type 4) */
/* if Local0 is a Number, it contains an error code */
If ((Local1 == 0x01)) /* Number type is 1 */
{
Return (Local0)
} /* return Local0 error code */
Else
{
Return (0x01)
} /* return default error code */
} /* failure: did not return a Package (type 4) */
/* save LCLB control method return value into Local2 */
Local2 = LCLB ()
If ((Local2 != 0x00))
{
Return (Local2)
} /* return failure code */
/* save LCLP control method return value into Local2 */
Local2 = LCLP ()
If ((Local2 != 0x00))
{
Return (Local2)
} /* return failure code */
Return (0x00) /* Pass */
} /* TEST */
} /* IDX3: Test device name */
} /* _SB system bus */
/* */
/* MTL developed test to exercise Indexes into buffers */
/* */
Device (IDX7)
{
Name (PKG4, Package (0x05)
{
0x02,
"A short string",
Buffer (0x04)
{
0x0A, 0x0B, 0x0C, 0x0D // ....
},
0x1234,
Package (0x02)
{
IDX7,
0x03
}
})
/* */
/* Generic Test method */
/* */
/* This test returns 0xE (14) - ObjectType = Buffer Field */
Method (TST1, 0, Serialized)
{
Name (DEST, Buffer (0x3F)
{
"Destination buffer that is longer than the short source buffer"
})
/* verify object type returned by Index(Buffer,Element,) */
Store (DEST [0x02], Local1)
Local2 = ObjectType (Local1)
If ((Local2 == 0x0E))
{
Return (0x00)
}
Else
{
Return (0x01)
}
}
Method (TST2, 0, Serialized)
{
Name (BUF0, Buffer (0x05)
{
0x01, 0x02, 0x03, 0x04, 0x05 // .....
})
BUF0 [0x02] = 0x55
Local0 = DerefOf (BUF0 [0x02])
If ((Local0 == 0x55))
{
Return (0x00)
}
Else
{
Return (0x02)
}
}
Method (TST3, 0, Serialized)
{
Name (BUF1, Buffer (0x05)
{
0x01, 0x02, 0x03, 0x04, 0x05 // .....
})
Store (BUF1 [0x01], Local0)
Local1 = DerefOf (Local0)
If ((Local1 == 0x02))
{
Return (0x00)
}
Else
{
Return (0x03)
}
}
Method (TST4, 0, NotSerialized)
{
/* Index (PKG4, 0) is a Number */
Store (PKG4 [0x00], Local0)
Local1 = ObjectType (Local0)
If ((Local1 == 0x01))
{
Return (0x00)
}
Else
{
Return (0x04)
}
}
Method (TST5, 0, NotSerialized)
{
/* Index (PKG4, 1) is a String */
Store (PKG4 [0x01], Local0)
Local1 = ObjectType (Local0)
If ((Local1 == 0x02))
{
Return (0x00)
}
Else
{
Return (0x05)
}
}
Method (TST6, 0, NotSerialized)
{
/* Index (PKG4, 2) is a Buffer */
Store (PKG4 [0x02], Local0)
Local1 = ObjectType (Local0)
If ((Local1 == 0x03))
{
Return (0x00)
}
Else
{
Return (0x06)
}
}
Method (TST7, 0, NotSerialized)
{
/* Index (PKG4, 3) is a Number */
Store (PKG4 [0x03], Local0)
Local1 = ObjectType (Local0)
If ((Local1 == 0x01))
{
Return (0x00)
}
Else
{
Return (0x07)
}
}
Method (TST8, 0, NotSerialized)
{
/* Index (PKG4, 4) is a Package */
Store (PKG4 [0x04], Local0)
Local1 = ObjectType (Local0)
If ((Local1 == 0x04))
{
Return (0x00)
}
Else
{
Return (0x08)
}
}
Method (TST9, 0, NotSerialized)
{
/* DerefOf (Index (PKG4, 0)) is a Number */
Local0 = DerefOf (PKG4 [0x00])
If ((Local0 == 0x02))
{
Return (0x00)
}
Else
{
Return (0x09)
}
}
Method (TSTA, 0, NotSerialized)
{
/* DerefOf (Index (PKG4, 1)) is a String */
Local0 = DerefOf (PKG4 [0x01])
Local1 = SizeOf (Local0)
If ((Local1 == 0x0E))
{
Return (0x00)
}
Else
{
Return (0x0A)
}
}
Method (TSTB, 0, NotSerialized)
{
/* DerefOf (Index (PKG4, 2)) is a Buffer */
Local0 = DerefOf (PKG4 [0x02])
Local1 = SizeOf (Local0)
If ((Local1 == 0x04))
{
Return (0x00)
}
Else
{
Return (0x0B)
}
}
Method (TSTC, 0, NotSerialized)
{
/* DerefOf (Index (PKG4, 3)) is a Number */
Local0 = DerefOf (PKG4 [0x03])
If ((Local0 == 0x1234))
{
Return (0x00)
}
Else
{
Return (0x0C)
}
}
Method (TSTD, 0, NotSerialized)
{
/* DerefOf (Index (PKG4, 4)) is a Package */
Local0 = DerefOf (PKG4 [0x04])
Local1 = SizeOf (Local0)
If ((Local1 == 0x02))
{
Return (0x00)
}
Else
{
Return (0x0D)
}
}
Method (TSTE, 0, NotSerialized)
{
/* DerefOf (Index (PKG4, 2)) is a Buffer */
Local0 = DerefOf (PKG4 [0x02])
/* DerefOf (Index (Local0, 1)) is a Number */
Local1 = DerefOf (Local0 [0x01])
If ((Local1 == 0x0B))
{
Return (0x00)
}
Else
{
Return (0x0E)
}
}
Method (TSTF, 0, Serialized)
{
Name (SRCB, Buffer (0x0C){}) /* 12 characters */
SRCB = "Short Buffer"
Name (DEST, Buffer (0x3F)
{
"Destination buffer that is longer than the short source buffer"
})
/* overwrite DEST contents, starting at buffer position 2 */
DEST [0x02] = SRCB /* \IDX7.TSTF.SRCB */
/* */
/* The DEST buffer element should be replaced with the last element of */
/* the SRCB element (i.e. 's'->'r') */
Local0 = DerefOf (DEST [0x02])
If ((Local0 != 0x72)) /* 'r' */
{
/* DEST element does not match the value from SRCB */
Return ((Local0 | 0x1000))
}
Return (0x00)
}
Method (TSTG, 0, Serialized)
{
Name (SRCB, Buffer (0x0C){}) /* 12 characters */
SRCB = "Short Buffer"
Name (DEST, Buffer (0x3F)
{
"Destination buffer that is longer than the short source buffer"
})
/* overwrite DEST contents, starting at buffer position 2 */
DEST [0x02] = SRCB /* \IDX7.TSTG.SRCB */
/* */
/* The next element of DEST should be unchanged */
/* */
Local0 = DerefOf (DEST [0x03])
If ((Local0 != 0x74)) /* 't' */
{
/* DEST has been changed */
Return ((Local0 | 0x2000))
}
/* */
/* The next element of DEST should be unchanged */
/* */
Local0 = DerefOf (DEST [0x04])
If ((Local0 != 0x69)) /* 'i' */
{
/* DEST has been changed */
Return ((Local0 | 0x2100))
}
/* */
/* The next element of DEST should be unchanged */
/* */
Local0 = DerefOf (DEST [0x05])
If ((Local0 != 0x6E)) /* 'n' */
{
/* DEST has been changed */
Return ((Local0 | 0x2200))
}
/* */
/* The next element of DEST should be unchanged */
/* */
Local0 = DerefOf (DEST [0x06])
If ((Local0 != 0x61)) /* 'a' */
{
/* DEST has been changed */
Return ((Local0 | 0x2300))
}
/* */
/* The next element of DEST should be unchanged */
/* */
Local0 = DerefOf (DEST [0x07])
If ((Local0 != 0x74)) /* 't' */
{
/* DEST has been changed */
Return ((Local0 | 0x2400))
}
/* */
/* Verify DEST elements beyond end of SRCB buffer copy */
/* have not been changed */
Local0 = DerefOf (DEST [0x0E])
If ((Local0 != 0x66)) /* 'f' */
{
/* DEST has been changed */
Return ((Local0 | 0x2400))
}
Return (0x00)
}
/* */
/* This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit */
/* number into the index'ed buffer */
/* */
Method (TSTH, 0, Serialized)
{
/* Create a Destination Buffer */
Name (DBUF, Buffer (0x1B)
{
"abcdefghijklmnopqrstuvwxyz"
})
/* Store a number > UINT8 into an index of the buffer */
DBUF [0x02] = 0x12345678
/* Check the results */
Local0 = DerefOf (DBUF [0x02])
If ((Local0 != 0x78)) /* 0x78 */
{
Return ((Local0 | 0x3000))
}
Local0 = DerefOf (DBUF [0x03])
If ((Local0 != 0x64)) /* 'd' */
{
Return ((Local0 | 0x3100))
}
Local0 = DerefOf (DBUF [0x04])
If ((Local0 != 0x65)) /* 'e' */
{
Return ((Local0 | 0x3200))
}
Local0 = DerefOf (DBUF [0x05])
If ((Local0 != 0x66)) /* 'f' */
{
Return ((Local0 | 0x3300))
}
Return (0x00)
}
Method (TSTI, 0, Serialized)
{
/* Create a Destination Buffer */
Name (DBUF, Buffer (0x1B)
{
"abcdefghijklmnopqrstuvwxyz"
})
/* Store a String into an index of the buffer */
DBUF [0x02] = "ABCDEFGH"
/* Check the results */
Local0 = DerefOf (DBUF [0x02])
If ((Local0 != 0x48)) /* 'H' */
{
Return ((Local0 | 0x4000))
}
Local0 = DerefOf (DBUF [0x03])
If ((Local0 != 0x64)) /* 'd' */
{
Return ((Local0 | 0x4100))
}
Local0 = DerefOf (DBUF [0x04])
If ((Local0 != 0x65)) /* 'e' */
{
Return ((Local0 | 0x4200))
}
Local0 = DerefOf (DBUF [0x05])
If ((Local0 != 0x66)) /* 'f' */
{
Return ((Local0 | 0x4300))
}
Return (0x00)
}
Method (TSTJ, 0, Serialized)
{
/* Create a Destination Buffer */
Name (DBUF, Buffer (0x1B)
{
"abcdefghijklmnopqrstuvwxyz"
})
/* Store a number > UINT8 into an index of the buffer */
DBUF [0x02] = 0x1234
/* Check the results */
Local0 = DerefOf (DBUF [0x02])
If ((Local0 != 0x34)) /* 0x34 */
{
Return ((Local0 | 0x3000))
}
Local0 = DerefOf (DBUF [0x03])
If ((Local0 != 0x64)) /* 'd' */
{
Return ((Local0 | 0x3100))
}
Local0 = DerefOf (DBUF [0x04])
If ((Local0 != 0x65)) /* 'e' */
{
Return ((Local0 | 0x3200))
}
Local0 = DerefOf (DBUF [0x05])
If ((Local0 != 0x66)) /* 'f' */
{
Return ((Local0 | 0x3300))
}
Return (0x00)
}
Method (TSTK, 0, Serialized)
{
/* Create a Destination Buffer */
Name (DBUF, Buffer (0x1B)
{
"abcdefghijklmnopqrstuvwxyz"
})
/* Store a number > UINT8 into an index of the buffer */
DBUF [0x02] = 0x00123456
/* Check the results */
Local0 = DerefOf (DBUF [0x02])
If ((Local0 != 0x56)) /* 0x56 */
{
Return ((Local0 | 0x3000))
}
Local0 = DerefOf (DBUF [0x03])
If ((Local0 != 0x64)) /* 'd' */
{
Return ((Local0 | 0x3100))
}
Local0 = DerefOf (DBUF [0x04])
If ((Local0 != 0x65)) /* 'e' */
{
Return ((Local0 | 0x3200))
}
Local0 = DerefOf (DBUF [0x05])
If ((Local0 != 0x66)) /* 'f' */
{
Return ((Local0 | 0x3300))
}
Return (0x00)
}
Method (TSTL, 0, Serialized)
{
/* Create a Destination Buffer */
Name (DBUF, Buffer (0x1B)
{
"abcdefghijklmnopqrstuvwxyz"
})
/* Store a number > UINT8 into an index of the buffer */
DBUF [0x02] = 0x12
/* Check the results */
Local0 = DerefOf (DBUF [0x02])
If ((Local0 != 0x12)) /* 0x12 */
{
Return ((Local0 | 0x3000))
}
Local0 = DerefOf (DBUF [0x03])
If ((Local0 != 0x64)) /* 'd' */
{
Return ((Local0 | 0x3100))
}
Local0 = DerefOf (DBUF [0x04])
If ((Local0 != 0x65)) /* 'e' */
{
Return ((Local0 | 0x3200))
}
Local0 = DerefOf (DBUF [0x05])
If ((Local0 != 0x66)) /* 'f' */
{
Return ((Local0 | 0x3300))
}
Return (0x00)
}
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IndexOp7 Test"
Local0 = TST1 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST2 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST3 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST4 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST5 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST6 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST7 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST8 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TST9 ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTA ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTB ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTC ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTD ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTE ()
If ((Local0 > 0x00))
{
Return (Local0)
}
/* No longer ACPI compliant */
/*
Store(TSTF(), Local0)
if (LGreater (Local0, 0))
{
Return(Local0)
}
*/
Local0 = TSTG ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTH ()
If ((Local0 > 0x00))
{
Return (Local0)
}
/* No longer ACPI compliant */
/*
Store(TSTI(), Local0)
if (LGreater (Local0, 0))
{
Return(Local0)
}
*/
Local0 = TSTJ ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTK ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Local0 = TSTL ()
If ((Local0 > 0x00))
{
Return (Local0)
}
Return (Local0)
}
} /* Device(IDX7) */
/* */
/* test MatchOp.asl */
/* */
/* MatchOp test cases that utilize nested DerefOf(Index(...)) to validate */
/* MatchOp, DerefOfOp, and IndexOp of nested packages. */
/* */
Device (MTCH)
{
Method (TEST, 0, Serialized)
{
Debug = "++++++++ MatchOp Test"
Name (TIM0, Package (0x08)
{
Package (0x04)
{
0x78,
0xB4,
0xF0,
0x0384
},
Package (0x04)
{
0x23,
0x21,
0x10,
0x00
},
Package (0x04)
{
0x0B,
0x09,
0x04,
0x00
},
Package (0x05)
{
0x70,
0x49,
0x36,
0x27,
0x19
},
Package (0x05)
{
0x00,
0x01,
0x02,
0x01,
0x02
},
Package (0x05)
{
0x00,
0x00,
0x00,
0x01,
0x01
},
Package (0x04)
{
0x04,
0x03,
0x02,
0x00
},
Package (0x04)
{
0x02,
0x01,
0x00,
0x00
}
}) /* TIM0 */
Name (TMD0, Buffer (0x14)
{
0xFF, 0xFF, 0xFF, 0xFF // ....
})
CreateDWordField (TMD0, 0x00, PIO0) /* 0xFFFFFFFF */
CreateDWordField (TMD0, 0x04, DMA0)
CreateDWordField (TMD0, 0x08, PIO1)
CreateDWordField (TMD0, 0x0C, DMA1)
CreateDWordField (TMD0, 0x10, CHNF)
/* validate PIO0 value */
Local3 = PIO0 /* \MTCH.TEST.PIO0 */
/* save Local3 object type value into Local2 */
Local2 = ObjectType (Local3)
/* validate Local3 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
Return (0x02)
} /* failure */
/* validate Local3 Number value */
If ((Local3 != 0xFFFFFFFF)) /* Number value 0xFFFFFFFF */
{
Return (0x03)
} /* failure */
Debug = "DWordField PASS"
Local5 = 0x00
Local6 = Match (DerefOf (TIM0 [0x01]), MLE, Local5, MTR, 0x00,
0x00)
/* save Local6 object type value into Local2 */
Local2 = ObjectType (Local6)
/* validate Local6 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
Return (0x04)
} /* failure */
Debug = "Match(DerefOf(Index(TIM0,1)),... PASS"
/* validate following produces a nested package to validate */
/* that MatchOp did not corrupt SearchPackage (TIM0) */
Local4 = DerefOf (TIM0 [0x01])
/* save Local4 object type value into Local2 */
Local2 = ObjectType (Local4)
/* validate Local4 is a Package */
If ((Local2 != 0x04)) /* Package type is 4 */
{
Return (0x05)
} /* failure */
Debug = "DerefOf(Index(TIM0,1)),... PASS"
Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO0, MTR, 0x00,
0x00) & 0x03)
/* save Local0 object type value into Local2 */
Local2 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
Return (0x06)
} /* failure */
/* validate Local0 Number value */
If ((Local0 != 0x03)) /* Number value 3 */
{
Return (0x07)
} /* failure */
Debug = "And(Match(DerefOf(Index(TIM0,0)),... PASS"
/* again, validate following produces a nested package */
Local4 = DerefOf (TIM0 [0x01])
/* save Local4 object type value into Local2 */
Local2 = ObjectType (Local4)
/* validate Local4 is a Package */
If ((Local2 != 0x04)) /* Package type is 4 */
{
Return (0x08)
} /* failure */
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
/* again, validate following produces a nested package */
Local4 = DerefOf (TIM0 [0x01])
/* save Local4 object type value into Local2 */
Local2 = ObjectType (Local4)
/* validate Local4 is a Package */
If ((Local2 != 0x04)) /* Package type is 4 */
{
Return (0x09)
} /* failure */
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
/* test nested DerefOf(Index) operators */
Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0])
/* save Local1 object type value into Local2 */
Local2 = ObjectType (Local1)
/* validate Local1 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
Return (0x0A)
} /* failure */
/* zero indicates pass, non-zero is an error code */
If ((Local1 != 0x00))
{
Return (0x0B)
} /* failure */
Debug = "DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS"
/* again, validate following produces a nested package */
Local4 = DerefOf (TIM0 [0x01])
/* save Local4 object type value into Local2 */
Local2 = ObjectType (Local4)
/* validate Local4 is a Package */
If ((Local2 != 0x04)) /* Package type is 4 */
{
Return (0x0C)
} /* failure */
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
/* retest nested DerefOf(Index) operators */
Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0])
/* save Local1 object type value into Local2 */
Local2 = ObjectType (Local1)
/* validate Local1 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
Return (0x0D)
} /* failure */
/* zero indicates pass, non-zero is an error code */
If ((Local1 != 0x00))
{
Return (0x0E)
} /* failure */
Debug = "DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again"
/* again, validate following produces a nested package */
Local4 = DerefOf (TIM0 [0x01])
/* save Local4 object type value into Local2 */
Local2 = ObjectType (Local4)
/* validate Local4 is a Package */
If ((Local2 != 0x04)) /* Package type is 4 */
{
Return (0x0F)
} /* failure */
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
Return (0x00) /* pass */
} /* TEST */
} /* MTCH */
/* */
/* test WhileBrk.asl */
/* */
/* This code tests the Break term and While term */
/* */
/* Syntax of Break term */
/* BreakTerm := Break */
/* The break operation causes the current package execution to complete. */
/* */
/* Syntax of While Term */
/* WhileTerm := While( */
/* Predicate //TermArg=>Integer */
/* ) {TermList} */
/* Predicate is evaluated as an integer. */
/* If the integer is non-zero, the list of terms in TermList is executed. */
/* The operation repeats until the Predicate evaluates to zero. */
/* */
/* MTL NOTE: This test has been modified to reflect ACPI 2.0 break */
/* NOTE: This test, when run under the MS ACPI.SYS grinds the system to */
/* a halt. */
/* */
Device (WHLB)
{
Name (CNT0, 0x00)
Name (CNT1, 0x00)
Method (TEST, 0, NotSerialized)
{
/* Check Break statement nested in If nested in While nested in */
/* While only exits inner-most While loop */
CNT0 = 0x00
While ((CNT0 < 0x04))
{
CNT1 = 0x00
While ((CNT1 < 0x0A))
{
If ((CNT1 == 0x01))
{
Break /* exit encompassing loop */
}
CNT1++
}
If ((CNT1 != 0x01))
{
/* failure */
Return (0x07)
}
CNT0++
}
/* Verify Break only exited inner-most While loop */
If ((CNT0 != 0x04))
{
/* failure */
Return (0x08)
}
Debug = "While/While/If/Break PASS"
Debug = "++++++++ WhileBrk Test"
/* Check Break statement nested in While */
CNT0 = 0x00
While ((CNT0 < 0x0A))
{
Break
CNT0++
}
If ((CNT0 != 0x00)) /* instruction after Break executed */
{
Return (0x04)
}
CNT0 = 0x00
/* Test While Term */
While ((CNT0 < 0x0A))
{
CNT0++
}
/* Check if the while loop was executed until the condition is satisfied. */
If ((CNT0 != 0x0A))
{
Return (0x01)
}
/* While loop in a reverse order */
While ((CNT0 > 0x00))
{
CNT0--
}
/* Check if the while loop was executed until the condition is satisfied. */
If ((CNT0 != 0x00))
{
Return (0x02)
}
Debug = "While/Break PASS"
/* Check Break statement nested in If nested in While */
CNT0 = 0x00
While ((CNT0 < 0x0A))
{
If ((CNT0 == 0x05))
{
Break
/* if we execute the next instruction, */
/* Break did not exit the loop */
CNT0 = 0x14 /* exit While loop with value larger */
/* than above */
}
CNT0++ /* check if Break exited both If and While */
} /* While */
If ((CNT0 > 0x13))
{
/* instruction after Break inside IfOp executed */
Return (0x05)
}
/* */
/* Break will exit out of the while loop, therefore */
/* the CNT0 counter should still Increment until 5 */
/* */
If ((CNT0 != 0x05))
{
/* instruction after Break inside WhileOp executed */
Return (0x06)
}
Debug = "While/If/Break PASS"
/* All the conditions passed */
Return (0x00)
} /* TEST */
} /* WHLB */
/* */
/* test IndexOp2.asl */
/* */
/* Additional IndexOp test cases to support ACPICMB (control method battery */
/* test) on Toshiba Portege 7020CT. Test cases include appropriate bit */
/* shifting of Field elements and reading Field elements greater than 64 bits. */
/* */
/* MTL NOTE: This test has been modified slightly from the original test */
/* to take into account ACPI specification limitations. */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
Device (MEM)
{
/* MEM */
Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID
Name (_STA, 0x0F) // _STA: Status
OperationRegion (SMEM, SystemMemory, 0x00800000, 0x0100)
Field (SMEM, AnyAcc, NoLock, Preserve)
{
/* Field: SMEM overlay using 32-bit field elements */
SMD0, /* 32-bits */ 32,
SMD1, /* 32-bits */ 32,
SMD2, /* 32-bits */ 32,
SMD3, /* 32-bits */ 32
} /* Field: SMEM overlay using 32-bit field elements */
Field (SMEM, AnyAcc, NoLock, Preserve)
{
/* Field: SMEM overlay using greater than 32-bit field elements */
SME0, /* larger than an integer (32 or 64) */ 69,
SME1, /* larger than an integer */ 97
} /* Field: SMEM overlay using greater than 32-bit field elements */
OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
Field (SRAM, AnyAcc, NoLock, Preserve)
{
Offset (0x6800),
/* Field: SRAM overlay */
IEAX, 32,
IEBX, 32,
IECX, 32,
IEDX, 32,
IESI, 32,
IEDI, 32,
IEBP, 32,
Offset (0x6820),
OEAX, 32,
OEBX, 32,
OECX, 32,
OEDX, 32,
OESI, 32,
OEDI, 32,
OEBP, 32,
Offset (0x68FF),
ACST, 1,
BES1, 1,
BES2, 1,
Offset (0x6900),
BMN1, 104,
BSN1, 88,
BTP1, 72,
BPU1, 32,
BDC1, 32,
BLF1, 32,
BTC1, 32,
BDV1, 32,
BST1, 32,
BPR1, 32,
BRC1, 32,
BPV1, 32,
Offset (0x6949),
BCW1, 32,
BCL1, 32,
BG11, 32,
BG21, 32,
BOI1, 32,
Offset (0x6A03),
BMN2, 104,
BSN2, 88,
BTP2, 72,
BPU2, 32,
BDC2, 32,
BLF2, 32,
BTC2, 32,
BDV2, 32,
BST2, 32,
BPR2, 32,
BRC2, 32,
BPV2, 32,
Offset (0x6A4C),
BCW2, 32,
BCL2, 32,
BG12, 32,
BG22, 32,
BOI2, 32,
Offset (0x6B03),
AC01, 16,
AC11, 16,
PSV1, 16,
CRT1, 16,
TMP1, 16,
AST1, 16,
AC21, 16,
AC31, 16,
AC02, 16,
AC12, 16,
PSV2, 16,
CRT2, 16,
TMP2, 16,
AST2, 16,
AC22, 16,
AC32, 16,
AC03, 16,
AC13, 16,
PSV3, 16,
CRT3, 16,
TMP3, 16,
AST3, 16,
AC23, 16,
AC33, 16,
Offset (0x6B43),
TMPF, 16,
Offset (0x6BF3),
FANH, 1,
FANL, 7,
TF11, 1,
TF21, 1,
TF31, 1,
, 1,
TF10, 1,
TF20, 1,
TF30, 1,
Offset (0x6BF5),
TP11, 1,
TP21, 1,
TP31, 1,
Offset (0x6C03),
GP50, 1,
GP51, 1,
GP52, 1,
GP53, 1,
Offset (0x6C04),
GP60, 1,
GP61, 1,
GP62, 1,
GP63, 1,
GP64, 1,
GP65, 1,
GP66, 1,
Offset (0x6C05),
GP70, 1,
GP71, 1,
GP72, 1,
GP73, 1,
GP74, 1,
GP75, 1,
GP76, 1,
Offset (0x6C06),
WED0, 1,
WED1, 1,
WED2, 1,
WED3, 1,
WED4, 1,
Offset (0x6C07),
SBL0, 1,
SBL1, 1,
SBL2, 1,
SBL3, 1,
Offset (0x6C08),
LIDS, 1,
VALF, 1,
, 2,
DCKI, 1,
DCKF, 1,
BT1F, 1,
BT2F, 1,
Offset (0x6D03),
HKCD, 8,
Offset (0x6D05),
DLID, 32,
DSRN, 32,
Offset (0x6D11),
BDID, 32,
DSPW, 1,
VGAF, 1,
VWE0, 1,
VWE1, 1,
PPSC, 1,
SPSC, 1,
EWLD, 1,
EWPS, 1,
Offset (0x7003),
PRES, 32768
} /* Field: SRAM overlay */
} /* MEM */
Device (BAT1)
{
/* BAT1 */
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) /* Control Method Battey ID */ // _HID: Hardware ID
Name (_UID, 0x01) // _UID: Unique ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
Method (_STA, 0, NotSerialized) // _STA: Status
{
/* _STA */
If (\_SB.MEM.BES1)
{
Return (0x1F)
} /* battery present */
Else
{
Return (0x0F)
} /* battery not present */
} /* _STA */
Method (_BIF, 0, Serialized) // _BIF: Battery Information
{
/* _BIF */
Name (BUFR, Package (0x0D){})
BUFR [0x00] = \_SB.MEM.BPU1
BUFR [0x01] = \_SB.MEM.BDC1
BUFR [0x02] = \_SB.MEM.BLF1
BUFR [0x03] = \_SB.MEM.BTC1
BUFR [0x04] = \_SB.MEM.BDV1
BUFR [0x05] = \_SB.MEM.BCW1
BUFR [0x06] = \_SB.MEM.BCL1
BUFR [0x07] = \_SB.MEM.BG11
BUFR [0x08] = \_SB.MEM.BG21
BUFR [0x09] = \_SB.MEM.BMN1
BUFR [0x0A] = \_SB.MEM.BSN1
BUFR [0x0B] = \_SB.MEM.BTP1
BUFR [0x0C] = \_SB.MEM.BOI1
Return (BUFR) /* \_SB_.BAT1._BIF.BUFR */
} /* _BIF */
} /* BAT1 */
Device (IDX2)
{
Method (B2IB, 0, Serialized)
{
/* B2IB: store from Buffer into Index'ed Buffer */
Name (SRCB, Buffer (0x0D)
{
"Short Buffer"
}) /* 12 characters plus NULL */
Name (DEST, Buffer (0x3F)
{
"Destination buffer that is longer than the short source buffer"
})
/* verify object type returned by Index(Buffer,Element,) */
Store (DEST [0x02], Local1)
Local2 = ObjectType (Local1)
If ((Local2 != 0x0E)) /* Buffer Field is type 14 */
{
/* Local2 indicates Local1 is not a Buffer Field */
Return (0x61)
}
/* verify object type and value returned by DerefOf(Index(Buffer,Element,)) */
/* should return Number containing element value */
Local3 = DerefOf (Local1)
Local4 = ObjectType (Local3)
If ((Local4 != 0x01)) /* Number is type 1 */
{
/* Local2 indicates Local1 is not a Number */
Return (0x62)
}
ElseIf ((Local3 != 0x73)) /* expect 's' element from DEST */
{
Return (0x63)
}
Debug = "DerefOf(Index(Buffer,,)) PASS"
/* */
/* The following sections have been rewritten because storing into */
/* an Indexed buffer only changes one byte - the FIRST byte of the */
/* buffer is written to the source index. This is the ONLY byte */
/* written -- as per ACPI 2.0 */
/* */
/* Overwrite DEST contents, at buffer position 2 [only] */
DEST [0x02] = SRCB /* \_SB_.IDX2.B2IB.SRCB */
/* */
/* Check that the next byte is not changed */
/* */
Local0 = DerefOf (DEST [0x03])
If ((Local0 != 0x74)) /* 't' */
{
/* DEST element is not matching original value */
If ((Local0 == 0x68))
{
/* DEST element was altered to 'h' */
Return (0x68)
}
Else
{
/* DEST element is an unknown value */
Return (0x69)
}
}
/* */
/* Check that the elements beyond the SRCB buffer copy */
/* have not been altered. */
/* */
Local0 = DerefOf (DEST [0x0E])
/* */
/* This should be an 'f'. */
/* */
If ((Local0 != 0x66))
{
/* DEST element was zero'd by buffer copy */
If ((Local0 == 0x00))
{
/* DEST element is zero */
Return (0x6A)
}
Else
{
/* DEST element is unknown value */
Return (0x6B)
}
}
Debug = "Store(SRCB,Index(Buffer,,)) PASS"
/* */
/* verify altering SRCB does NOT alter DEST */
/* */
SRCB [0x01] = 0x6A /* SRCB = "Sjort Buffer" */
Local0 = DerefOf (SRCB [0x01])
If ((Local0 != 0x6A)) /* 'j' */
{
/* SRCB element is unaltered */
Return (0x71)
}
Local0 = DerefOf (DEST [0x03]) /* DEST = "Destination buffer that... */
If ((Local0 != 0x74)) /* 't' */
{
/* DEST element is altered */
If ((Local0 == 0x6A)) /* 'j' */
{
/* SRCB change altered DEST element */
Return (0x72)
}
Else
{
/* DEST element is unknown value */
Return (0x73)
}
}
/* verify altering DEST does NOT alter SRCB */
DEST [0x04] = 0x6B /* DEST = "DeSkination buffer..." */
Local0 = DerefOf (DEST [0x04])
If ((Local0 != 0x6B)) /* 'k' */
{
/* DEST element is unaltered */
Return (0x74)
}
Local0 = DerefOf (SRCB [0x02])
If ((Local0 != 0x6F)) /* 'o' */
{
/* SRC element is altered */
If ((Local0 == 0x6B)) /* 'k' */
{
/* DEST change altered SRCB element */
Return (0x75)
}
Else
{
/* SRCB element is unknown value */
Return (0x76)
}
}
Debug = "SRCB and DEST independent PASS"
/* verify string can be written to Index target/destination */
/* Only FIRST byte is written */
DEST [0x02] = "New Buff" /* DEST = "DeNkination buffer..." */
Local0 = DerefOf (DEST [0x02])
If ((Local0 != 0x4E)) /* 'N' */
{
/* DEST element is unaltered */
Return (0x81)
}
Local0 = DerefOf (DEST [0x06])
If ((Local0 != 0x61)) /* 'a' */
{
/* DEST element is unaltered */
Return (0x82)
}
Local0 = DerefOf (DEST [0x0A])
If ((Local0 != 0x6E)) /* 'n' */
{
/* DEST element is unaltered */
Return (0x83)
}
Debug = "Store(String,Index) PASS"
Return (0x00) /* pass */
} /* B2IB: store from Buffer into Index'ed Buffer */
Method (FB2P, 0, Serialized)
{
/* FB2P: store from Field Buffer into Index'ed Package */
Name (DEST, Package (0x02){})
/* initialize memory using 32-bit field elements */
\_SB.MEM.SMD0 = 0x01234567
\_SB.MEM.SMD1 = 0x89ABCDEF
\_SB.MEM.SMD2 = 0xFEDCBA98
\_SB.MEM.SMD3 = 0x76543210
/* move greater than 64-bit buffers into DEST package */
DEST [0x00] = \_SB.MEM.SME0
DEST [0x01] = \_SB.MEM.SME1
/* validate DEST contents */
Local0 = DerefOf (DEST [0x00])
Local1 = DerefOf (DEST [0x01])
/* verify Local0 and Local1 are Buffers */
Local2 = ObjectType (Local0)
If ((Local2 != 0x03)) /* Buffer type is 3 */
{
Return (0x11)
}
Local3 = ObjectType (Local1)
If ((Local3 != 0x03)) /* Buffer type is 3 */
{
Return (0x12)
}
/* validate DEST buffer contents */
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x00])
If ((Local4 != 0x67))
{
Return (0x13)
}
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x01])
If ((Local4 != 0x45))
{
Return (0x14)
}
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x04])
If ((Local4 != 0xEF))
{
Return (0x15)
}
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x05])
If ((Local4 != 0xCD))
{
Return (0x16)
}
Debug = "Store(Mem,PkgElement) PASS"
/* validate changing source \_SB.MEM.SMD* does not impact DEST */
\_SB.MEM.SMD0 = 0x12345678
Local5 = DerefOf (DerefOf (DEST [0x00]) [0x00])
If ((Local5 != 0x67))
{
Return (0x21)
}
Local5 = DerefOf (DerefOf (DEST [0x00]) [0x01])
If ((Local5 != 0x45))
{
Return (0x22)
}
/* validate changing DEST does not impact source \_SB.MEM.SMD* */
DerefOf (DEST [0x00]) [0x00] = 0x30
Local5 = DerefOf (DerefOf (DEST [0x00]) [0x00])
If ((Local5 != 0x30))
{
Return (0x23)
}
/* */
/* This section was modified from the original iPCO code because */
/* it attempted to compare two buffers. This is not allowed until */
/* ACPI v2.0, so the test has been modified to just check the */
/* changed \_SB.MEM.SMD0 */
/* */
Local5 = \_SB.MEM.SMD0
If ((Local5 != 0x12345678))
{
Return (0x24)
}
Debug = "Mem and Pkg independent PASS"
Return (0x00)
} /* FB2P: store from Field Buffer into Index'ed Package */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ IndexOp2 Test"
/* store _BIF package return value into Local0 */
Local0 = \_SB.BAT1._BIF ()
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Package */
If ((Local1 != 0x04)) /* Package type is 4 */
{
/* failure */
Return (0x02)
}
/* validate source and destination buffers are independent of each */
/* of each other (i.e., changing one's contents does not change */
/* other's contents) using B2IB (store from Buffer into Index'ed */
/* Buffer) and FB2P (store from Field Buffer into Index'ed Package) */
/* call B2IB (store from Buffer into Index'ed Buffer) */
Local2 = B2IB () /* Local2 is B2IB return value */
/* save Local2 object type value into Local3 */
Local3 = ObjectType (Local2)
/* validate Local2 is a Number */
If ((Local3 != 0x01)) /* Number type is 1 */
{
/* failure */
Return (0x04)
}
/* zero indicates pass, non-zero is an error code */
If ((Local2 != 0x00))
{
/* return B2IB error code */
Return (Local2)
}
/* call FB2P (store from Field Buffer into Index'ed Package) */
Local2 = FB2P () /* Local2 is FB2P return value */
/* save Local2 object type value into Local3 */
Local3 = ObjectType (Local2)
/* validate Local2 is a Number */
If ((Local3 != 0x01)) /* Number type is 1 */
{
/* failure */
Return (0x05)
}
/* zero indicates pass, non-zero is an error code */
If ((Local2 != 0x00))
{
/* return FB2P error code */
Return (Local2)
}
Return (0x00)
} /* TEST */
} /* IDX2: Test device name */
} /* _SB system bus */
/* */
/* test SizeOf.asl */
/* */
/* Test for SizeOf */
/* test cases include following SizeOf arguments: */
/* buffer, buffer field; */
/* control method argument, control method local variable; */
/* control method return values; */
/* direct string, string; */
/* package; */
/* buffer, package, and string package elements */
/* */
/* MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,... */
/* calls because it is not legal to perform a SizeOf operation on a Buffer Field. */
/* This test has also been extended to test additional Package element sizes. */
/* */
Device (SIZO)
{
/* SAR0 control method validates SizeOf(Arg) */
/* SAR0 should only be called by SARG */
Method (SAR0, 2, NotSerialized)
{
/* SAR0: SizeOf(Arg) test control method */
/* Local0 Arg0 length */
/* Local1 Local0 object type */
/* Store first string size (Arg0) into Local7 */
Local0 = SizeOf (Arg0)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x21)
}
/* If strings are not of equal size, return error code */
If ((Local0 != Arg1))
{
Return (0x22)
}
Return (0x00)
} /* SAR0: SizeOf(Arg) test control method */
Method (SARG, 0, Serialized)
{
/* SARG: SizeOf(Arg) test control method */
Name (BUFR, Buffer (0x0C){}) /* uninitialized Buffer */
Name (BUF1, Buffer (0x05)
{
0x01, 0x02, 0x03, 0x04, 0x05 // .....
})
Name (PKG0, Package (0x04){}) /* uninitialized Package */
Name (STR0, "String")
Name (PKG1, Package (0x04)
{
BUFR,
"String2",
STR0,
PKG0
}) /* PKG1 */
Name (PKG2, Package (0x04)
{
Buffer (0x0F){},
"String 1",
Package (0x02){}
}) /* PKG2 */
/* Namespace entry buffer reference */
Local0 = SAR0 (BUFR, 0x0C)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x23)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=BUFR) PASS"
/* Namespace entry package reference */
Local0 = SAR0 (PKG0, 0x04)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x24)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=PKG0) PASS"
/* Namespace entry string reference */
Local0 = SAR0 (STR0, 0x06)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x25)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=STR0) PASS"
/* direct string reference */
Local0 = SAR0 ("String", 0x06)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x26)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=String) PASS"
BUF1 [0x02] = 0x55
/****************************************************
//
// This section is commented because it is illegal to
// perform a SizeOf operation on a Buffer Field
//
// Namespace BufferField reference
Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
// save Local0 object type value into Local1
Store (ObjectType (Local0), Local1)
// validate Local0 is a Number
If (LNotEqual (Local1, 1)) // Number type is 1
{ Return (0x27) }
If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
{ Return (Local0) }
Store ("SizeOf(Arg=BufferField) PASS", Debug)
****************************************************/
/* Namespace BufferPackageElement reference */
/* */
Local0 = SAR0 (PKG1 [0x00], 0x0C)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x28)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=PackageBuffer NTE Reference Element) PASS"
/* Namespace StringPackageElement reference */
Local0 = SAR0 (PKG1 [0x01], 0x07)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x29)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=Package String Element) PASS"
/* Namespace StringPackageElement reference */
Local0 = SAR0 (PKG1 [0x02], 0x06)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x2A)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=Package String NTE Reference Element) PASS"
/* Namespace PackagePackageElement reference */
Local0 = SAR0 (PKG1 [0x03], 0x04)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x2B)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=Package Package NTE Reference Element) PASS"
/* Package Buffer Element */
Local0 = SAR0 (PKG2 [0x00], 0x0F)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x2B)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=Package Buffer Element) PASS"
/* Package String Element */
Local0 = SAR0 (PKG2 [0x01], 0x08)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x2B)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=Package String Element) PASS"
/* Package Package Element */
Local0 = SAR0 (PKG2 [0x02], 0x02)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x2B)
}
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
{
Return (Local0)
}
Debug = "SizeOf(Arg=Package Package Element) PASS"
Debug = "SizeOf(Arg) PASS"
Return (0x00)
} /* SARG: SizeOf(Arg) test control method */
Method (SBUF, 0, Serialized)
{
/* SBUF: SizeOf(Buffer) test control method */
Name (BUFR, Buffer (0x0C){})
/* store size of BUFR buffer into Local0 */
Local0 = SizeOf (BUFR)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x31)
}
If ((Local0 != 0x0C)) /* BUFR size is 12 */
{
Return (0x32)
}
Debug = "SizeOf(BUFR) PASS"
Return (0x00)
} /* SBUF: SizeOf(Buffer) test control method */
/****************************************************
//
// This section is commented because it is illegal to
// perform a SizeOf operation on a Buffer Field
//
Method (SIND)
{ // SIND: SizeOf(Index(,,)) test control method
Name (BUFR, Buffer (12) {})
// store size of Index(BUFR,2,) buffer into Local0
Store (SizeOf (Index (BUFR, 2, )), Local0)
// save Local0 object type value into Local1
Store (ObjectType (Local0), Local1)
// validate Local0 is a Number
If (LNotEqual (Local1, 1)) // Number type is 1
{
Return (0x41)
}
If (LNotEqual (Local0, 10)) // 12 - 2 = 10
{
Return (0x42)
}
Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
// TBD: strings and packages
Return (0)
} // SIND: SizeOf(Index(,,)) test control method
****************************************************/
Method (SLOC, 0, Serialized)
{
/* SLOC: SizeOf(Local) test control method */
Name (BUFR, Buffer (0x0C){}) /* uninitialized Buffer */
Name (STR0, "String")
Name (PKG0, Package (0x04){}) /* uninitialized Package */
/* store BUFR Buffer into Local2 */
Local2 = BUFR /* \SIZO.SLOC.BUFR */
/* store size of BUFR buffer into Local0 */
Local0 = SizeOf (Local2)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x51)
}
If ((Local0 != 0x0C)) /* BUFR size is 12 */
{
Return (0x52)
}
Debug = "SizeOf(Local2=Buffer) PASS"
/* store STR0 string into Local2 */
Local2 = STR0 /* \SIZO.SLOC.STR0 */
/* store size of STR0 buffer into Local0 */
Local0 = SizeOf (Local2)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x53)
}
If ((Local0 != 0x06)) /* STR0 size is 6 */
{
Return (0x54)
}
Debug = "SizeOf(Local2=String) PASS"
/* store PKG0 Package into Local2 */
Local2 = PKG0 /* \SIZO.SLOC.PKG0 */
/* store size of PKG0 buffer into Local0 */
Local0 = SizeOf (Local2)
/* save Local0 object type value into Local1 */
Local1 = ObjectType (Local0)
/* validate Local0 is a Number */
If ((Local1 != 0x01)) /* Number type is 1 */
{
Return (0x55)
}
If ((Local0 != 0x04)) /* PKG0 size is 4 */
{
Return (0x56)
}
Debug = "SizeOf(Local2=Package) PASS"
Return (0x00)
} /* SLOC: SizeOf(Local) test control method */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ SizeOf Test"
/* Store current operating system string into Local0 */
Local0 = _OS /* \_OS_ */
Local3 = SizeOf (_OS)
/* save Local3 object type value into Local4 */
Local4 = ObjectType (Local3)
/* validate Local3 is a Number */
If ((Local4 != 0x01)) /* Number type is 1 */
{
/* failure */
Return (0x61)
}
/* Store current operating system string into Local0 */
/* This verifies above SizeOf(_OS) did not corrupt ACPI namespace */
Local0 = _OS /* \_OS_ */
/* Store SARG [Validate SizeOf(Arg)] return value into Local1 */
Local1 = SARG ()
/* save Local1 object type value into Local2 */
Local2 = ObjectType (Local1)
/* validate Local1 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
/* failure */
Return (0x62)
}
/* zero indicates pass, non-zero is an error code */
If ((Local1 != 0x00))
{
/* return SARG error code */
Return (Local1)
}
/* Store SBUF [Validate SizeOf(Buffer)] return value into Local1 */
Local1 = SBUF ()
/* save Local1 object type value into Local2 */
Local2 = ObjectType (Local1)
/* validate Local1 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
/* failure */
Return (0x63)
}
/* zero indicates pass, non-zero is an error code */
If ((Local1 != 0x00))
{
/* return SBUF error code */
Return (Local1)
}
/****************************************************
//
// This section is commented because it is illegal to
// perform a SizeOf operation on a Buffer Field
//
// Store SIND [verify SizeOf(Index(,,))] return value into Local1
Store (SIND, Local1)
// save Local1 object type value into Local2
Store (ObjectType (Local1), Local2)
// validate Local1 is a Number
If (LNotEqual (Local2, 1)) // Number type is 1
{
// failure
Return (0x64)
}
// zero indicates pass, non-zero is an error code
If (LNotEqual (Local1, 0))
{
// return SARG error code
Return (Local1)
}
****************************************************/
/* Store SLOC [verify SizeOf(Local)] return value into Local1 */
Local1 = SLOC ()
/* save Local1 object type value into Local2 */
Local2 = ObjectType (Local1)
/* validate Local1 is a Number */
If ((Local2 != 0x01)) /* Number type is 1 */
{
/* failure */
Return (0x65)
}
/* zero indicates pass, non-zero is an error code */
If ((Local1 != 0x00))
{
/* return SLOC error code */
Return (Local1)
}
/* TBD: SizeOf (METH) -- where METH control method returns */
/* buffer, BufferField, string, package, package element */
Return (0x00)
} /* TEST */
} /* SIZO */
/* */
/* test SmiShare.asl */
/* */
Scope (\_SB) /* System Bus */
{
/* _SB system bus */
/* Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long */
OperationRegion (RAM1, SystemMemory, 0x00400000, 0x0A)
Field (RAM1, AnyAcc, NoLock, Preserve)
{
BI1T, /* Create some bits in memory to access */ 1,
BI2T, 2,
BI3T, 3,
LST2, 2
} /* End Field RAM1 */
Field (RAM1, WordAcc, NoLock, WriteAsZeros)
{
WRD, 16
} /* End 2nd Field RAM1 */
Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
{
BYTE, 8
} /* End 3rd Field RAM1 */
Field (RAM1, ByteAcc, NoLock, Preserve)
{
SMIC, 8,
SMID, 8
}
Device (MBIT)
{
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
BI1T = 0x00
BI2T = 0x03
BI3T = 0x07
LST2 = 0x00
} /* End _INI Method */
} /* End Device MBIT */
Device (MWRD)
{
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
WRD = 0x00
} /* End _INI Method */
} /* End Device MWRD */
Device (MBYT)
{
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
BYTE = 0x00
SMIC = 0x0C
SMID = 0x0D
} /* End _INI Method */
} /* End Device MBYT */
/*
// Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
Field (\RAM1, AnyAcc, NoLock, Preserve)
{
BI1T, 1, // Create some bits in memory to access
BI2T, 2,
BI3T, 3,
LST2, 2
} // End Field RAM1
Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
{
WRD, 16
} // End 2nd Field RAM1
Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
{
BYTE, 8
} // End 3rd Field RAM1
Field (\RAM1, ByteAcc, NoLock, Preserve)
{
SMIC, 8,
SMID, 8
}
*/
Method (SMIX, 0, NotSerialized)
{
Return (BYTE) /* \_SB_.BYTE */
} /* End SMIX */
Method (EVNT, 0, NotSerialized)
{
Local0 = SMIX ()
Notify (\_SB, 0x29) // Reserved
If ((Local0 & 0x01))
{
Notify (\_SB.SMIS, 0x21) // Reserved
}
If ((Local0 & 0x02))
{
Notify (\_SB.SMIS, 0x22) // Reserved
}
If ((Local0 & 0x04))
{
Notify (\_SB.SMIS, 0x24) // Reserved
}
If ((Local0 & 0x08))
{
Notify (\_SB.SMIS, 0x28) // Reserved
}
} /* End Method EVNT */
Method (NTFY, 0, NotSerialized)
{
Notify (\_SB, 0x01) // Device Check
Notify (\_TZ.TZ1, 0x02) // Device Wake
Notify (\_PR.CPU0, 0x03) // Eject Request
Notify (\_SB, 0x81) // Information Change
Notify (\_TZ.TZ1, 0x82) // Thermal Device List Change
Notify (\_PR.CPU0, 0x83) // Guaranteed Change
}
Device (SMIS)
{
Method (BINK, 0, NotSerialized)
{
Local0 = 0x00 /* Zero out Local0 */
If ((SMID != 0x0D))
{
Local0 |= 0x80
}
If ((SMIC != 0x0C))
{
Local0 |= 0x40
}
If ((BYTE != 0x00))
{
Local0 |= 0x20
}
If ((WRD != 0x00))
{
Local0 |= 0x10
}
If ((LST2 != 0x00))
{
Local0 |= 0x08
}
If ((BI3T != 0x07))
{
Local0 |= 0x04
}
If ((BI2T != 0x03))
{
Local0 |= 0x02
}
If ((BI1T != 0x00))
{
Local0 |= 0x01
}
Return (Local0)
} /* End Method BINK */
Method (TEST, 0, NotSerialized)
{
Debug = "++++++++ SmiShare Test"
/* Expect EVNT to generate Notify value we just previously */
/* stored in BYTE */
BYTE = 0x20
EVNT ()
BYTE = 0x21
EVNT ()
BYTE = 0x22
EVNT ()
BYTE = 0x23
EVNT ()
NTFY ()
Return (0x00) /* pass */
} /* End Method TEST */
} /* Device SMIS */
Device (CNDT)
{
Method (TEST, 0, NotSerialized)
{
If (ECOK ())
{
Return ("Broken")
}
Else
{
Return ("Works")
}
}
Method (ECOK, 0, NotSerialized)
{
Return (0x00)
}
}
} /* _SB system bus */
/* Test a very big buffer */
Name (WQAB, Buffer (0x1A64)
{
/* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, // FOMB....
/* 0008 */ 0x54, 0x1A, 0x00, 0x00, 0xBA, 0xAD, 0x00, 0x00, // T.......
/* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, // DS...}.T
/* 0018 */ 0x98, 0xBD, 0x92, 0x00, 0x01, 0x06, 0x18, 0x42, // .......B
/* 0020 */ 0x10, 0x47, 0x10, 0x92, 0x46, 0x62, 0x02, 0x89, // .G..Fb..
/* 0028 */ 0x80, 0x90, 0x18, 0x18, 0x14, 0x81, 0x85, 0x00, // ........
/* 0030 */ 0x49, 0x02, 0x88, 0xC4, 0x41, 0xE1, 0x20, 0xD4, // I...A. .
/* 0038 */ 0x9F, 0x40, 0x7E, 0x05, 0x20, 0x74, 0x28, 0x40, // .@~. t(@
/* 0040 */ 0xA6, 0x00, 0x83, 0x02, 0x9C, 0x22, 0x88, 0xA0, // ....."..
/* 0048 */ 0x57, 0x01, 0x36, 0x05, 0x98, 0x14, 0x60, 0x51, // W.6...`Q
/* 0050 */ 0x80, 0x76, 0x01, 0x96, 0x05, 0xE8, 0x16, 0x20, // .v.....
/* 0058 */ 0x1D, 0x96, 0x88, 0x04, 0x47, 0x89, 0x01, 0x47, // ....G..G
/* 0060 */ 0xE9, 0xC4, 0x16, 0x6E, 0xD8, 0xE0, 0x85, 0xA2, // ...n....
/* 0068 */ 0x68, 0x06, 0x51, 0x12, 0x94, 0x8B, 0x20, 0x5D, // h.Q... ]
/* 0070 */ 0x10, 0x52, 0x2E, 0xC0, 0x37, 0x82, 0x06, 0x10, // .R..7...
/* 0078 */ 0xA5, 0x77, 0x01, 0xB6, 0x05, 0x98, 0x86, 0x27, // .w.....'
/* 0080 */ 0xD2, 0x20, 0xE4, 0x60, 0x08, 0x54, 0xCE, 0x80, // . .`.T..
/* 0088 */ 0x20, 0x69, 0x44, 0x21, 0x1E, 0xA7, 0x44, 0x08, // iD!..D.
/* 0090 */ 0x0A, 0x84, 0x90, 0xD4, 0xF1, 0xA0, 0xA0, 0x71, // .......q
/* 0098 */ 0x88, 0xAD, 0xCE, 0x46, 0x93, 0xA9, 0x74, 0x7E, // ...F..t~
/* 00A0 */ 0x48, 0x82, 0x70, 0xC6, 0x2A, 0x7E, 0x3A, 0x9A, // H.p.*~:.
/* 00A8 */ 0xD0, 0xD9, 0x9C, 0x60, 0xE7, 0x18, 0x72, 0x3C, // ...`..r<
/* 00B0 */ 0x48, 0xF4, 0x20, 0xB8, 0x00, 0x0F, 0x1C, 0x2C, // H. ....,
/* 00B8 */ 0x34, 0x84, 0x22, 0x6B, 0x80, 0xC1, 0x8C, 0xDD, // 4."k....
/* 00C0 */ 0x63, 0xB1, 0x0B, 0x4E, 0x0A, 0xEC, 0x61, 0xB3, // c..N..a.
/* 00C8 */ 0x01, 0x19, 0xA2, 0x24, 0x38, 0xD4, 0x11, 0xC0, // ...$8...
/* 00D0 */ 0x12, 0x05, 0x98, 0x1F, 0x87, 0x0C, 0x0F, 0x95, // ........
/* 00D8 */ 0x8C, 0x25, 0x24, 0x1B, 0xAB, 0x87, 0xC2, 0xA5, // .%$.....
/* 00E0 */ 0x40, 0x68, 0x6C, 0x27, 0xED, 0x19, 0x45, 0x2C, // @hl'..E,
/* 00E8 */ 0x79, 0x4A, 0x82, 0x49, 0xE0, 0x51, 0x44, 0x36, // yJ.I.QD6
/* 00F0 */ 0x1A, 0x27, 0x28, 0x1B, 0x1A, 0x25, 0x03, 0x42, // .'(..%.B
/* 00F8 */ 0x9E, 0x05, 0x58, 0x07, 0x26, 0x04, 0x76, 0x2F, // ..X.&.v/
/* 0100 */ 0xC0, 0x9A, 0x00, 0x73, 0xB3, 0x90, 0xB1, 0xB9, // ...s....
/* 0108 */ 0xE8, 0xFF, 0x0F, 0x71, 0xB0, 0x31, 0xDA, 0x9A, // ...q.1..
/* 0110 */ 0xAE, 0x90, 0xC2, 0xC4, 0x88, 0x12, 0x2C, 0x5E, // ......,^
/* 0118 */ 0xC5, 0xC3, 0x10, 0xCA, 0x93, 0x42, 0xA8, 0x48, // .....B.H
/* 0120 */ 0x95, 0xA1, 0x68, 0xB4, 0x51, 0x2A, 0x14, 0xE0, // ..h.Q*..
/* 0128 */ 0x4C, 0x80, 0x30, 0x5C, 0x1D, 0x03, 0x82, 0x46, // L.0\...F
/* 0130 */ 0x88, 0x15, 0x29, 0x56, 0xFB, 0x83, 0x20, 0xF1, // ..)V.. .
/* 0138 */ 0x2D, 0x40, 0x54, 0x01, 0xA2, 0x48, 0xA3, 0x41, // -@T..H.A
/* 0140 */ 0x9D, 0x03, 0x3C, 0x5C, 0x0F, 0xF5, 0xF0, 0x3D, // ..<\...=
/* 0148 */ 0xF6, 0x93, 0x0C, 0x72, 0x90, 0x67, 0xF1, 0xA8, // ...r.g..
/* 0150 */ 0x70, 0x9C, 0x06, 0x49, 0xE0, 0x0B, 0x80, 0x4F, // p..I...O
/* 0158 */ 0x08, 0x1E, 0x38, 0xDE, 0x35, 0xA0, 0x66, 0x7C, // ..8.5.f|
/* 0160 */ 0xBC, 0x4C, 0x10, 0x1C, 0x6A, 0x88, 0x1E, 0x68, // .L..j..h
/* 0168 */ 0xB8, 0x13, 0x38, 0x44, 0x06, 0xE8, 0x49, 0x3D, // ..8D..I=
/* 0170 */ 0x52, 0x60, 0x07, 0x77, 0x32, 0xEF, 0x01, 0xAF, // R`.w2...
/* 0178 */ 0x0A, 0xCD, 0x5E, 0x12, 0x08, 0xC1, 0xF1, 0xF8, // ..^.....
/* 0180 */ 0x7E, 0xC0, 0x26, 0x9C, 0xC0, 0xF2, 0x07, 0x81, // ~.&.....
/* 0188 */ 0x1A, 0x99, 0xA1, 0x3D, 0xCA, 0xD3, 0x8A, 0x19, // ...=....
/* 0190 */ 0xF2, 0x31, 0xC1, 0x04, 0x16, 0x0B, 0x21, 0x05, // .1....!.
/* 0198 */ 0x10, 0x1A, 0x0F, 0xF8, 0x6F, 0x00, 0x8F, 0x17, // ....o...
/* 01A0 */ 0xBE, 0x12, 0xC4, 0xF6, 0x80, 0x12, 0x0C, 0x0B, // ........
/* 01A8 */ 0x21, 0x23, 0xAB, 0xF0, 0x78, 0xE8, 0x28, 0x7C, // !#..x.(|
/* 01B0 */ 0x95, 0x38, 0x9C, 0xD3, 0x8A, 0x67, 0x82, 0xE1, // .8...g..
/* 01B8 */ 0x20, 0xF4, 0x05, 0x90, 0x00, 0x51, 0xE7, 0x0C, // ....Q..
/* 01C0 */ 0xD4, 0x61, 0xC1, 0xE7, 0x04, 0x76, 0x33, 0x38, // .a...v38
/* 01C8 */ 0x83, 0x47, 0x00, 0x8F, 0xE4, 0x84, 0xFC, 0x2B, // .G.....+
/* 01D0 */ 0xF1, 0xC0, 0xE0, 0x03, 0xE2, 0xEF, 0x1F, 0xA7, // ........
/* 01D8 */ 0xEC, 0x11, 0x9C, 0xA9, 0x01, 0x7D, 0x1C, 0xF0, // .....}..
/* 01E0 */ 0xFF, 0x7F, 0x28, 0x7C, 0x88, 0x1E, 0xDF, 0x29, // ..(|...)
/* 01E8 */ 0x1F, 0xAF, 0x4F, 0x17, 0x96, 0x35, 0x4E, 0xE8, // ..O..5N.
/* 01F0 */ 0x77, 0x08, 0x9F, 0x38, 0x7C, 0x64, 0x71, 0x44, // w..8|dqD
/* 01F8 */ 0x08, 0x39, 0x39, 0x05, 0xA0, 0x81, 0x4F, 0xF7, // .99...O.
/* 0200 */ 0xEC, 0x22, 0x9C, 0xAE, 0x27, 0xE5, 0x40, 0xC3, // ."..'.@.
/* 0208 */ 0xA0, 0xE3, 0x04, 0xC7, 0x79, 0x00, 0x1C, 0xE3, // ....y...
/* 0210 */ 0x84, 0x7F, 0x2E, 0x80, 0x3F, 0x40, 0x7E, 0xCA, // ....?@~.
/* 0218 */ 0x78, 0xC5, 0x48, 0xE0, 0x98, 0x23, 0x44, 0x9F, // x.H..#D.
/* 0220 */ 0x6B, 0x3C, 0x42, 0x2C, 0xFC, 0x53, 0x45, 0xE1, // k<B,.SE.
/* 0228 */ 0x03, 0x21, 0x63, 0x04, 0x17, 0xA0, 0xC7, 0x08, // .!c.....
/* 0230 */ 0x7C, 0x03, 0x8E, 0x11, 0x7D, 0x94, 0xE0, 0xEA, // |...}...
/* 0238 */ 0x0F, 0x1A, 0x74, 0x80, 0xB8, 0xFF, 0xFF, 0x00, // ..t.....
/* 0240 */ 0xE1, 0x83, 0x7A, 0x80, 0xC0, 0x37, 0xFA, 0xD1, // ..z..7..
/* 0248 */ 0x03, 0x3D, 0x2E, 0x8B, 0x3E, 0x0F, 0xC8, 0xF8, // .=..>...
/* 0250 */ 0x89, 0x46, 0xF3, 0xE2, 0xA7, 0x03, 0x7E, 0xF8, // .F....~.
/* 0258 */ 0x00, 0x0F, 0xA8, 0x87, 0x84, 0x03, 0xC5, 0x4C, // .......L
/* 0260 */ 0x9B, 0x83, 0x3E, 0xBB, 0x1C, 0x3A, 0x76, 0xB8, // ..>..:v.
/* 0268 */ 0xE0, 0x3F, 0x81, 0x80, 0x4B, 0xDE, 0x21, 0x0C, // .?..K.!.
/* 0270 */ 0x14, 0x23, 0xC6, 0x9F, 0x83, 0x7C, 0x0A, 0x03, // .#...|..
/* 0278 */ 0xFF, 0xFF, 0xFF, 0x14, 0x06, 0xFE, 0xE1, 0xF0, // ........
/* 0280 */ 0x20, 0x4F, 0x07, 0x9F, 0xB6, 0xA8, 0x74, 0x18, // O....t.
/* 0288 */ 0xD4, 0x81, 0x0B, 0xB0, 0x32, 0x89, 0x08, 0xCF, // ....2...
/* 0290 */ 0x12, 0xB5, 0x41, 0xE8, 0xD4, 0xF0, 0x36, 0xF1, // ..A...6.
/* 0298 */ 0xB6, 0xE5, 0x5B, 0x40, 0x9C, 0xD3, 0xEC, 0xED, // ..[@....
/* 02A0 */ 0xC0, 0x45, 0x30, 0x22, 0xD4, 0x0C, 0x45, 0x4E, // .E0"..EN
/* 02A8 */ 0x5A, 0x11, 0x63, 0x44, 0x79, 0xDC, 0x32, 0xCA, // Z.cDy.2.
/* 02B0 */ 0xDB, 0xD6, 0x0B, 0x40, 0xBC, 0x13, 0x7B, 0xDE, // ...@..{.
/* 02B8 */ 0x32, 0x46, 0xF0, 0xC8, 0x0F, 0x5C, 0x2C, 0xC6, // 2F...\,.
/* 02C0 */ 0xEA, 0xF5, 0x5F, 0xF3, 0x81, 0x0B, 0x70, 0xF6, // .._...p.
/* 02C8 */ 0xFF, 0x3F, 0x70, 0x01, 0x1C, 0x0A, 0x7A, 0x18, // .?p...z.
/* 02D0 */ 0x42, 0x0F, 0xC3, 0x53, 0x39, 0x97, 0x87, 0xC8, // B..S9...
/* 02D8 */ 0x53, 0x89, 0x18, 0x35, 0x4C, 0xD4, 0x67, 0x28, // S..5L.g(
/* 02E0 */ 0xDF, 0x2D, 0x7C, 0x20, 0x02, 0xDF, 0x99, 0x0B, // .-| ....
/* 02E8 */ 0xF8, 0xFD, 0xFF, 0x0F, 0x44, 0x70, 0x8E, 0x29, // ....Dp.)
/* 02F0 */ 0xB8, 0x33, 0x0D, 0x78, 0x7C, 0xCE, 0x40, 0x20, // .3.x|.@
/* 02F8 */ 0xA7, 0xE2, 0x43, 0x0D, 0x60, 0x41, 0xF4, 0x13, // ..C.`A..
/* 0300 */ 0xC2, 0x27, 0x1A, 0x2A, 0x13, 0x06, 0x75, 0xA8, // .'.*..u.
/* 0308 */ 0x01, 0xAC, 0x5C, 0x61, 0x9E, 0x46, 0xCF, 0xF9, // ..\a.F..
/* 0310 */ 0x59, 0xC6, 0xA7, 0x1A, 0x1F, 0x4A, 0x8D, 0x63, // Y....J.c
/* 0318 */ 0x88, 0x97, 0x99, 0x87, 0x1A, 0x1F, 0x0B, 0x5E, // .......^
/* 0320 */ 0x49, 0x7D, 0xA8, 0x31, 0x54, 0x9C, 0x87, 0x1A, // I}.1T...
/* 0328 */ 0x0F, 0x37, 0x50, 0xD4, 0x37, 0x9B, 0x67, 0x1B, // .7P.7.g.
/* 0330 */ 0xA3, 0xC7, 0xF7, 0x0D, 0xD5, 0x10, 0x0F, 0x35, // .......5
/* 0338 */ 0x4C, 0xF2, 0x4A, 0x35, 0x16, 0x1F, 0x6A, 0xC0, // L.J5..j.
/* 0340 */ 0xF1, 0xFF, 0x3F, 0xD4, 0x00, 0xFC, 0xFF, 0xFF, // ..?.....
/* 0348 */ 0x1F, 0x6A, 0x00, 0x47, 0x47, 0x03, 0x38, 0x47, // .j.GG.8G
/* 0350 */ 0x46, 0xDC, 0xD1, 0x00, 0x5C, 0x87, 0x52, 0xE0, // F...\.R.
/* 0358 */ 0x70, 0x34, 0x00, 0x1E, 0x47, 0x21, 0x30, 0x5F, // p4..G!0_
/* 0360 */ 0x68, 0x7C, 0x14, 0x02, 0x16, 0xFF, 0xFF, 0xA3, // h|......
/* 0368 */ 0x10, 0xF8, 0x65, 0x9F, 0x83, 0x50, 0x42, 0x8F, // ..e..PB.
/* 0370 */ 0x42, 0x80, 0xA0, 0xDB, 0xCF, 0x53, 0xC4, 0xB3, // B....S..
/* 0378 */ 0x8F, 0x2F, 0x3F, 0x0F, 0x04, 0x11, 0x5E, 0xF3, // ./?...^.
/* 0380 */ 0x7D, 0x0A, 0xF2, 0x21, 0xDF, 0x47, 0x21, 0x06, // }..!.G!.
/* 0388 */ 0x63, 0x28, 0x5F, 0x83, 0x7C, 0x14, 0x62, 0x50, // c(_.|.bP
/* 0390 */ 0xAF, 0x41, 0xBE, 0xEF, 0x1B, 0xE4, 0xF1, 0x22, // .A....."
/* 0398 */ 0x48, 0xEC, 0x67, 0x02, 0x1F, 0x85, 0x98, 0xE8, // H.g.....
/* 03A0 */ 0xA3, 0x10, 0xA0, 0xF0, 0xFF, 0x7F, 0x14, 0x02, // ........
/* 03A8 */ 0xF8, 0xFF, 0xFF, 0x3F, 0x0A, 0x01, 0xCE, 0x02, // ...?....
/* 03B0 */ 0x1C, 0x0D, 0x40, 0x37, 0xAD, 0x47, 0x21, 0xF0, // ..@7.G!.
/* 03B8 */ 0xDE, 0x59, 0x4E, 0xFB, 0x04, 0x7C, 0x16, 0x02, // .YN..|..
/* 03C0 */ 0xCC, 0xFE, 0xFF, 0xCF, 0x42, 0xC0, 0xEC, 0x28, // ....B..(
/* 03C8 */ 0x74, 0x14, 0x67, 0xF9, 0x2A, 0xF4, 0x04, 0xF0, // t.g.*...
/* 03D0 */ 0x02, 0x10, 0x23, 0xCC, 0x3B, 0xD0, 0x4B, 0x26, // ..#.;.K&
/* 03D8 */ 0xBB, 0x8B, 0x1B, 0xE7, 0xC9, 0xE5, 0x2C, 0x9E, // ......,.
/* 03E0 */ 0xC4, 0x7D, 0x09, 0xF2, 0x81, 0xE2, 0x59, 0xC8, // .}....Y.
/* 03E8 */ 0x50, 0xA7, 0x1B, 0xF4, 0x8D, 0xDC, 0x03, 0x8B, // P.......
/* 03F0 */ 0x19, 0x3F, 0xC4, 0xF3, 0x90, 0x21, 0x9E, 0x85, // .?...!..
/* 03F8 */ 0x00, 0x76, 0xFD, 0xFF, 0xCF, 0x42, 0x00, 0xFF, // .v...B..
/* 0400 */ 0xFF, 0xFF, 0x47, 0x03, 0xF8, 0x2F, 0x00, 0x9F, // ..G../..
/* 0408 */ 0x85, 0x80, 0xE7, 0x09, 0xE0, 0x41, 0xDB, 0x67, // .....A.g
/* 0410 */ 0x21, 0x80, 0x33, 0x87, 0xCB, 0xF3, 0x7F, 0x05, // !.3.....
/* 0418 */ 0x3A, 0x96, 0xF7, 0x08, 0xCF, 0xFA, 0x24, 0x5F, // :.....$_
/* 0420 */ 0x2F, 0x3D, 0xD3, 0x87, 0x82, 0x67, 0x21, 0x86, // /=...g!.
/* 0428 */ 0x75, 0x18, 0x3E, 0x0B, 0x31, 0x88, 0x17, 0x4D, // u.>.1..M
/* 0430 */ 0x43, 0xBC, 0x70, 0xFA, 0x30, 0xE0, 0xFF, 0x3F, // C.p.0..?
/* 0438 */ 0x5E, 0xE0, 0x57, 0x4E, 0x03, 0x05, 0x09, 0xF4, // ^.WN....
/* 0440 */ 0x2C, 0x04, 0x30, 0xFE, 0xFF, 0x7F, 0x16, 0x02, // ,.0.....
/* 0448 */ 0xC8, 0xB8, 0x46, 0x9D, 0x85, 0x80, 0xE5, 0x6D, // ..F....m
/* 0450 */ 0xE5, 0x19, 0xDB, 0xA7, 0x95, 0x04, 0xFF, 0xFF, // ........
/* 0458 */ 0x67, 0x21, 0xC0, 0x41, 0x2E, 0x23, 0x07, 0x21, // g!.A.#.!
/* 0460 */ 0x4C, 0xC4, 0x87, 0x83, 0x8F, 0x99, 0x80, 0x9E, // L.......
/* 0468 */ 0x29, 0xBE, 0xB8, 0x1B, 0xE3, 0x09, 0xE0, 0x45, // )......E
/* 0470 */ 0xE2, 0x31, 0x93, 0x1D, 0x35, 0x0D, 0xF3, 0x2C, // .1..5..,
/* 0478 */ 0x64, 0xBC, 0xB3, 0x78, 0x0D, 0x78, 0x82, 0xF7, // d..x.x..
/* 0480 */ 0xE4, 0x9F, 0x85, 0x18, 0xD8, 0x61, 0x05, 0x7B, // .....a.{
/* 0488 */ 0x14, 0x32, 0xA8, 0xC1, 0x63, 0x87, 0x08, 0x13, // .2..c...
/* 0490 */ 0xE8, 0x59, 0x88, 0xC5, 0x7D, 0xAE, 0xE8, 0x3C, // .Y..}..<
/* 0498 */ 0xE1, 0xB3, 0x10, 0xF0, 0xFE, 0xFF, 0x9F, 0x25, // .......%
/* 04A0 */ 0xE0, 0x5E, 0x0D, 0x9E, 0x85, 0x00, 0x13, 0x87, // .^......
/* 04A8 */ 0x0D, 0x9F, 0x35, 0xC0, 0x33, 0x7C, 0x8F, 0xEA, // ..5.3|..
/* 04B0 */ 0x1C, 0x1E, 0x8F, 0x81, 0x7F, 0x56, 0x1D, 0xE7, // .....V..
/* 04B8 */ 0x04, 0x96, 0x7B, 0xD1, 0xB2, 0x71, 0xA0, 0xA1, // ..{..q..
/* 04C0 */ 0x23, 0xB2, 0x3A, 0x20, 0x8D, 0x0D, 0x73, 0x29, // #.: ..s)
/* 04C8 */ 0x89, 0x7C, 0x72, 0x6C, 0xD4, 0x56, 0x04, 0xA7, // .|rl.V..
/* 04D0 */ 0x33, 0x93, 0x4F, 0x00, 0xD6, 0x42, 0x21, 0x05, // 3.O..B!.
/* 04D8 */ 0x34, 0x1A, 0x8B, 0xE1, 0x9D, 0xF9, 0xE8, 0x44, // 4......D
/* 04E0 */ 0x41, 0x0C, 0xE8, 0xE3, 0x90, 0x6D, 0x1C, 0x0A, // A....m..
/* 04E8 */ 0x50, 0x7B, 0xD1, 0x14, 0xC8, 0x39, 0x07, 0xA3, // P{...9..
/* 04F0 */ 0x7F, 0x76, 0x74, 0x36, 0xBE, 0x13, 0x70, 0x0D, // .vt6..p.
/* 04F8 */ 0x10, 0x3A, 0x25, 0x18, 0xDA, 0x6A, 0x04, 0xFC, // .:%..j..
/* 0500 */ 0xFF, 0x67, 0x89, 0x01, 0x33, 0xFE, 0x53, 0x8C, // .g..3.S.
/* 0508 */ 0x09, 0x7C, 0x8E, 0xC1, 0x1F, 0x0C, 0xF0, 0x03, // .|......
/* 0510 */ 0x7F, 0x31, 0xA8, 0xFA, 0x5E, 0xA0, 0xFB, 0x82, // .1..^...
/* 0518 */ 0xD5, 0xDD, 0x64, 0x20, 0xCC, 0xC8, 0x04, 0xF5, // ..d ....
/* 0520 */ 0x9D, 0x0E, 0x40, 0x01, 0xE4, 0x0B, 0x81, 0xCF, // ..@.....
/* 0528 */ 0x51, 0x0F, 0x05, 0x6C, 0x22, 0x21, 0xC2, 0x44, // Q..l"!.D
/* 0530 */ 0x33, 0x3A, 0x62, 0xC2, 0xA8, 0xE8, 0x13, 0xA6, // 3:b.....
/* 0538 */ 0x20, 0x9E, 0xB0, 0x63, 0x4D, 0x18, 0x3D, 0x13, // ..cM.=.
/* 0540 */ 0x5F, 0x74, 0xD8, 0x88, 0x31, 0x21, 0xAE, 0x1E, // _t..1!..
/* 0548 */ 0xD0, 0x26, 0x18, 0xD4, 0x97, 0x22, 0x58, 0x43, // .&..."XC
/* 0550 */ 0xE6, 0x63, 0xF1, 0x05, 0x02, 0x37, 0x65, 0x30, // .c...7e0
/* 0558 */ 0xCE, 0x89, 0x5D, 0x13, 0x7C, 0xD9, 0xC1, 0xCD, // ..].|...
/* 0560 */ 0x19, 0x8C, 0xF0, 0x98, 0xBB, 0x18, 0xBF, 0x3A, // .......:
/* 0568 */ 0x79, 0x74, 0xFC, 0xA0, 0xE0, 0x1B, 0x0E, 0xC3, // yt......
/* 0570 */ 0x7E, 0x32, 0xF3, 0x8C, 0xDE, 0xCB, 0x7C, 0x8D, // ~2....|.
/* 0578 */ 0xC3, 0xC0, 0x7A, 0xBC, 0x1C, 0xD6, 0x68, 0x61, // ..z...ha
/* 0580 */ 0x0F, 0xED, 0x3D, 0xC4, 0xFF, 0xFF, 0x43, 0x8C, // ..=...C.
/* 0588 */ 0xCF, 0x13, 0xC6, 0x08, 0xEB, 0xDB, 0x0B, 0x38, // .......8
/* 0590 */ 0xEE, 0x59, 0xF0, 0xEF, 0x1A, 0xE0, 0xB9, 0x84, // .Y......
/* 0598 */ 0xF8, 0xAE, 0x01, 0x30, 0xF0, 0xFF, 0x7F, 0xD7, // ...0....
/* 05A0 */ 0x00, 0x4E, 0xD7, 0x04, 0xDF, 0x35, 0x80, 0xF7, // .N...5..
/* 05A8 */ 0xD0, 0x7D, 0xD7, 0x00, 0xAE, 0xD9, 0xEF, 0x1A, // .}......
/* 05B0 */ 0xA8, 0x63, 0x80, 0x15, 0xDE, 0x35, 0xA0, 0x5D, // .c...5.]
/* 05B8 */ 0xD9, 0xDE, 0xD7, 0x9E, 0xB0, 0xAC, 0xE9, 0xB2, // ........
/* 05C0 */ 0x81, 0x52, 0x73, 0xD9, 0x00, 0x14, 0xFC, 0xFF, // .Rs.....
/* 05C8 */ 0x2F, 0x1B, 0x80, 0x01, 0x29, 0x13, 0x46, 0x85, // /...).F.
/* 05D0 */ 0x9F, 0x30, 0x05, 0xF1, 0x84, 0x1D, 0xEC, 0xB2, // .0......
/* 05D8 */ 0x01, 0x8A, 0x18, 0x97, 0x0D, 0xD0, 0x8F, 0xED, // ........
/* 05E0 */ 0x65, 0x03, 0x18, 0xDC, 0x13, 0xF8, 0x6D, 0x03, // e.....m.
/* 05E8 */ 0x78, 0x43, 0xFA, 0xB6, 0x01, 0xD6, 0xFF, 0xFF, // xC......
/* 05F0 */ 0x6D, 0x03, 0xAC, 0xF9, 0x6F, 0x1B, 0x28, 0x0E, // m...o.(.
/* 05F8 */ 0xAB, 0xBC, 0x6D, 0x40, 0x3C, 0xC9, 0x33, 0x02, // ..m@<.3.
/* 0600 */ 0xAB, 0xBA, 0x6E, 0xA0, 0xF4, 0x5C, 0x37, 0x00, // ..n..\7.
/* 0608 */ 0x12, 0x88, 0x99, 0x30, 0x2A, 0xFE, 0x84, 0x29, // ...0*..)
/* 0610 */ 0x88, 0x27, 0xEC, 0x68, 0xD7, 0x0D, 0x50, 0x04, // .'.h..P.
/* 0618 */ 0xB9, 0x6E, 0x80, 0x7E, 0x5E, 0x09, 0xFE, 0xFF, // .n.~^...
/* 0620 */ 0xAF, 0x1B, 0xC0, 0xE0, 0xA2, 0x80, 0xB9, 0x6F, // .......o
/* 0628 */ 0x00, 0x6F, 0x58, 0x7E, 0xDF, 0x00, 0x7C, 0xDC, // .oX~..|.
/* 0630 */ 0xC4, 0x31, 0xF7, 0x0D, 0xC0, 0xCC, 0xFF, 0xFF, // .1......
/* 0638 */ 0xBE, 0x01, 0xB0, 0xE7, 0xA2, 0x80, 0xBB, 0x6F, // .......o
/* 0640 */ 0x00, 0xEF, 0x8B, 0xB4, 0xEF, 0x1B, 0x60, 0xFE, // ......`.
/* 0648 */ 0xFF, 0xDF, 0x37, 0xC0, 0x28, 0x6D, 0xFD, 0x1E, // ..7.(m..
/* 0650 */ 0x1C, 0x3D, 0x21, 0x78, 0x7C, 0xB8, 0xFB, 0xA5, // .=!x|...
/* 0658 */ 0xC7, 0xE7, 0xBB, 0x39, 0x38, 0x06, 0x79, 0x8C, // ...98.y.
/* 0660 */ 0x87, 0x76, 0xC0, 0xAF, 0xEF, 0x9E, 0x98, 0xEF, // .v......
/* 0668 */ 0xE6, 0xC0, 0xFF, 0x4C, 0x70, 0x3C, 0x18, 0x68, // ...Lp<.h
/* 0670 */ 0x1C, 0x62, 0xAB, 0x97, 0x06, 0x72, 0x34, 0x38, // .b...r48
/* 0678 */ 0x3F, 0xDC, 0x19, 0x81, 0x61, 0x15, 0x7F, 0xF2, // ?...a...
/* 0680 */ 0x47, 0x38, 0xC7, 0xD0, 0xD9, 0xE1, 0x20, 0xB1, // G8.... .
/* 0688 */ 0x83, 0xE0, 0xC1, 0x56, 0x6D, 0x02, 0x85, 0x86, // ...Vm...
/* 0690 */ 0x50, 0x14, 0x18, 0x14, 0x8B, 0x0F, 0x18, 0xF8, // P.......
/* 0698 */ 0x61, 0xB3, 0xB3, 0x00, 0x93, 0x04, 0x87, 0x3A, // a......:
/* 06A0 */ 0x02, 0xF8, 0x3E, 0xD1, 0xFC, 0x38, 0x74, 0x37, // ..>..8t7
/* 06A8 */ 0x38, 0x54, 0x8F, 0xE5, 0xA1, 0x80, 0x9E, 0x01, // 8T......
/* 06B0 */ 0x71, 0xC7, 0x0C, 0x32, 0x69, 0xCF, 0x28, 0xE2, // q..2i.(.
/* 06B8 */ 0x53, 0xC2, 0x29, 0x85, 0x49, 0xE0, 0xF3, 0x03, // S.).I...
/* 06C0 */ 0x43, 0xE3, 0x04, 0xAF, 0x0D, 0xA1, 0xF9, 0xFF, // C.......
/* 06C8 */ 0xFF, 0xA4, 0xC0, 0x3C, 0xDF, 0x31, 0x04, 0x6C, // ...<.1.l
/* 06D0 */ 0x02, 0xBB, 0xBF, 0x64, 0xC8, 0xDA, 0xC0, 0x75, // ...d...u
/* 06D8 */ 0x4B, 0x32, 0x44, 0x6F, 0x38, 0xB2, 0x85, 0xA2, // K2Do8...
/* 06E0 */ 0xE9, 0x44, 0x79, 0xDF, 0x88, 0x62, 0x67, 0x08, // .Dy..bg.
/* 06E8 */ 0xC2, 0x88, 0x12, 0x2C, 0xC8, 0xA3, 0x42, 0xAC, // ...,..B.
/* 06F0 */ 0x28, 0x2F, 0x05, 0x46, 0x88, 0x18, 0xE2, 0x95, // (/.F....
/* 06F8 */ 0x23, 0xD0, 0x09, 0x87, 0x0F, 0xF2, 0xD8, 0x14, // #.......
/* 0700 */ 0xA7, 0xFD, 0x41, 0x90, 0x58, 0x4F, 0x02, 0x8D, // ..A.XO..
/* 0708 */ 0xC5, 0x91, 0x46, 0x83, 0x3A, 0x07, 0x78, 0xB8, // ..F.:.x.
/* 0710 */ 0x3E, 0xC4, 0x78, 0xF8, 0x0F, 0x21, 0x06, 0x39, // >.x..!.9
/* 0718 */ 0xC8, 0x73, 0x7B, 0x54, 0x38, 0x4E, 0x5F, 0x25, // .s{T8N_%
/* 0720 */ 0x4C, 0xF0, 0x02, 0xE0, 0x83, 0x0A, 0x1C, 0xD7, // L.......
/* 0728 */ 0x80, 0x9A, 0xF1, 0x33, 0x06, 0x58, 0x8E, 0xE3, // ...3.X..
/* 0730 */ 0x3E, 0xA9, 0xC0, 0x1D, 0x8F, 0xEF, 0x07, 0x6C, // >......l
/* 0738 */ 0xC2, 0x09, 0x2C, 0x7F, 0x10, 0xA8, 0xE3, 0x0C, // ..,.....
/* 0740 */ 0x9F, 0xE7, 0x0B, 0x8B, 0x21, 0x1F, 0x13, 0x4C, // ....!..L
/* 0748 */ 0x60, 0xB1, 0x27, 0x1B, 0x3A, 0x1E, 0xF0, 0xDF, // `.'.:...
/* 0750 */ 0x63, 0x1E, 0x2F, 0x7C, 0x32, 0xF1, 0x7C, 0x4D, // c./|2.|M
/* 0758 */ 0x30, 0x22, 0x84, 0x9C, 0x8C, 0x07, 0x7D, 0x87, // 0"....}.
/* 0760 */ 0xC0, 0x5C, 0x6F, 0xD8, 0xB9, 0x85, 0x8B, 0x3A, // .\o....:
/* 0768 */ 0x68, 0xA0, 0x4E, 0x0B, 0x3E, 0x28, 0xB0, 0x9B, // h.N.>(..
/* 0770 */ 0x11, 0xE6, 0xB8, 0xCE, 0xCF, 0x2A, 0x60, 0xF8, // .....*`.
/* 0778 */ 0xFF, 0x9F, 0x55, 0x60, 0x8F, 0x10, 0xFE, 0xED, // ..U`....
/* 0780 */ 0xC1, 0xF3, 0xF2, 0x95, 0xE1, 0xD5, 0x21, 0x81, // ......!.
/* 0788 */ 0x43, 0x8E, 0x10, 0x3D, 0x2E, 0x8F, 0x10, 0x73, // C..=...s
/* 0790 */ 0x3E, 0xC2, 0x0C, 0x11, 0x5C, 0x67, 0x01, 0x70, // >...\g.p
/* 0798 */ 0x0C, 0x11, 0xF8, 0x1C, 0x70, 0xC0, 0x71, 0x69, // ....p.qi
/* 07A0 */ 0xE2, 0x03, 0xF5, 0x01, 0x07, 0x70, 0x70, 0x4D, // .....ppM
/* 07A8 */ 0xC3, 0x1D, 0x70, 0xC0, 0x71, 0x16, 0x60, 0xFF, // ..p.q.`.
/* 07B0 */ 0xFF, 0xC3, 0x0D, 0x2C, 0x49, 0x26, 0x0E, 0x23, // ...,I&.#
/* 07B8 */ 0x18, 0x11, 0x30, 0x28, 0x02, 0x02, 0xA4, 0xB3, // ..0(....
/* 07C0 */ 0x80, 0x0F, 0x29, 0x00, 0x1F, 0xAE, 0x0C, 0x0F, // ..).....
/* 07C8 */ 0x29, 0xD8, 0x93, 0x86, 0x07, 0x8E, 0x1B, 0x85, // ).......
/* 07D0 */ 0x07, 0x8D, 0x0B, 0x30, 0x68, 0x7A, 0xE2, 0x80, // ...0hz..
/* 07D8 */ 0x7F, 0x4C, 0xF0, 0x19, 0x05, 0x1C, 0xE3, 0x06, // .L......
/* 07E0 */ 0xDF, 0x2A, 0x0C, 0xFC, 0xFF, 0x3F, 0x30, 0xCC, // .*...?0.
/* 07E8 */ 0xE1, 0xC2, 0x63, 0x39, 0x8A, 0xA0, 0x07, 0x1E, // ..c9....
/* 07F0 */ 0xD4, 0xF7, 0x8C, 0x33, 0xF7, 0x24, 0x8F, 0xD1, // ...3.$..
/* 07F8 */ 0x51, 0x0F, 0x27, 0xF4, 0xE4, 0x85, 0x3B, 0x57, // Q.'...;W
/* 0800 */ 0xF9, 0x0A, 0x71, 0x14, 0x18, 0xB8, 0x77, 0x29, // ..q...w)
/* 0808 */ 0x8F, 0xCF, 0x17, 0x2B, 0xC3, 0x63, 0x46, 0xFB, // ...+.cF.
/* 0810 */ 0x1E, 0x72, 0xD6, 0x11, 0x02, 0xE2, 0x2F, 0x75, // .r..../u
/* 0818 */ 0x6C, 0xC0, 0x60, 0x39, 0x18, 0x00, 0x87, 0x01, // l.`9....
/* 0820 */ 0xE3, 0x13, 0x0D, 0x58, 0x67, 0x1B, 0x3C, 0xF4, // ...Xg.<.
/* 0828 */ 0x69, 0x31, 0xC4, 0xE3, 0x0B, 0xFB, 0x56, 0x61, // i1....Va
/* 0830 */ 0x82, 0xEA, 0x41, 0x75, 0x12, 0xF4, 0xD0, 0xC0, // ..Au....
/* 0838 */ 0x01, 0xE8, 0xA1, 0xC1, 0x3F, 0xB9, 0x90, 0xFB, // ....?...
/* 0840 */ 0x2B, 0x1D, 0x82, 0xB5, 0xE2, 0x69, 0xDE, 0x47, // +....i.G
/* 0848 */ 0x1E, 0xF3, 0xDC, 0xA2, 0xBC, 0x0D, 0x3C, 0x07, // ......<.
/* 0850 */ 0xF0, 0xD3, 0x82, 0x87, 0xE3, 0x63, 0x81, 0xC7, // .....c..
/* 0858 */ 0xE9, 0x4B, 0x58, 0x82, 0xF7, 0x1A, 0x9F, 0x6C, // .KX....l
/* 0860 */ 0x1E, 0x5C, 0x58, 0xB2, 0x21, 0xA0, 0x06, 0xEB, // .\X.!...
/* 0868 */ 0x21, 0x60, 0xA6, 0x9A, 0xC0, 0x49, 0x46, 0x80, // !`...IF.
/* 0870 */ 0xCA, 0x00, 0xA1, 0x1B, 0xCB, 0xE9, 0x3E, 0x8B, // ......>.
/* 0878 */ 0x84, 0x38, 0xCD, 0x47, 0x99, 0xC7, 0x02, 0x8F, // .8.G....
/* 0880 */ 0xF5, 0xC1, 0xC0, 0xFF, 0x7F, 0xCD, 0x23, 0xD4, // ......#.
/* 0888 */ 0x7D, 0xCD, 0x33, 0x7B, 0x3A, 0xC0, 0xAC, 0x22, // }.3{:.."
/* 0890 */ 0xDC, 0x7B, 0xCE, 0x1B, 0x86, 0xD1, 0x9E, 0x2D, // .{.....-
/* 0898 */ 0x7C, 0xCD, 0x78, 0xD6, 0x34, 0x42, 0x38, 0x76, // |.x.4B8v
/* 08A0 */ 0x83, 0xF3, 0x48, 0x8C, 0xF0, 0x82, 0xC0, 0x4E, // ..H....N
/* 08A8 */ 0x0C, 0x0F, 0x30, 0xC6, 0x39, 0x79, 0xC3, 0xFA, // ..0.9y..
/* 08B0 */ 0xC2, 0xCB, 0x40, 0x83, 0x19, 0xDB, 0x97, 0x01, // ..@.....
/* 08B8 */ 0x36, 0x2A, 0xDF, 0x88, 0xC0, 0x97, 0xFC, 0x62, // 6*.....b
/* 08C0 */ 0x00, 0x65, 0x16, 0xBE, 0x9E, 0xF8, 0xA0, 0xC4, // .e......
/* 08C8 */ 0x2E, 0x06, 0x2C, 0xE5, 0xC5, 0x00, 0x54, 0x37, // ..,...T7
/* 08D0 */ 0x0C, 0x5F, 0x0C, 0xE0, 0x5F, 0x89, 0x5E, 0x0C, // ._.._.^.
/* 08D8 */ 0xC0, 0x70, 0x71, 0xF2, 0x3D, 0xC0, 0x1E, 0xEE, // .pq.=...
/* 08E0 */ 0xA3, 0x74, 0x9C, 0xBE, 0xFD, 0xBD, 0x19, 0xF8, // .t......
/* 08E8 */ 0x6C, 0xC0, 0x60, 0x3C, 0xC3, 0x30, 0xC6, 0x08, // l.`<.0..
/* 08F0 */ 0xE3, 0x51, 0x86, 0x31, 0xC1, 0xDC, 0xB7, 0x03, // .Q.1....
/* 08F8 */ 0xE8, 0x39, 0x87, 0x81, 0x4A, 0x78, 0x3B, 0x80, // .9..Jx;.
/* 0900 */ 0x72, 0x0E, 0xE8, 0xF2, 0x68, 0x42, 0x4F, 0x01, // r...hBO.
/* 0908 */ 0x4F, 0x07, 0x3E, 0x29, 0x1A, 0xA2, 0xAF, 0xB1, // O.>)....
/* 0910 */ 0x0A, 0x26, 0x50, 0xC4, 0x07, 0x0D, 0x3E, 0xB5, // .&P...>.
/* 0918 */ 0x28, 0x3E, 0x15, 0x78, 0x2D, 0xCF, 0x4E, 0xE1, // (>.x-.N.
/* 0920 */ 0xE2, 0x9C, 0x89, 0xA7, 0x6A, 0x38, 0x03, 0xBD, // ....j8..
/* 0928 */ 0xE6, 0x86, 0x63, 0xFF, 0x7F, 0x38, 0xFC, 0xA9, // ..c..8..
/* 0930 */ 0xE0, 0x35, 0x80, 0x1D, 0x24, 0x3D, 0x2D, 0x23, // .5..$=-#
/* 0938 */ 0xC2, 0x38, 0xA4, 0x3C, 0x32, 0xF8, 0xB6, 0x18, // .8.<2...
/* 0940 */ 0xC7, 0x90, 0x0F, 0x91, 0xBE, 0x13, 0x18, 0xF2, // ........
/* 0948 */ 0x21, 0xEF, 0x79, 0xC7, 0xC0, 0xAF, 0x08, 0x71, // !.y....q
/* 0950 */ 0x9E, 0xB2, 0x7C, 0x67, 0xF0, 0x65, 0x01, 0x7C, // ..|g.e.|
/* 0958 */ 0x91, 0x2E, 0x0B, 0x68, 0x68, 0x9F, 0x64, 0x7C, // ...hh.d|
/* 0960 */ 0x41, 0x30, 0xEC, 0x89, 0xB3, 0x00, 0x77, 0x05, // A0....w.
/* 0968 */ 0x50, 0x81, 0xFA, 0xAE, 0x00, 0xFF, 0x42, 0xF0, // P.....B.
/* 0970 */ 0xAE, 0x00, 0x86, 0x79, 0xF9, 0x56, 0xC0, 0x35, // ...y.V.5
/* 0978 */ 0x1D, 0x4A, 0xD0, 0x67, 0x12, 0x5F, 0x17, 0x70, // .J.g._.p
/* 0980 */ 0x53, 0x64, 0xA9, 0x8E, 0x0A, 0xD0, 0x53, 0x4C, // Sd....SL
/* 0988 */ 0x02, 0x75, 0x47, 0xF7, 0x51, 0x01, 0xC6, 0x4D, // .uG.Q..M
/* 0990 */ 0xD9, 0x07, 0x54, 0x76, 0x5A, 0x60, 0x67, 0x21, // ..TvZ`g!
/* 0998 */ 0x76, 0x1D, 0xC1, 0x5D, 0x49, 0x18, 0xCA, 0xB3, // v..]I...
/* 09A0 */ 0x81, 0x2F, 0x59, 0xFC, 0x70, 0x00, 0x03, 0xDC, // ./Y.p...
/* 09A8 */ 0xB3, 0x38, 0xC4, 0x08, 0xB1, 0xD9, 0x81, 0xEB, // .8......
/* 09B0 */ 0x75, 0xD2, 0x70, 0x2F, 0x44, 0xEC, 0xFF, 0x7F, // u.p/D...
/* 09B8 */ 0x32, 0x00, 0xE3, 0x51, 0x1B, 0x1C, 0x27, 0x9D, // 2..Q..'.
/* 09C0 */ 0xF0, 0x91, 0x9E, 0x59, 0xF8, 0x49, 0x19, 0x30, // ...Y.I.0
/* 09C8 */ 0x71, 0xF2, 0x03, 0xE3, 0xC9, 0x1A, 0xC6, 0x00, // q.......
/* 09D0 */ 0xB8, 0xBC, 0x57, 0x95, 0x81, 0xFC, 0x43, 0x90, // ..W...C.
/* 09D8 */ 0x20, 0x18, 0xD4, 0x29, 0x19, 0x38, 0x1C, 0xC5, // ..).8..
/* 09E0 */ 0x70, 0xA7, 0x64, 0x78, 0x50, 0xF8, 0xC3, 0x00, // p.dxP...
/* 09E8 */ 0xE6, 0x46, 0xE8, 0x7B, 0x82, 0xA1, 0xDE, 0x93, // .F.{....
/* 09F0 */ 0x0E, 0xE3, 0x91, 0xD0, 0x04, 0x3E, 0x2D, 0xC3, // .....>-.
/* 09F8 */ 0xFA, 0xFF, 0x9F, 0x96, 0x81, 0xD5, 0xB1, 0xDD, // ........
/* 0A00 */ 0x43, 0xF6, 0x59, 0x01, 0x77, 0x76, 0x80, 0x3B, // C.Y.wv.;
/* 0A08 */ 0x3D, 0x7E, 0x7A, 0x00, 0x9C, 0x00, 0x3D, 0x3D, // =~z...==
/* 0A10 */ 0x80, 0xED, 0xBC, 0x01, 0xF7, 0x40, 0x80, 0x38, // .....@.8
/* 0A18 */ 0xFE, 0xA3, 0x82, 0x5F, 0x59, 0x28, 0x1C, 0x3F, // ..._Y(.?
/* 0A20 */ 0xB6, 0xF3, 0x63, 0x09, 0xEE, 0x70, 0xE0, 0x23, // ..c..p.#
/* 0A28 */ 0x83, 0x0F, 0x90, 0xB8, 0xA1, 0xF8, 0x50, 0x81, // ......P.
/* 0A30 */ 0x3C, 0x0B, 0x80, 0x62, 0xF4, 0x6C, 0x04, 0xEC, // <..b.l..
/* 0A38 */ 0x06, 0xF3, 0xD2, 0x12, 0xE5, 0xFF, 0xFF, 0xDE, // ........
/* 0A40 */ 0xC0, 0x4E, 0x29, 0xB8, 0x83, 0x00, 0xF8, 0x8E, // .N).....
/* 0A48 */ 0x01, 0xE0, 0x1D, 0x0C, 0x97, 0x35, 0x66, 0x94, // .....5f.
/* 0A50 */ 0x10, 0x18, 0x8D, 0x19, 0x77, 0x08, 0xE1, 0x27, // ....w..'
/* 0A58 */ 0x02, 0xDC, 0x98, 0x3D, 0x6E, 0x8F, 0x19, 0x77, // ...=n..w
/* 0A60 */ 0x9C, 0xE5, 0xA3, 0x7A, 0xCA, 0x08, 0xE5, 0x03, // ...z....
/* 0A68 */ 0x07, 0x3B, 0x67, 0xBC, 0x11, 0xF0, 0xA1, 0x03, // .;g.....
/* 0A70 */ 0x8F, 0x03, 0x0C, 0xEE, 0x48, 0x01, 0xC6, 0xCB, // ....H...
/* 0A78 */ 0x01, 0x1B, 0x3B, 0xB8, 0x83, 0x90, 0x53, 0x20, // ..;...S
/* 0A80 */ 0x4B, 0x87, 0xD1, 0xD8, 0x71, 0xB2, 0x81, 0x74, // K...q..t
/* 0A88 */ 0x8C, 0xF1, 0x21, 0xD7, 0x63, 0xC7, 0x0D, 0xD6, // ..!.c...
/* 0A90 */ 0x63, 0xC7, 0x1D, 0x5F, 0xB0, 0xFF, 0xFF, 0xE3, // c.._....
/* 0A98 */ 0x0B, 0x18, 0xC6, 0xC0, 0xC5, 0x0F, 0x03, 0x7D, // .......}
/* 0AA0 */ 0xF3, 0xF3, 0xE8, 0x0C, 0xEE, 0x61, 0xFB, 0x04, // .....a..
/* 0AA8 */ 0x13, 0xE3, 0xF9, 0x25, 0xC4, 0x23, 0xCC, 0x8B, // ...%.#..
/* 0AB0 */ 0x4B, 0x84, 0xA3, 0x08, 0xF2, 0xE6, 0x12, 0xE7, // K.......
/* 0AB8 */ 0xD5, 0x20, 0xCC, 0x63, 0x4B, 0x94, 0x10, 0x11, // . .cK...
/* 0AC0 */ 0x0E, 0x26, 0xCE, 0x13, 0x8C, 0x11, 0x0E, 0x3C, // .&.....<
/* 0AC8 */ 0x8A, 0x21, 0x22, 0x9C, 0x40, 0x88, 0x93, 0x3E, // .!".@..>
/* 0AD0 */ 0xD9, 0x20, 0xE1, 0x63, 0x84, 0x8D, 0xF6, 0x04, // . .c....
/* 0AD8 */ 0xC3, 0xC7, 0xC2, 0xCF, 0x2B, 0x1E, 0x3C, 0x3F, // ....+.<?
/* 0AE0 */ 0xAD, 0xF9, 0x2E, 0xE8, 0xC9, 0x9C, 0xE3, 0x43, // .......C
/* 0AE8 */ 0x96, 0xA7, 0xF6, 0x38, 0xE9, 0xC3, 0x2C, 0x6E, // ...8..,n
/* 0AF0 */ 0x50, 0x0F, 0x8E, 0xEC, 0xAE, 0xE3, 0xE3, 0x35, // P......5
/* 0AF8 */ 0xF6, 0x14, 0xE4, 0x21, 0xF0, 0x13, 0x81, 0x2F, // ...!.../
/* 0B00 */ 0x88, 0x9E, 0xAC, 0xEF, 0x7A, 0xEC, 0x5E, 0x66, // ....z.^f
/* 0B08 */ 0x8C, 0xEA, 0xA7, 0x80, 0x3A, 0xA6, 0x9C, 0xC1, // ....:...
/* 0B10 */ 0x2B, 0x04, 0xBB, 0xE7, 0xF9, 0x90, 0xED, 0xBB, // +.......
/* 0B18 */ 0x24, 0x1B, 0x05, 0xEE, 0x90, 0xE0, 0x33, 0x12, // $.....3.
/* 0B20 */ 0x3F, 0x55, 0x78, 0x18, 0x1E, 0x05, 0x8C, 0x19, // ?Ux.....
/* 0B28 */ 0xBC, 0x23, 0x1C, 0x5A, 0x88, 0x03, 0x7E, 0xDF, // .#.Z..~.
/* 0B30 */ 0x65, 0x43, 0x8D, 0x71, 0x7A, 0x3E, 0x7F, 0xB0, // eC.qz>..
/* 0B38 */ 0x41, 0xC0, 0x87, 0x3A, 0x54, 0x0F, 0xF3, 0xA8, // A..:T...
/* 0B40 */ 0x5E, 0x0A, 0x19, 0xCE, 0xD9, 0xC1, 0x1D, 0x04, // ^.......
/* 0B48 */ 0xF6, 0xF8, 0xE1, 0x41, 0xF0, 0x9B, 0x25, 0x1F, // ...A..%.
/* 0B50 */ 0x04, 0x3B, 0xDF, 0xBC, 0xC1, 0x19, 0xE4, 0xFF, // .;......
/* 0B58 */ 0x7F, 0x0C, 0xB0, 0xCF, 0x54, 0x3E, 0x9A, 0x20, // ....T>.
/* 0B60 */ 0x8E, 0x80, 0xE8, 0xF3, 0x87, 0xC7, 0xF0, 0x26, // .......&
/* 0B68 */ 0xC7, 0x87, 0x83, 0x3D, 0x7A, 0xE0, 0x4E, 0x22, // ...=z.N"
/* 0B70 */ 0x70, 0x8F, 0x5D, 0x07, 0xED, 0x6B, 0x9C, 0x2F, // p.]..k./
/* 0B78 */ 0x5A, 0x30, 0xEE, 0x7B, 0xCF, 0x22, 0xE0, 0xC7, // Z0.{."..
/* 0B80 */ 0x78, 0x6C, 0x01, 0xC7, 0xA1, 0x04, 0xDC, 0xC1, // xl......
/* 0B88 */ 0x8E, 0x6B, 0x1C, 0x42, 0x51, 0x60, 0x74, 0x28, // .k.BQ`t(
/* 0B90 */ 0xC1, 0xC5, 0x00, 0x12, 0x8C, 0x63, 0x9C, 0xD1, // .....c..
/* 0B98 */ 0xD0, 0x97, 0x48, 0x1F, 0xD2, 0xE0, 0x0C, 0x1A, // ..H.....
/* 0BA0 */ 0xF6, 0x3C, 0x9F, 0x50, 0xB8, 0x3D, 0x01, 0x8A, // .<.P.=..
/* 0BA8 */ 0x4E, 0x28, 0x20, 0xC3, 0x7D, 0x06, 0xC1, 0x9E, // N( .}...
/* 0BB0 */ 0x10, 0xF8, 0x19, 0x84, 0xFD, 0xFF, 0x0F, 0x8E, // ........
/* 0BB8 */ 0x1E, 0xF7, 0x7B, 0xA3, 0x4F, 0x8D, 0x6C, 0xEE, // ..{.O.l.
/* 0BC0 */ 0x0F, 0x01, 0x27, 0x70, 0xEE, 0xEC, 0xD4, 0x8C, // ..'p....
/* 0BC8 */ 0x3B, 0x33, 0x60, 0xCF, 0x1F, 0x1E, 0x02, 0x3F, // ;3`....?
/* 0BD0 */ 0x17, 0x78, 0xF8, 0x1E, 0x02, 0x7E, 0xF0, 0x0F, // .x...~..
/* 0BD8 */ 0xCC, 0x06, 0x07, 0xE3, 0x29, 0xC2, 0xD7, 0x0E, // ....)...
/* 0BE0 */ 0x0E, 0xCE, 0x4F, 0x03, 0x06, 0xE7, 0xAF, 0x50, // ..O....P
/* 0BE8 */ 0x9F, 0xE7, 0x19, 0x38, 0xF6, 0xD4, 0xEB, 0x7B, // ...8...{
/* 0BF0 */ 0x87, 0xE7, 0xEB, 0x43, 0x05, 0xFE, 0xA6, 0xE7, // ...C....
/* 0BF8 */ 0x43, 0x05, 0x38, 0x0E, 0x0F, 0xFC, 0xB0, 0xC2, // C.8.....
/* 0C00 */ 0x86, 0xF0, 0x28, 0x80, 0x3F, 0xB5, 0xF8, 0xF8, // ..(.?...
/* 0C08 */ 0x17, 0xE7, 0x29, 0x82, 0xDD, 0x46, 0xB0, 0x87, // ..)..F..
/* 0C10 */ 0x0B, 0xC0, 0x51, 0xB4, 0xB3, 0x18, 0x2A, 0xCC, // ..Q...*.
/* 0C18 */ 0x59, 0x8C, 0xFC, 0xFF, 0xCF, 0x51, 0xA8, 0xB3, // Y....Q..
/* 0C20 */ 0x18, 0x3D, 0x5C, 0x00, 0x2E, 0x04, 0x1F, 0x0F, // .=\.....
/* 0C28 */ 0x40, 0x73, 0x10, 0x78, 0x5C, 0xF0, 0x85, 0xE0, // @s.x\...
/* 0C30 */ 0x48, 0x0E, 0xE4, 0xE9, 0x00, 0xF0, 0x19, 0x4A, // H......J
/* 0C38 */ 0xC3, 0xA1, 0x09, 0x13, 0x03, 0x06, 0x75, 0x3E, // ......u>
/* 0C40 */ 0xF0, 0x09, 0xC5, 0xC7, 0x0E, 0x7E, 0x36, 0xF0, // .....~6.
/* 0C48 */ 0x8D, 0xDC, 0x43, 0xE5, 0xA7, 0x66, 0x5F, 0xF2, // ..C..f_.
/* 0C50 */ 0x11, 0xE0, 0x02, 0x75, 0xA0, 0x61, 0xA0, 0x46, // ...u.a.F
/* 0C58 */ 0xE4, 0x23, 0xD2, 0xFF, 0xFF, 0xB9, 0x0D, 0x1B, // .#......
/* 0C60 */ 0x60, 0x68, 0xF4, 0x1C, 0x0E, 0xE3, 0x80, 0xEB, // `h......
/* 0C68 */ 0x73, 0x38, 0x76, 0x40, 0x3E, 0x87, 0xC3, 0x3F, // s8v@>..?
/* 0C70 */ 0x47, 0xC3, 0x1F, 0x1B, 0x3B, 0xDD, 0xF3, 0x81, // G...;...
/* 0C78 */ 0xC1, 0xBA, 0x7E, 0x63, 0x06, 0x06, 0xB6, 0x6F, // ..~c...o
/* 0C80 */ 0x91, 0x07, 0x06, 0x1C, 0x51, 0xCF, 0xC6, 0x57, // ....Q..W
/* 0C88 */ 0x08, 0x0F, 0x0C, 0x6C, 0x80, 0x1E, 0x18, 0xF0, // ...l....
/* 0C90 */ 0x89, 0x05, 0x21, 0x27, 0x03, 0x43, 0x9D, 0x32, // ..!'.C.2
/* 0C98 */ 0x8C, 0x1C, 0xF3, 0x89, 0xC3, 0xC3, 0xF0, 0xA1, // ........
/* 0CA0 */ 0x22, 0xEA, 0x33, 0xC0, 0x23, 0x1E, 0x1B, 0x1B, // ".3.#...
/* 0CA8 */ 0xFB, 0xFF, 0x8F, 0x0D, 0x2C, 0xC7, 0x16, 0x8F, // ....,...
/* 0CB0 */ 0x0D, 0xFC, 0x47, 0x78, 0xFC, 0xD8, 0xE0, 0x8C, // ..Gx....
/* 0CB8 */ 0xE5, 0xD1, 0xC4, 0x97, 0x99, 0x23, 0x3B, 0x8D, // .....#;.
/* 0CC0 */ 0x33, 0x7B, 0x0D, 0xF1, 0xD1, 0xEE, 0xF1, 0xDB, // 3{......
/* 0CC8 */ 0x63, 0x03, 0x97, 0x85, 0xB1, 0x01, 0xA5, 0x90, // c.......
/* 0CD0 */ 0x63, 0x43, 0x1F, 0x52, 0x7C, 0x0A, 0xB0, 0x71, // cC.R|..q
/* 0CD8 */ 0x54, 0x32, 0x0F, 0x1F, 0xAF, 0x7C, 0x62, 0x38, // T2...|b8
/* 0CE0 */ 0xBA, 0x20, 0x6F, 0xE8, 0xBE, 0x5C, 0xF8, 0x48, // . o..\.H
/* 0CE8 */ 0x63, 0x30, 0x5F, 0x5A, 0x7C, 0x06, 0xE5, 0x43, // c0_Z|..C
/* 0CF0 */ 0x04, 0xD7, 0x57, 0xC5, 0x43, 0x04, 0x3E, 0xA1, // ..W.C.>.
/* 0CF8 */ 0x86, 0x88, 0x1E, 0xCF, 0xFF, 0xFF, 0x11, 0xCC, // ........
/* 0D00 */ 0x43, 0x64, 0x43, 0x03, 0xAF, 0x87, 0xA1, 0x01, // CdC.....
/* 0D08 */ 0xA5, 0x98, 0xC0, 0x5E, 0x85, 0x87, 0x46, 0x4F, // ...^..FO
/* 0D10 */ 0x3F, 0x3E, 0x04, 0x30, 0x08, 0xDF, 0x06, 0xD8, // ?>.0....
/* 0D18 */ 0x55, 0xC0, 0x57, 0x21, 0x83, 0x24, 0x18, 0xE7, // U.W!.$..
/* 0D20 */ 0x64, 0x41, 0x07, 0x07, 0x8E, 0x21, 0x79, 0x70, // dA...!yp
/* 0D28 */ 0xF0, 0x07, 0xE3, 0x21, 0x70, 0x60, 0xCF, 0xE0, // ...!p`..
/* 0D30 */ 0xB9, 0xE8, 0x31, 0xD8, 0xA7, 0x1D, 0x9F, 0x4A, // ..1....J
/* 0D38 */ 0xC0, 0x77, 0xE6, 0x04, 0xC7, 0xE9, 0x1D, 0x7B, // .w.....{
/* 0D40 */ 0x29, 0xF0, 0x08, 0x1E, 0xAD, 0x3C, 0x02, 0x7E, // )....<.~
/* 0D48 */ 0xB4, 0x02, 0x66, 0xFF, 0xFF, 0xA3, 0x15, 0x30, // ..f....0
/* 0D50 */ 0x09, 0x7A, 0xE6, 0xA4, 0x03, 0x77, 0x34, 0x18, // .z...w4.
/* 0D58 */ 0xD4, 0xD1, 0x0A, 0x5C, 0x11, 0xC0, 0x75, 0xDC, // ...\..u.
/* 0D60 */ 0xF0, 0xD1, 0x02, 0xCE, 0x50, 0x0F, 0xDA, 0x07, // ....P...
/* 0D68 */ 0x65, 0xCF, 0xDA, 0x97, 0x21, 0x76, 0xB4, 0x00, // e...!v..
/* 0D70 */ 0x97, 0x89, 0x43, 0x08, 0xD0, 0x04, 0x3E, 0x89, // ..C...>.
/* 0D78 */ 0x67, 0xEF, 0x43, 0x03, 0xB3, 0x8A, 0xA1, 0x01, // g.C.....
/* 0D80 */ 0xA5, 0xA3, 0x01, 0xEE, 0x44, 0x81, 0xFD, 0xFF, // ....D...
/* 0D88 */ 0x9F, 0x28, 0x60, 0xDE, 0x30, 0x70, 0x07, 0x0A, // .(`.0p..
/* 0D90 */ 0xC0, 0xCD, 0xE9, 0xDB, 0xE3, 0xE2, 0xD0, 0x38, // .......8
/* 0D98 */ 0xC4, 0xE7, 0xA7, 0x73, 0xF6, 0xD1, 0xE8, 0x4C, // ...s...L
/* 0DA0 */ 0x71, 0x67, 0x11, 0x30, 0x9C, 0x7D, 0x11, 0x8F, // qg.0.}..
/* 0DA8 */ 0x18, 0x03, 0xF9, 0x81, 0x21, 0x59, 0x30, 0x28, // ....!Y0(
/* 0DB0 */ 0x16, 0x0F, 0xC5, 0x07, 0x03, 0x0E, 0xEC, 0x23, // .......#
/* 0DB8 */ 0x02, 0x3B, 0x17, 0xB0, 0x73, 0xAD, 0xE1, 0xF8, // .;..s...
/* 0DC0 */ 0x59, 0xC0, 0xA7, 0x84, 0xB7, 0xA6, 0x17, 0x7B, // Y......{
/* 0DC8 */ 0x9F, 0xD7, 0x7D, 0xD6, 0x08, 0xC9, 0xCE, 0xF4, // ..}.....
/* 0DD0 */ 0x3E, 0x89, 0xE2, 0x0E, 0xA2, 0x70, 0x4E, 0x9F, // >....pN.
/* 0DD8 */ 0xE0, 0x22, 0xF0, 0x65, 0xDF, 0xA3, 0xE0, 0xA7, // .".e....
/* 0DE0 */ 0x07, 0xCF, 0xF1, 0x8D, 0xC1, 0xA7, 0x07, 0xE6, // ........
/* 0DE8 */ 0x7E, 0xF8, 0x9A, 0xF1, 0x33, 0xC3, 0xE3, 0x43, // ~...3..C
/* 0DF0 */ 0x88, 0x27, 0xE2, 0xDA, 0xA6, 0x20, 0x5B, 0x18, // .'... [.
/* 0DF8 */ 0x42, 0x09, 0xF4, 0xFF, 0x8F, 0x10, 0xE5, 0x6D, // B......m
/* 0E00 */ 0x20, 0xCA, 0x29, 0x44, 0x88, 0x12, 0xA4, 0xB1, // .)D....
/* 0E08 */ 0xC9, 0x0B, 0x35, 0xCA, 0xD9, 0x45, 0x6E, 0x6D, // ..5..Enm
/* 0E10 */ 0xF6, 0x82, 0x0B, 0x14, 0x2A, 0x66, 0x9C, 0x28, // ....*f.(
/* 0E18 */ 0xEF, 0x10, 0xB1, 0xDA, 0x1F, 0x04, 0x91, 0xF4, // ........
/* 0E20 */ 0x32, 0xD0, 0x71, 0xC9, 0x91, 0x0E, 0x7D, 0xE8, // 2.q...}.
/* 0E28 */ 0x61, 0xFB, 0x04, 0x8C, 0x3F, 0x48, 0xE2, 0xAE, // a...?H..
/* 0E30 */ 0x2A, 0x3E, 0x28, 0xF8, 0x00, 0x80, 0x77, 0x09, // *>(...w.
/* 0E38 */ 0xA8, 0x5B, 0x9D, 0xC7, 0xED, 0xF3, 0x06, 0xF8, // .[......
/* 0E40 */ 0xAF, 0x17, 0x58, 0x82, 0xF2, 0x07, 0x81, 0x1A, // ..X.....
/* 0E48 */ 0x99, 0xA1, 0x3D, 0xCC, 0xB7, 0x19, 0x43, 0xBE, // ..=...C.
/* 0E50 */ 0x07, 0x1C, 0x16, 0x3B, 0x27, 0xF9, 0xF0, 0x08, // ...;'...
/* 0E58 */ 0x1C, 0x8E, 0x01, 0x4F, 0x1B, 0xBE, 0x51, 0x7B, // ...O..Q{
/* 0E60 */ 0xBE, 0x3E, 0x62, 0x01, 0x8E, 0xFE, 0xFF, 0x47, // .>b....G
/* 0E68 */ 0x2C, 0x30, 0x9D, 0xDF, 0x7D, 0x82, 0x01, 0xC7, // ,0..}...
/* 0E70 */ 0xCD, 0x82, 0x9F, 0x61, 0x00, 0x67, 0x40, 0xCF, // ...a.g@.
/* 0E78 */ 0x30, 0x60, 0x1F, 0x2A, 0x6E, 0x08, 0x5C, 0xEE, // 0`.*n.\.
/* 0E80 */ 0x8A, 0x28, 0x90, 0x05, 0xC2, 0xA0, 0x0E, 0xFD, // .(......
/* 0E88 */ 0xE4, 0x08, 0x42, 0xCF, 0x9C, 0x70, 0x86, 0x72, // ..B..p.r
/* 0E90 */ 0xB2, 0xBD, 0x5F, 0x1D, 0xC8, 0x2D, 0xC2, 0x43, // .._..-.C
/* 0E98 */ 0x3D, 0x8B, 0xC7, 0x04, 0x76, 0xDA, 0x02, 0x36, // =...v..6
/* 0EA0 */ 0xFF, 0xFF, 0xE3, 0x29, 0xB0, 0x98, 0xF7, 0xD3, // ...)....
/* 0EA8 */ 0x69, 0x84, 0x63, 0x03, 0xFB, 0x71, 0x0B, 0x38, // i.c..q.8
/* 0EB0 */ 0x1D, 0xCC, 0xE0, 0xDC, 0x7F, 0xD8, 0x2D, 0x1A, // ......-.
/* 0EB8 */ 0x37, 0x34, 0xB0, 0x0D, 0xCC, 0x43, 0x03, 0x3E, // 74...C.>
/* 0EC0 */ 0x27, 0x47, 0x30, 0x9E, 0x98, 0xF8, 0x55, 0xE2, // 'G0...U.
/* 0EC8 */ 0xE1, 0x89, 0x1F, 0x43, 0xC0, 0xFA, 0xFF, 0x3F, // ...C...?
/* 0ED0 */ 0x99, 0x01, 0xF6, 0x84, 0x1E, 0xCB, 0x50, 0xD2, // ......P.
/* 0ED8 */ 0x4E, 0x66, 0x80, 0xC0, 0xFB, 0xD8, 0x3B, 0xC3, // Nf....;.
/* 0EE0 */ 0x4B, 0x83, 0xE7, 0x74, 0xD2, 0xCF, 0x62, 0x3E, // K..t..b>
/* 0EE8 */ 0x99, 0x19, 0x21, 0x0A, 0xBB, 0x8F, 0x19, 0xAD, // ..!.....
/* 0EF0 */ 0x37, 0x14, 0xCD, 0x3C, 0xE8, 0x3B, 0x99, 0x51, // 7..<.;.Q
/* 0EF8 */ 0x62, 0x46, 0x6A, 0x0E, 0x4C, 0x48, 0x11, 0x0F, // bFj.LH..
/* 0F00 */ 0x27, 0x4A, 0x88, 0x60, 0xAF, 0x13, 0x6F, 0x67, // 'J.`..og
/* 0F08 */ 0x4F, 0x66, 0x4C, 0xD6, 0xC9, 0x0C, 0x24, 0xFF, // OfL...$.
/* 0F10 */ 0xFF, 0x93, 0x19, 0x98, 0x5C, 0x9F, 0xCC, 0x80, // ....\...
/* 0F18 */ 0xCA, 0x39, 0x0A, 0x7F, 0x32, 0x03, 0x78, 0x74, // .9..2.xt
/* 0F20 */ 0xC0, 0xC2, 0x9D, 0xCC, 0xC0, 0xF2, 0xFF, 0x3F, // .......?
/* 0F28 */ 0xC4, 0x00, 0xCE, 0xC7, 0x0A, 0x63, 0x0C, 0x3C, // .....c.<
/* 0F30 */ 0xDA, 0xC1, 0x0C, 0x15, 0xE6, 0x6C, 0x86, 0x0E, // .....l..
/* 0F38 */ 0x72, 0x08, 0xA1, 0xC1, 0x0E, 0x21, 0x50, 0xE6, // r....!P.
/* 0F40 */ 0x72, 0xA0, 0xA7, 0xF0, 0x9A, 0xE0, 0x73, 0x14, // r.....s.
/* 0F48 */ 0xD8, 0x0F, 0x67, 0xC0, 0xE1, 0xD4, 0x80, 0x0F, // ..g.....
/* 0F50 */ 0x74, 0xE2, 0x42, 0x8F, 0xC2, 0x23, 0x0E, 0x58, // t.B..#.X
/* 0F58 */ 0xFD, 0xC0, 0xC8, 0xFF, 0xFF, 0x64, 0x06, 0x18, // .....d..
/* 0F60 */ 0x78, 0x6A, 0xF8, 0x40, 0x82, 0x63, 0x31, 0xEA, // xj.@.c1.
/* 0F68 */ 0x1B, 0xC4, 0x21, 0xBE, 0x8D, 0xF8, 0xE8, 0xFE, // ..!.....
/* 0F70 */ 0x6A, 0xE2, 0x4B, 0x00, 0xE6, 0x42, 0xE2, 0xD3, // j.K..B..
/* 0F78 */ 0x09, 0xB3, 0x70, 0x38, 0x03, 0x5A, 0x43, 0x60, // ..p8.ZC`
/* 0F80 */ 0x57, 0x26, 0xCF, 0x9C, 0x0F, 0xE1, 0x6C, 0x3C, // W&....l<
/* 0F88 */ 0x7A, 0xDC, 0xE9, 0x04, 0xDE, 0x38, 0x7C, 0x3A, // z....8|:
/* 0F90 */ 0x01, 0x5E, 0x07, 0x0C, 0xCC, 0x0C, 0xC2, 0x3F, // .^.....?
/* 0F98 */ 0x84, 0xB0, 0x21, 0x9C, 0xAA, 0xC7, 0x70, 0xEE, // ..!...p.
/* 0FA0 */ 0xAF, 0x38, 0x3E, 0x9D, 0x80, 0xF3, 0xFF, 0x7F, // .8>.....
/* 0FA8 */ 0x62, 0x03, 0x0C, 0x0A, 0x7E, 0x32, 0xF8, 0xB8, // b...~2..
/* 0FB0 */ 0x46, 0x25, 0xC2, 0xA0, 0x8E, 0xE6, 0x80, 0x7B, // F%.....{
/* 0FB8 */ 0x98, 0x27, 0x36, 0x26, 0x6F, 0xC5, 0x1A, 0x8B, // .'6&o...
/* 0FC0 */ 0x4F, 0x6C, 0x30, 0xFF, 0xFF, 0x27, 0x36, 0x80, // Ol0..'6.
/* 0FC8 */ 0xD1, 0x87, 0x20, 0xB0, 0xFD, 0xFF, 0x0F, 0x41, // .. ....A
/* 0FD0 */ 0x60, 0x1C, 0xA0, 0x0F, 0x41, 0x80, 0x9B, 0xD3, // `...A...
/* 0FD8 */ 0x09, 0xEE, 0xC4, 0x07, 0xB6, 0x63, 0x10, 0x60, // .....c.`
/* 0FE0 */ 0x6D, 0xE8, 0x3E, 0x06, 0x81, 0xF9, 0xFF, 0x3F, // m.>....?
/* 0FE8 */ 0x5A, 0x98, 0xA3, 0xE0, 0xC2, 0x8E, 0x7C, 0x28, // Z.....|(
/* 0FF0 */ 0x29, 0xA7, 0x3E, 0xB4, 0x0C, 0x20, 0x69, 0x38, // ).>.. i8
/* 0FF8 */ 0xC9, 0x01, 0x9D, 0xD3, 0x3D, 0x70, 0x92, 0x75, // ....=p.u
/* 1000 */ 0xEA, 0x40, 0x8F, 0xC7, 0xA0, 0xAF, 0x1C, 0xBE, // .@......
/* 1008 */ 0x12, 0xF0, 0x23, 0x07, 0x93, 0x00, 0xAA, 0x41, // ..#....A
/* 1010 */ 0xFA, 0xCC, 0x07, 0x9C, 0x8E, 0x1C, 0xE0, 0x38, // .......8
/* 1018 */ 0x26, 0x05, 0xC6, 0xDE, 0x0E, 0xDE, 0x22, 0x3D, // &....."=
/* 1020 */ 0x89, 0xA7, 0xA1, 0xE3, 0x0C, 0x51, 0x38, 0x26, // .....Q8&
/* 1028 */ 0x39, 0x18, 0x44, 0x7A, 0x95, 0x62, 0x03, 0x7C, // 9.Dz.b.|
/* 1030 */ 0xAB, 0xF1, 0xD9, 0xC8, 0x07, 0x10, 0x78, 0xE3, // ......x.
/* 1038 */ 0xF6, 0xD8, 0x61, 0xFF, 0xFF, 0x0F, 0x75, 0xC0, // ..a...u.
/* 1040 */ 0x01, 0xE2, 0xA4, 0xF8, 0x21, 0xC3, 0x98, 0x67, // ....!..g
/* 1048 */ 0xC5, 0x0F, 0x75, 0x80, 0xF5, 0x18, 0x27, 0x3A, // ..u...':
/* 1050 */ 0x94, 0xF0, 0x43, 0x1D, 0x20, 0xE8, 0xFF, 0x7F, // ..C. ...
/* 1058 */ 0xA8, 0x03, 0x86, 0x38, 0x6F, 0x24, 0xD1, 0x1E, // ...8o$..
/* 1060 */ 0xEA, 0x98, 0xE8, 0x43, 0x1D, 0x40, 0xC8, 0xFF, // ...C.@..
/* 1068 */ 0xFF, 0xA1, 0x0E, 0x18, 0x9E, 0x87, 0x00, 0xAE, // ........
/* 1070 */ 0x9C, 0xEF, 0xC0, 0x7C, 0x22, 0x02, 0xEF, 0xFF, // ...|"...
/* 1078 */ 0xFF, 0x7C, 0x07, 0xB8, 0x1B, 0x2D, 0xCC, 0x51, // .|...-.Q
/* 1080 */ 0x70, 0x41, 0xAF, 0x0E, 0x03, 0x51, 0x09, 0x30, // pA...Q.0
/* 1088 */ 0x28, 0x02, 0xC7, 0x5F, 0x9B, 0x60, 0x1C, 0xEA, // (.._.`..
/* 1090 */ 0x7C, 0x87, 0x3E, 0x2F, 0x78, 0xD8, 0x4F, 0x05, // |.>/x.O.
/* 1098 */ 0x9E, 0xC4, 0xA9, 0xFA, 0x5A, 0x70, 0x14, 0x4F, // ....Zp.O
/* 10A0 */ 0x00, 0x3E, 0xE1, 0x01, 0xFF, 0xA1, 0xC1, 0x9A, // .>......
/* 10A8 */ 0x44, 0xF1, 0x43, 0x03, 0xF5, 0x11, 0xE4, 0xFF, // D.C.....
/* 10B0 */ 0x7F, 0x68, 0xC0, 0x28, 0xEA, 0xF9, 0x06, 0x7D, // .h.(...}
/* 10B8 */ 0xCC, 0xF2, 0xD9, 0x20, 0xE6, 0x0B, 0x48, 0x84, // ... ..H.
/* 10C0 */ 0x07, 0x10, 0x5F, 0x1F, 0xD8, 0x71, 0xD2, 0x67, // .._..q.g
/* 10C8 */ 0xA0, 0x40, 0x51, 0xDE, 0x37, 0xF8, 0x09, 0x07, // .@Q.7...
/* 10D0 */ 0x5C, 0x83, 0xF3, 0x09, 0x07, 0xBC, 0x87, 0x23, // \......#
/* 10D8 */ 0x1F, 0x4B, 0xC0, 0x77, 0xD0, 0x84, 0x73, 0x81, // .K.w..s.
/* 10E0 */ 0xF1, 0x8D, 0x8D, 0x9D, 0x06, 0xC0, 0x76, 0x00, // ......v.
/* 10E8 */ 0x06, 0xDF, 0x69, 0x00, 0x1C, 0xC7, 0x24, 0x7E, // ..i...$~
/* 10F0 */ 0x3A, 0x04, 0x13, 0xCC, 0xC1, 0xBC, 0x34, 0xFB, // :.....4.
/* 10F8 */ 0xFF, 0xEF, 0xFD, 0x94, 0x43, 0xCF, 0x86, 0x80, // ....C...
/* 1100 */ 0x75, 0x49, 0x07, 0x43, 0x94, 0x88, 0xB3, 0x21, // uI.C...!
/* 1108 */ 0x20, 0xFD, 0xFF, 0x7F, 0x36, 0xC4, 0x20, 0xC4, // ...6. .
/* 1110 */ 0x09, 0xFC, 0x12, 0xD1, 0xDC, 0xD9, 0x90, 0xAE, // ........
/* 1118 */ 0xD8, 0x67, 0x43, 0x80, 0xE1, 0xFF, 0xFF, 0x23, // .gC....#
/* 1120 */ 0x00, 0xF6, 0x7C, 0x04, 0x38, 0x3D, 0x64, 0x83, // ..|.8=d.
/* 1128 */ 0xE7, 0x14, 0x08, 0xE3, 0xE4, 0x03, 0x38, 0xFE, // ......8.
/* 1130 */ 0xFF, 0x8F, 0x15, 0xE6, 0x18, 0x78, 0xEA, 0x97, // .....x..
/* 1138 */ 0x9B, 0x8F, 0x03, 0x54, 0xD4, 0x2B, 0xC2, 0x30, // ...T.+.0
/* 1140 */ 0x94, 0xC5, 0x87, 0x05, 0x1F, 0x11, 0xF8, 0x61, // .......a
/* 1148 */ 0xC1, 0x23, 0xA8, 0x78, 0x9C, 0xF4, 0x74, 0xE3, // .#.x..t.
/* 1150 */ 0x33, 0x21, 0x3B, 0x24, 0x38, 0xFC, 0x20, 0xE9, // 3!;$8. .
/* 1158 */ 0x41, 0x13, 0x3C, 0xE7, 0x23, 0x78, 0xB7, 0x1E, // A.<.#x..
/* 1160 */ 0x38, 0xA7, 0x02, 0xC0, 0x4D, 0xAE, 0x27, 0xA3, // 8...M.'.
/* 1168 */ 0x4E, 0x17, 0x0E, 0x70, 0x8E, 0x92, 0x8D, 0x63, // N..p...c
/* 1170 */ 0x08, 0xE5, 0x70, 0xCC, 0xB7, 0x87, 0xA6, 0xC9, // ..p.....
/* 1178 */ 0x4E, 0x56, 0x30, 0x63, 0x41, 0xEA, 0x24, 0xE0, // NV0cA.$.
/* 1180 */ 0x01, 0x38, 0x10, 0x8C, 0xB4, 0x93, 0x68, 0x34, // .8....h4
/* 1188 */ 0x86, 0xB3, 0x5A, 0x18, 0xC1, 0x19, 0xC4, 0xC7, // ..Z.....
/* 1190 */ 0x11, 0xE7, 0x3A, 0x19, 0xA1, 0x3F, 0x07, 0x3E, // ..:..?.>
/* 1198 */ 0x15, 0x61, 0x82, 0xDC, 0x4B, 0xE8, 0xBC, 0x7D, // .a..K..}
/* 11A0 */ 0x37, 0xE0, 0x57, 0x61, 0x8F, 0xC5, 0xFF, 0x7F, // 7.Wa....
/* 11A8 */ 0x60, 0xDF, 0x4E, 0xC0, 0x31, 0x17, 0xAB, 0x01, // `.N.1...
/* 11B0 */ 0x45, 0x0D, 0xC0, 0x68, 0x98, 0x53, 0xC0, 0x53, // E..h.S.S
/* 11B8 */ 0x09, 0xB8, 0x82, 0xCD, 0x0D, 0x7D, 0x61, 0xB1, // .....}a.
/* 11C0 */ 0xD6, 0xA9, 0xE8, 0x14, 0xF4, 0x3E, 0x70, 0x70, // .....>pp
/* 11C8 */ 0xC0, 0x63, 0xF6, 0x1E, 0x1C, 0x2C, 0x34, 0x0F, // .c...,4.
/* 11D0 */ 0x0E, 0x6C, 0xD9, 0x06, 0x87, 0x56, 0x72, 0x17, // .l...Vr.
/* 11D8 */ 0x21, 0x87, 0x0F, 0xFC, 0xEC, 0x80, 0x03, 0xA0, // !.......
/* 11E0 */ 0x67, 0x07, 0x0B, 0xC9, 0xB3, 0x03, 0x9B, 0xBE, // g.......
/* 11E8 */ 0xB3, 0x08, 0x28, 0x70, 0xFE, 0xFF, 0x11, 0xDE, // ..(p....
/* 11F0 */ 0x3B, 0x7C, 0x6E, 0x79, 0xF6, 0x60, 0x63, 0x78, // ;|ny.`cx
/* 11F8 */ 0x74, 0x31, 0x9A, 0xD1, 0xB9, 0xA6, 0xDB, 0x04, // t1......
/* 1200 */ 0x4A, 0xC5, 0x6D, 0x82, 0x82, 0xF8, 0x06, 0xE0, // J.m.....
/* 1208 */ 0x84, 0x34, 0xBA, 0x75, 0xE2, 0x66, 0x62, 0xFC, // .4.u.fb.
/* 1210 */ 0x47, 0x0C, 0x1F, 0x11, 0x0E, 0xE9, 0x6C, 0x4D, // G.....lM
/* 1218 */ 0x30, 0x0F, 0xA4, 0x9E, 0x81, 0xBE, 0xB3, 0xE1, // 0.......
/* 1220 */ 0x67, 0x1F, 0xF2, 0xC1, 0xC5, 0xD3, 0xF0, 0xF5, // g.......
/* 1228 */ 0x86, 0xDC, 0x3B, 0xE8, 0xB4, 0x7D, 0x66, 0xC0, // ..;..}f.
/* 1230 */ 0x1C, 0x74, 0x7D, 0x9D, 0x7A, 0x83, 0x27, 0x57, // .t}.z.'W
/* 1238 */ 0x09, 0xEA, 0xE1, 0x02, 0x42, 0x2F, 0x34, 0xBE, // ....B/4.
/* 1240 */ 0xDC, 0x25, 0x78, 0xE0, 0xF4, 0xE9, 0xEE, 0xBD, // .%x.....
/* 1248 */ 0x84, 0x9D, 0xF1, 0x12, 0xBC, 0xE0, 0x25, 0x98, // ......%.
/* 1250 */ 0x77, 0x10, 0xA8, 0x51, 0x79, 0x10, 0x98, 0xAB, // w..Qy...
/* 1258 */ 0x3C, 0xCB, 0x37, 0x06, 0x54, 0xB2, 0x8B, 0x16, // <.7.T...
/* 1260 */ 0x3D, 0xC3, 0xBC, 0xC3, 0xF8, 0x92, 0xE0, 0xEB, // =.......
/* 1268 */ 0x87, 0xCF, 0x2D, 0x5E, 0xC0, 0xEB, 0x16, 0x0C, // ..-^....
/* 1270 */ 0x82, 0x67, 0xA0, 0x57, 0x17, 0xDF, 0xD9, 0x0D, // .g.W....
/* 1278 */ 0xFC, 0x2A, 0xF0, 0x46, 0x13, 0x22, 0x98, 0x61, // .*.F.".a
/* 1280 */ 0x0F, 0xFF, 0xDD, 0xDD, 0xA8, 0xBE, 0xE9, 0x18, // ........
/* 1288 */ 0xEB, 0x75, 0xC4, 0x23, 0xE5, 0xC7, 0x96, 0x03, // .u.#....
/* 1290 */ 0x8A, 0xF4, 0xF2, 0xE6, 0x09, 0xF8, 0x2C, 0xE3, // ......,.
/* 1298 */ 0x53, 0xDD, 0x49, 0xF9, 0x7A, 0x68, 0xF4, 0x57, // S.I.zh.W
/* 12A0 */ 0x08, 0x1F, 0x7E, 0x8C, 0xEC, 0x73, 0x0E, 0x3B, // ..~..s.;
/* 12A8 */ 0xDF, 0xB1, 0x41, 0x71, 0xC4, 0x07, 0x86, 0x97, // ..Aq....
/* 12B0 */ 0x1A, 0x4F, 0x85, 0x9D, 0xBB, 0x60, 0x1C, 0x1C, // .O...`..
/* 12B8 */ 0xD8, 0xB1, 0x08, 0x73, 0x7C, 0x05, 0xD7, 0xC9, // ...s|...
/* 12C0 */ 0xE6, 0xFF, 0xFF, 0xE4, 0x00, 0x6E, 0x78, 0xCC, // .....nx.
/* 12C8 */ 0xC1, 0xD7, 0xE7, 0x0D, 0xDF, 0x0C, 0x3C, 0x2E, // ......<.
/* 12D0 */ 0x7E, 0xE4, 0xF0, 0x49, 0xE3, 0xA5, 0xD3, 0xD8, // ~..I....
/* 12D8 */ 0xA7, 0xE9, 0xA3, 0xD1, 0xCB, 0x9B, 0x4F, 0x2F, // ......O/
/* 12E0 */ 0x18, 0x58, 0x5F, 0x1A, 0x38, 0xAC, 0xD1, 0xC2, // .X_.8...
/* 12E8 */ 0x3E, 0x06, 0x9C, 0xB9, 0x2F, 0x44, 0xB8, 0xC3, // >.../D..
/* 12F0 */ 0x23, 0x58, 0x00, 0xF1, 0xB7, 0x92, 0x47, 0x0E, // #X....G.
/* 12F8 */ 0x4F, 0xC0, 0x80, 0x4C, 0xD3, 0xBA, 0x74, 0x20, // O..L..t
/* 1300 */ 0xE2, 0xA7, 0x3C, 0x2B, 0x5F, 0x99, 0x2E, 0x43, // ..<+_..C
/* 1308 */ 0x0C, 0xE3, 0xA9, 0xF2, 0xF1, 0xC3, 0xB3, 0xF1, // ........
/* 1310 */ 0x51, 0xC0, 0xC7, 0x28, 0xCF, 0xFC, 0x8C, 0x22, // Q..(..."
/* 1318 */ 0xBD, 0x32, 0x10, 0x50, 0x9D, 0x88, 0xB8, 0x42, // .2.P...B
/* 1320 */ 0x18, 0x89, 0xA1, 0xD1, 0x9D, 0x83, 0xC7, 0x1F, // ........
/* 1328 */ 0x22, 0x05, 0x31, 0xA0, 0x6F, 0x2E, 0xC0, 0xF4, // ".1.o...
/* 1330 */ 0x4C, 0x04, 0x5C, 0xFE, 0xFF, 0x37, 0x17, 0x80, // L.\..7..
/* 1338 */ 0xFF, 0xFF, 0xFF, 0x9B, 0x0B, 0xE0, 0xE6, 0xFE, // ........
/* 1340 */ 0xE0, 0x9B, 0x0B, 0x70, 0x8D, 0xB4, 0x2A, 0x7A, // ...p..*z
/* 1348 */ 0x61, 0x77, 0x08, 0x18, 0xD4, 0x9D, 0x1D, 0x70, // aw.....p
/* 1350 */ 0x78, 0x2B, 0x78, 0x67, 0x87, 0xF5, 0xFF, 0xBF, // x+xg....
/* 1358 */ 0xB3, 0xC3, 0xC3, 0x8C, 0x13, 0xE5, 0x85, 0x21, // .......!
/* 1360 */ 0xC6, 0x3B, 0x3B, 0x0B, 0xF0, 0x26, 0xD0, 0x51, // .;;..&.Q
/* 1368 */ 0xC6, 0x77, 0x76, 0x80, 0x1F, 0x67, 0xD8, 0x77, // .wv..g.w
/* 1370 */ 0x69, 0xF0, 0x5E, 0x75, 0x81, 0xF5, 0xFF, 0xFF, // i.^u....
/* 1378 */ 0xAA, 0x0B, 0x3C, 0x04, 0xDF, 0xA7, 0x41, 0x3E, // ..<...A>
/* 1380 */ 0x5E, 0x30, 0x8C, 0x83, 0x2B, 0x27, 0xA1, 0xC7, // ^0..+'..
/* 1388 */ 0x02, 0x6B, 0x85, 0x41, 0xDD, 0xA9, 0xC1, 0xA5, // .k.A....
/* 1390 */ 0x09, 0x5C, 0x17, 0x5F, 0x1F, 0x6A, 0x7C, 0xA4, // .\._.j|.
/* 1398 */ 0xC5, 0x9F, 0x2F, 0x70, 0x01, 0x86, 0x4C, 0x4F, // ../p..LO
/* 13A0 */ 0x65, 0x30, 0xAE, 0x29, 0x3E, 0x95, 0x61, 0xEE, // e0.)>.a.
/* 13A8 */ 0x0E, 0x1E, 0x90, 0x8F, 0x18, 0xC0, 0x67, 0x15, // ......g.
/* 13B0 */ 0x1E, 0x18, 0xEE, 0xB4, 0xE0, 0x9B, 0x92, 0x41, // .......A
/* 13B8 */ 0xCF, 0x31, 0xA8, 0x8F, 0x3C, 0x27, 0xEF, 0x7B, // .1..<'.{
/* 13C0 */ 0xC2, 0xE3, 0x84, 0xA3, 0x9E, 0x83, 0xE8, 0xD8, // ........
/* 13C8 */ 0xC0, 0x71, 0xDC, 0xC0, 0xFD, 0xFF, 0xC7, 0x06, // .q......
/* 13D0 */ 0xEF, 0x70, 0x83, 0x3B, 0xE8, 0xF8, 0x62, 0x70, // .p.;..bp
/* 13D8 */ 0x5C, 0x18, 0xB8, 0xE7, 0x02, 0x0F, 0xC3, 0x37, // \......7
/* 13E0 */ 0x1D, 0x8F, 0x08, 0x33, 0xFE, 0xD7, 0x3F, 0x23, // ...3..?#
/* 13E8 */ 0x04, 0xC4, 0x5F, 0x8C, 0xD8, 0x80, 0xC1, 0x78, // .._....x
/* 13F0 */ 0x6B, 0xF3, 0xF5, 0x0D, 0x37, 0x60, 0x5F, 0x1D, // k...7`_.
/* 13F8 */ 0x7C, 0xC1, 0xF0, 0x09, 0xCC, 0xE8, 0x2F, 0x30, // |...../0
/* 1400 */ 0x4F, 0x62, 0x3E, 0x36, 0x90, 0x0B, 0x1C, 0x1D, // Ob>6....
/* 1408 */ 0x30, 0x38, 0x00, 0x3D, 0x60, 0xF8, 0x87, 0x8B, // 08.=`...
/* 1410 */ 0x77, 0x39, 0x30, 0x5C, 0x05, 0x7D, 0x5C, 0xF0, // w90\.}\.
/* 1418 */ 0xB1, 0xC7, 0x8A, 0xEE, 0x72, 0xE8, 0x9B, 0x9C, // ....r...
/* 1420 */ 0x61, 0xE2, 0x18, 0xE2, 0x0D, 0x8C, 0xDD, 0x25, // a......%
/* 1428 */ 0xC8, 0x61, 0x0E, 0xEA, 0x5D, 0xC2, 0x73, 0xE0, // .a..].s.
/* 1430 */ 0x67, 0x0B, 0x9F, 0xE0, 0x7C, 0xF3, 0x09, 0x71, // g...|..q
/* 1438 */ 0xAA, 0x8F, 0x56, 0xEF, 0x01, 0x3E, 0x7A, 0xBC, // ..V..>z.
/* 1440 */ 0x77, 0xF9, 0xEC, 0xC4, 0x2E, 0x02, 0x3E, 0x72, // w.....>r
/* 1448 */ 0x19, 0xC7, 0xD3, 0xF4, 0x15, 0xD0, 0x43, 0x36, // ......C6
/* 1450 */ 0xD8, 0xAB, 0x86, 0x4F, 0x60, 0x3E, 0xBA, 0xE1, // ...O`>..
/* 1458 */ 0x8E, 0x51, 0x9E, 0x89, 0xA7, 0xEF, 0x3B, 0x08, // .Q....;.
/* 1460 */ 0x3B, 0x92, 0x1C, 0x75, 0xA8, 0x6B, 0x7A, 0x44, // ;..u.kzD
/* 1468 */ 0xF9, 0xFF, 0x9F, 0xD0, 0x81, 0xF8, 0xD6, 0x06, // ........
/* 1470 */ 0xCE, 0x68, 0xF7, 0x0F, 0xF4, 0x36, 0x3D, 0x32, // .h...6=2
/* 1478 */ 0xCC, 0xD1, 0x00, 0xD6, 0x25, 0x04, 0x5C, 0x77, // ....%.\w
/* 1480 */ 0x0C, 0x5F, 0x42, 0x80, 0x4F, 0xD0, 0x4B, 0x04, // ._B.O.K.
/* 1488 */ 0xFA, 0x9A, 0xE1, 0xD1, 0x3D, 0x02, 0x60, 0xAE, // ....=.`.
/* 1490 */ 0x18, 0xEC, 0x58, 0xE0, 0xC3, 0x86, 0xAF, 0x01, // ..X.....
/* 1498 */ 0xEC, 0x5E, 0xE0, 0x30, 0xF7, 0x08, 0x50, 0x81, // .^.0..P.
/* 14A0 */ 0x7A, 0x78, 0xF0, 0xD5, 0xDE, 0x23, 0x40, 0x71, // zx...#@q
/* 14A8 */ 0xB2, 0xF4, 0xA1, 0xC1, 0x03, 0xB5, 0xAA, 0x33, // .......3
/* 14B0 */ 0x26, 0x94, 0x23, 0x26, 0x3F, 0x9B, 0xF9, 0x26, // &.#&?..&
/* 14B8 */ 0x81, 0xB9, 0x5D, 0xFA, 0x26, 0x01, 0x37, 0xCF, // ..].&.7.
/* 14C0 */ 0x2C, 0x50, 0x49, 0x20, 0xF4, 0xFF, 0xBF, 0x49, // ,PI ...I
/* 14C8 */ 0xC0, 0x85, 0xE9, 0xF2, 0x32, 0x43, 0xE7, 0x7F, // ....2C..
/* 14D0 */ 0xE0, 0xBE, 0xD5, 0x79, 0x84, 0x3E, 0x44, 0x30, // ...y.>D0
/* 14D8 */ 0x94, 0xF7, 0x3C, 0x9F, 0xC2, 0xF8, 0x19, 0xC2, // ..<.....
/* 14E0 */ 0x07, 0x4C, 0x76, 0xA6, 0xE0, 0x67, 0x4D, 0xDC, // .Lv..gM.
/* 14E8 */ 0x1D, 0xC0, 0x28, 0x6F, 0x9E, 0x9E, 0x00, 0x3B, // ..(o...;
/* 14F0 */ 0x7F, 0x1A, 0xF9, 0xDD, 0xE0, 0x5D, 0xC0, 0xD3, // .....]..
/* 14F8 */ 0xF7, 0xBD, 0x88, 0x9F, 0x28, 0xC0, 0x17, 0xEC, // ....(...
/* 1500 */ 0x4E, 0x07, 0x05, 0xFA, 0x84, 0x3C, 0x22, 0xA3, // N....<".
/* 1508 */ 0xFA, 0x88, 0xC0, 0x2F, 0x49, 0x60, 0x3C, 0x92, // .../I`<.
/* 1510 */ 0xF8, 0x40, 0x01, 0x84, 0xEE, 0x05, 0xA8, 0xD3, // .@......
/* 1518 */ 0x07, 0x47, 0x3D, 0xE3, 0x17, 0x54, 0x63, 0xBE, // .G=..Tc.
/* 1520 */ 0x5B, 0x3D, 0xC2, 0x79, 0x72, 0x98, 0xCB, 0x01, // [=.yr...
/* 1528 */ 0x8B, 0x73, 0x4D, 0x02, 0xD5, 0x71, 0x97, 0x8F, // .sM..q..
/* 1530 */ 0x0E, 0xEE, 0xB5, 0x15, 0xFB, 0xFF, 0x27, 0x38, // ......'8
/* 1538 */ 0xB8, 0x77, 0x96, 0x77, 0x3E, 0x43, 0x79, 0x90, // .w.w>Cy.
/* 1540 */ 0xE0, 0xBB, 0xB6, 0x82, 0xE3, 0xAA, 0x06, 0xE3, // ........
/* 1548 */ 0xD8, 0xC2, 0x2F, 0x79, 0x80, 0x9D, 0x61, 0x71, // ../y..aq
/* 1550 */ 0xC1, 0x7F, 0x0F, 0x03, 0x51, 0x89, 0x30, 0x28, // ....Q.0(
/* 1558 */ 0x02, 0xCB, 0xBB, 0xB7, 0x52, 0xF8, 0x43, 0x06, // ....R.C.
/* 1560 */ 0xE3, 0x4D, 0x81, 0x4F, 0x1A, 0x3B, 0x6A, 0xE0, // .M.O.;j.
/* 1568 */ 0xFB, 0xFF, 0x1F, 0x35, 0xD8, 0x86, 0x8A, 0xBB, // ...5....
/* 1570 */ 0x29, 0x82, 0x75, 0xAA, 0x98, 0x21, 0xF0, 0x60, // ).u..!.`
/* 1578 */ 0x0F, 0x00, 0x9F, 0xAF, 0x7C, 0x06, 0x50, 0x14, // ....|.P.
/* 1580 */ 0x18, 0xD4, 0xA1, 0x1D, 0xCE, 0x6D, 0x18, 0x70, // .....m.p
/* 1588 */ 0x30, 0x62, 0xDC, 0xA5, 0x10, 0xEE, 0x94, 0xDF, // 0b......
/* 1590 */ 0x51, 0x62, 0x3F, 0x97, 0xB3, 0xE9, 0xE2, 0xAE, // Qb?.....
/* 1598 */ 0xE6, 0x3E, 0x9D, 0xB0, 0x0B, 0x32, 0x8C, 0xB3, // .>...2..
/* 15A0 */ 0xC0, 0x23, 0xC0, 0xAB, 0x39, 0xBF, 0x20, 0x3F, // .#..9. ?
/* 15A8 */ 0x17, 0xBF, 0x10, 0x3C, 0x26, 0x85, 0x78, 0x53, // ...<&.xS
/* 15B0 */ 0x7A, 0x25, 0x36, 0xC6, 0x93, 0x71, 0x73, 0xB7, // z%6..qs.
/* 15B8 */ 0x62, 0x72, 0xDE, 0x79, 0x41, 0x36, 0xC6, 0xD1, // br.yA6..
/* 15C0 */ 0x44, 0x8C, 0x72, 0x6E, 0x0F, 0x03, 0x91, 0x5F, // D.rn..._
/* 15C8 */ 0x90, 0x7D, 0x3F, 0x79, 0x21, 0x88, 0x18, 0xCD, // .}?y!...
/* 15D0 */ 0x10, 0x41, 0x9F, 0x97, 0x8D, 0x15, 0x28, 0xDE, // .A....(.
/* 15D8 */ 0x0B, 0x32, 0x13, 0xF8, 0x56, 0xD0, 0xC1, 0xC5, // .2..V...
/* 15E0 */ 0x17, 0x64, 0xEC, 0xFF, 0xFF, 0x82, 0x0C, 0x30, // .d.....0
/* 15E8 */ 0xE2, 0x64, 0x04, 0xF8, 0x3C, 0x71, 0xE0, 0xCE, // .d..<q..
/* 15F0 */ 0x35, 0x30, 0xFE, 0xFF, 0x97, 0x6A, 0xD8, 0x27, // 50...j.'
/* 15F8 */ 0x1B, 0xC0, 0xD9, 0xD0, 0x7D, 0xB2, 0x01, 0xF7, // ....}...
/* 1600 */ 0x68, 0xE1, 0x1D, 0x4D, 0x10, 0x27, 0x1B, 0x0A, // h..M.'..
/* 1608 */ 0xE4, 0xE0, 0xEB, 0xA2, 0x70, 0x3C, 0xF4, 0x49, // ....p<.I
/* 1610 */ 0x84, 0x1E, 0x9D, 0x7C, 0x94, 0xC4, 0x9D, 0x19, // ...|....
/* 1618 */ 0x3C, 0x91, 0x77, 0x16, 0x8F, 0xE2, 0x65, 0xD0, // <.w...e.
/* 1620 */ 0xF7, 0x82, 0x13, 0x79, 0x7D, 0xB0, 0x9C, 0x63, // ...y}..c
/* 1628 */ 0x24, 0xA8, 0x46, 0xE2, 0xE3, 0x03, 0xFC, 0xEB, // $.F.....
/* 1630 */ 0x8B, 0x8F, 0x91, 0xF0, 0xF9, 0xFC, 0xC3, 0xF2, // ........
/* 1638 */ 0x60, 0x0C, 0xF9, 0xFF, 0x7F, 0x8A, 0xC4, 0x80, // `.......
/* 1640 */ 0x3C, 0xBB, 0x3C, 0x86, 0xF0, 0x0B, 0x24, 0xDC, // <.<...$.
/* 1648 */ 0xD3, 0xCC, 0x01, 0x60, 0x64, 0x5D, 0x1E, 0xD1, // ...`d]..
/* 1650 */ 0x67, 0x47, 0x8E, 0x11, 0xD7, 0x17, 0x45, 0x5F, // gG....E_
/* 1658 */ 0x81, 0x7D, 0x10, 0x38, 0x9F, 0xE7, 0x44, 0xB0, // .}.8..D.
/* 1660 */ 0x8E, 0x9A, 0x1F, 0x6D, 0xF8, 0xF8, 0x39, 0xF8, // ...m..9.
/* 1668 */ 0x5B, 0xC1, 0x03, 0xA5, 0x8F, 0x45, 0x21, 0x1E, // [....E!.
/* 1670 */ 0x91, 0xF8, 0x39, 0x11, 0x5C, 0x26, 0xCE, 0x89, // ..9.\&..
/* 1678 */ 0x40, 0xE2, 0xD0, 0x0B, 0xE3, 0xB4, 0x80, 0x1B, // @.......
/* 1680 */ 0x88, 0xCF, 0x94, 0xD8, 0x29, 0x9F, 0x08, 0x3B, // ....)..;
/* 1688 */ 0x97, 0x60, 0x46, 0x07, 0xAE, 0xCB, 0xBD, 0x47, // .`F....G
/* 1690 */ 0x07, 0xFE, 0x93, 0x00, 0x1E, 0xEB, 0xFF, 0xFF, // ........
/* 1698 */ 0x78, 0x07, 0xBE, 0x93, 0xBA, 0xEF, 0x26, 0xBE, // x.....&.
/* 16A0 */ 0xC8, 0xF8, 0x50, 0xF4, 0x7C, 0x07, 0xF8, 0x0F, // ..P.|...
/* 16A8 */ 0x77, 0xB8, 0x43, 0xC5, 0x39, 0xDF, 0x01, 0xD2, // w.C.9...
/* 16B0 */ 0xFE, 0xFF, 0xE7, 0x3B, 0x60, 0x79, 0xB6, 0x7E, // ...;`y.~
/* 16B8 */ 0xBE, 0x03, 0xBB, 0xC8, 0xF3, 0x1D, 0x40, 0xAC, // ......@.
/* 16C0 */ 0xFF, 0xFF, 0xF9, 0x0E, 0xB0, 0x73, 0x46, 0xC3, // .....sF.
/* 16C8 */ 0x9D, 0xEF, 0xC0, 0x76, 0xB4, 0x01, 0xCC, 0x4D, // ...v...M
/* 16D0 */ 0xE3, 0xD1, 0x06, 0xDC, 0xC3, 0x85, 0x3D, 0x0C, // ......=.
/* 16D8 */ 0xAE, 0xD0, 0xA6, 0x4F, 0x8D, 0x46, 0xAD, 0x1A, // ...O.F..
/* 16E0 */ 0x94, 0xA9, 0x51, 0xE6, 0xFF, 0xDF, 0xA0, 0x56, // ..Q....V
/* 16E8 */ 0x9F, 0x4A, 0x8D, 0x19, 0xCB, 0x0E, 0xA5, 0x80, // .J......
/* 16F0 */ 0x8F, 0x0A, 0x8D, 0xCD, 0xF2, 0x28, 0x04, 0x62, // .....(.b
/* 16F8 */ 0x31, 0xAF, 0x06, 0x81, 0x38, 0x2C, 0x08, 0x8D, // 1...8,..
/* 1700 */ 0xF4, 0xCA, 0x11, 0x88, 0x25, 0x3F, 0xFB, 0x05, // ....%?..
/* 1708 */ 0x62, 0xB9, 0x6F, 0x06, 0x81, 0x38, 0xE0, 0x1B, // b.o..8..
/* 1710 */ 0x4C, 0xE0, 0xE4, 0x61, 0x25, 0x70, 0xF2, 0x6E, // L..a%p.n
/* 1718 */ 0x10, 0x88, 0x23, 0x83, 0x50, 0xA1, 0x3A, 0x40, // ..#.P.:@
/* 1720 */ 0x58, 0x4C, 0x10, 0x1A, 0xCA, 0x07, 0x08, 0x93, // XL......
/* 1728 */ 0xFE, 0x48, 0x10, 0x20, 0x31, 0x02, 0xC2, 0xC2, // .H. 1...
/* 1730 */ 0xBD, 0xBF, 0x04, 0x62, 0x69, 0xEF, 0x09, 0x81, // ...bi...
/* 1738 */ 0x58, 0x88, 0x15, 0x10, 0x16, 0x17, 0x84, 0x86, // X.......
/* 1740 */ 0xD3, 0x02, 0xC2, 0x24, 0x99, 0x01, 0x61, 0x81, // ...$..a.
/* 1748 */ 0x40, 0xA8, 0x7C, 0x35, 0x20, 0x4C, 0xA4, 0x1B, // @.|5 L..
/* 1750 */ 0x40, 0xBA, 0x7A, 0x81, 0x38, 0x88, 0x1E, 0x10, // @.z.8...
/* 1758 */ 0x26, 0xC3, 0x0F, 0x08, 0x0B, 0x0D, 0x42, 0xA3, // &.....B.
/* 1760 */ 0x3D, 0x30, 0x04, 0x48, 0x0C, 0x81, 0xB0, 0xF8, // =0.H....
/* 1768 */ 0x8E, 0x40, 0x98, 0xF8, 0x57, 0x91, 0x40, 0x9C, // .@..W.@.
/* 1770 */ 0xDF, 0x12, 0xC4, 0x4D, 0x69, 0x88, 0x35, 0x01, // ...Mi.5.
/* 1778 */ 0x31, 0x0D, 0x9E, 0x80, 0x98, 0x22, 0x10, 0x01, // 1...."..
/* 1780 */ 0x39, 0xF6, 0xD3, 0x43, 0x40, 0xD6, 0x60, 0x0A, // 9..C@.`.
/* 1788 */ 0x88, 0x45, 0x07, 0x11, 0x90, 0x85, 0xA8, 0x02, // .E......
/* 1790 */ 0x62, 0x79, 0x5D, 0x01, 0xB1, 0xF0, 0x20, 0x02, // by]... .
/* 1798 */ 0x72, 0xE6, 0x97, 0x9F, 0x80, 0xAC, 0xE0, 0xA5, // r.......
/* 17A0 */ 0xF3, 0x10, 0xC0, 0xDE, 0x10, 0x81, 0x48, 0x72, // ......Hr
/* 17A8 */ 0x10, 0x01, 0x39, 0xB0, 0x2F, 0x20, 0x16, 0x1F, // ..9./ ..
/* 17B0 */ 0x44, 0x40, 0xCE, 0xFA, 0x28, 0x14, 0x90, 0x83, // D@..(...
/* 17B8 */ 0x83, 0x68, 0x10, 0xE4, 0x6B, 0x26, 0x20, 0xA7, // .h..k& .
/* 17C0 */ 0x07, 0x11, 0x10, 0xF9, 0x04, 0x05, 0x21, 0x6A, // ......!j
/* 17C8 */ 0xBD, 0x81, 0x30, 0x3D, 0x8F, 0x42, 0x0D, 0x85, // ..0=.B..
/* 17D0 */ 0x80, 0x50, 0xE5, 0xEA, 0xCE, 0x31, 0x2C, 0x07, // .P...1,.
/* 17D8 */ 0x08, 0xCD, 0x05, 0x22, 0x30, 0xAB, 0x70, 0x07, // ..."0.p.
/* 17E0 */ 0xC4, 0x54, 0x81, 0x08, 0xC8, 0x09, 0x80, 0xC8, // .T......
/* 17E8 */ 0xFF, 0x9F, 0x60, 0x2A, 0x10, 0x9A, 0x12, 0x8C, // ..`*....
/* 17F0 */ 0xEA, 0x92, 0x07, 0xC4, 0x12, 0x80, 0xD0, 0x54, // .......T
/* 17F8 */ 0x20, 0x34, 0x25, 0x88, 0x00, 0xAD, 0xCA, 0x1E, // 4%.....
/* 1800 */ 0x10, 0x53, 0x0A, 0x42, 0x95, 0x83, 0xD0, 0x74, // .S.B...t
/* 1808 */ 0x20, 0x54, 0xB6, 0xBE, 0xC3, 0x02, 0x05, 0x11, // T......
/* 1810 */ 0x90, 0xA3, 0x83, 0x50, 0xE1, 0xFE, 0x40, 0x98, // ...P..@.
/* 1818 */ 0xDE, 0x97, 0x86, 0x00, 0x9D, 0x0E, 0x44, 0x40, // ......D@
/* 1820 */ 0x4E, 0x0C, 0x42, 0x15, 0x7C, 0x32, 0x82, 0x10, // N.B.|2..
/* 1828 */ 0xB1, 0x20, 0x54, 0xC1, 0x27, 0x23, 0x28, 0xD1, // . T.'#(.
/* 1830 */ 0xF2, 0xB2, 0x13, 0x90, 0xF5, 0x81, 0x50, 0xBD, // ......P.
/* 1838 */ 0x20, 0x02, 0x73, 0x36, 0x20, 0x9A, 0x17, 0x84, // .s6 ...
/* 1840 */ 0xE6, 0x07, 0xA3, 0x5A, 0x8D, 0x02, 0x31, 0xFD, // ...Z..1.
/* 1848 */ 0x20, 0x34, 0x0F, 0x88, 0xC0, 0xAC, 0xE0, 0xF9, // 4......
/* 1850 */ 0x71, 0xC0, 0x0C, 0x84, 0xAA, 0x04, 0x11, 0x98, // q.......
/* 1858 */ 0x73, 0x01, 0xD1, 0xAC, 0x20, 0x34, 0x3B, 0x18, // s... 4;.
/* 1860 */ 0xD5, 0xFE, 0x0F, 0xD1, 0x00, 0x08, 0x08, 0xCD, // ........
/* 1868 */ 0x07, 0xA2, 0xC3, 0x00, 0x79, 0x96, 0x09, 0xC8, // ....y...
/* 1870 */ 0x1A, 0x41, 0xA8, 0x66, 0x10, 0x81, 0x39, 0x27, // .A.f..9'
/* 1878 */ 0x10, 0xCD, 0x0E, 0x42, 0x95, 0xFD, 0x4D, 0x82, // ...B..M.
/* 1880 */ 0x91, 0x8C, 0x0F, 0xD0, 0x40, 0x24, 0x37, 0x08, // ....@$7.
/* 1888 */ 0xD5, 0xF1, 0x0C, 0x0A, 0x46, 0x74, 0x83, 0x08, // ....Ft..
/* 1890 */ 0xC8, 0x59, 0x40, 0x68, 0x36, 0x30, 0x9A, 0x4C, // .Y@h60.L
/* 1898 */ 0xED, 0x91, 0x80, 0xBA, 0x05, 0x61, 0xE9, 0x41, // .....a.A
/* 18A0 */ 0x68, 0x3A, 0xBB, 0x83, 0xA7, 0x20, 0x54, 0x81, // h:... T.
/* 18A8 */ 0x5E, 0x30, 0xA6, 0x19, 0x44, 0x87, 0x05, 0x02, // ^0..D...
/* 18B0 */ 0x42, 0x73, 0x81, 0x51, 0x1D, 0xAF, 0x96, 0x40, // Bs.Q...@
/* 18B8 */ 0x44, 0x1B, 0x08, 0xD5, 0x0A, 0xA2, 0x81, 0x93, // D.......
/* 18C0 */ 0x1F, 0x53, 0x10, 0x92, 0x14, 0x84, 0xFC, 0xFF, // .S......
/* 18C8 */ 0x07, 0xAA, 0xC7, 0x9C, 0x40, 0xAC, 0xFA, 0x5B, // ....@..[
/* 18D0 */ 0x25, 0x50, 0x27, 0x01, 0xA1, 0xC9, 0x40, 0x74, // %P'...@t
/* 18D8 */ 0x7C, 0x20, 0x0F, 0xB8, 0x83, 0x64, 0x20, 0x54, // | ...d T
/* 18E0 */ 0x29, 0x88, 0xC0, 0xAC, 0xF4, 0x63, 0xA4, 0x23, // )....c.#
/* 18E8 */ 0x05, 0x51, 0x7D, 0xBC, 0xA0, 0x20, 0x34, 0xD1, // .Q}.. 4.
/* 18F0 */ 0x3B, 0x2C, 0x08, 0x7B, 0xB8, 0x69, 0xA8, 0xE4, // ;,.{.i..
/* 18F8 */ 0x59, 0xA5, 0xA1, 0x12, 0x10, 0x9A, 0x0D, 0x44, // Y......D
/* 1900 */ 0xC7, 0x04, 0xF2, 0xAA, 0x79, 0x4C, 0x60, 0x20, // ....yL`
/* 1908 */ 0x54, 0x2F, 0x08, 0xCD, 0x01, 0x42, 0x13, 0x83, // T/...B..
/* 1910 */ 0x08, 0xD4, 0xA9, 0xBF, 0x37, 0x1A, 0x2A, 0xF9, // ....7.*.
/* 1918 */ 0x5B, 0x09, 0xC4, 0xCA, 0x5E, 0x69, 0x02, 0xB1, // [...^i..
/* 1920 */ 0xDE, 0xA7, 0x4E, 0x20, 0xE6, 0x1D, 0x98, 0xA9, // ..N ....
/* 1928 */ 0x05, 0xA1, 0xEA, 0x41, 0x04, 0xE6, 0xB4, 0x40, // ...A...@
/* 1930 */ 0x54, 0x81, 0x78, 0x10, 0xA6, 0x08, 0x44, 0x60, // T.x...D`
/* 1938 */ 0x4E, 0x02, 0x44, 0xD3, 0x81, 0xD0, 0xEC, 0x60, // N.D....`
/* 1940 */ 0x54, 0xE7, 0xA3, 0x4D, 0x40, 0xD6, 0x0E, 0x42, // T..M@..B
/* 1948 */ 0xB3, 0x80, 0x08, 0xCC, 0x59, 0x1E, 0x69, 0x02, // ....Y.i.
/* 1950 */ 0xB1, 0x92, 0x2F, 0x9D, 0x0E, 0x24, 0x04, 0x84, // ../..$..
/* 1958 */ 0x26, 0xD3, 0x7F, 0x68, 0xA1, 0x05, 0x80, 0x99, // &..h....
/* 1960 */ 0x84, 0x04, 0x20, 0x4C, 0x16, 0x88, 0x0E, 0x27, // .. L...'
/* 1968 */ 0xD6, 0x08, 0x22, 0x40, 0xC7, 0x01, 0xA3, 0xD1, // .."@....
/* 1970 */ 0x40, 0x68, 0x5C, 0x40, 0x9A, 0x1D, 0x90, 0x2A, // @h\@...*
/* 1978 */ 0x6D, 0x00, 0xC6, 0x54, 0x83, 0xD0, 0x24, 0x20, // m..T..$
/* 1980 */ 0x02, 0x74, 0x2C, 0x10, 0x01, 0x5A, 0x74, 0x04, // .t,..Zt.
/* 1988 */ 0x30, 0x16, 0x01, 0x84, 0x46, 0x05, 0xA1, 0xC9, // 0...F...
/* 1990 */ 0x2A, 0x80, 0xB2, 0x9C, 0x20, 0x1A, 0x20, 0xC9, // *... . .
/* 1998 */ 0x30, 0x60, 0x0A, 0x42, 0x33, 0x81, 0xD0, 0x8C, // 0`.B3...
/* 19A0 */ 0x20, 0x54, 0x7C, 0x07, 0x10, 0x16, 0x04, 0x84, // T|.....
/* 19A8 */ 0x86, 0x03, 0xD1, 0x00, 0xFE, 0xFF, 0x8F, 0x0C, // ........
/* 19B0 */ 0x02, 0xD1, 0x00, 0x9C, 0x23, 0xC4, 0x61, 0x85, // ....#.a.
/* 19B8 */ 0x82, 0xD0, 0xF4, 0x20, 0x34, 0x6C, 0x09, 0x50, // ... 4l.P
/* 19C0 */ 0x16, 0x1D, 0x44, 0xC7, 0x23, 0x92, 0x02, 0x8C, // ..D.#...
/* 19C8 */ 0x05, 0x02, 0xA1, 0x31, 0x41, 0x68, 0x6C, 0x10, // ...1Ahl.
/* 19D0 */ 0x1A, 0x29, 0x06, 0x28, 0x13, 0x54, 0xE3, 0x50, // .).(.T.P
/* 19D8 */ 0x44, 0x7B, 0x80, 0x31, 0x99, 0x20, 0x54, 0x36, // D{.1. T6
/* 19E0 */ 0x88, 0xC0, 0x1C, 0x14, 0x88, 0x86, 0x07, 0xA1, // ........
/* 19E8 */ 0x62, 0x82, 0x00, 0x52, 0x10, 0x01, 0x12, 0x20, // b..R...
/* 19F0 */ 0x1A, 0x1E, 0x84, 0x8A, 0x29, 0x32, 0x74, 0x0A, // ....)2t.
/* 19F8 */ 0x42, 0x55, 0x24, 0x39, 0x9A, 0x50, 0x10, 0x1D, // BU$9.P..
/* 1A00 */ 0x4D, 0x08, 0x08, 0xCD, 0x07, 0x46, 0x75, 0x35, // M....Fu5
/* 1A08 */ 0x39, 0x6E, 0x50, 0x10, 0xAA, 0x1D, 0x84, 0x06, // 9nP.....
/* 1A10 */ 0x05, 0xA1, 0x39, 0xA2, 0x80, 0xB2, 0xEC, 0x20, // ..9....
/* 1A18 */ 0x02, 0xB2, 0x9E, 0x2A, 0x87, 0x0A, 0x0A, 0x22, // ...*..."
/* 1A20 */ 0x30, 0xA7, 0x02, 0xA2, 0x49, 0x41, 0xA8, 0x8E, // 0...IA..
/* 1A28 */ 0x2C, 0x47, 0x0A, 0x9A, 0x06, 0x84, 0x25, 0x06, // ,G....%.
/* 1A30 */ 0xA1, 0xC9, 0xDA, 0x80, 0xB0, 0x0C, 0x75, 0x0E, // ......u.
/* 1A38 */ 0x24, 0x14, 0x84, 0xE6, 0x04, 0xA1, 0x4A, 0xF2, // $.....J.
/* 1A40 */ 0x0C, 0x8F, 0x82, 0xE8, 0x38, 0x42, 0x80, 0x68, // ....8B.h
/* 1A48 */ 0x7A, 0x10, 0xAA, 0xA6, 0xCF, 0x00, 0x28, 0x88, // z.....(.
/* 1A50 */ 0x06, 0x40, 0x40, 0x68, 0x4E, 0x30, 0xAA, 0xA8, // .@@hN0..
/* 1A58 */ 0xD1, 0xD1, 0x84, 0x82, 0x50, 0xDD, 0x2F, 0x4E, // ....P./N
/* 1A60 */ 0x81, 0xF8, 0xFF, 0x0F // ....
}) /* END MBUF */
} /*end DefinitionBlock */
Reference in New Issue View Git Blame Copy Permalink