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


/*
 * Some or all of this work - Copyright (c) 2006 - 2011, 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 (
    "grammar.aml",      //Output filename
    "DSDT",             //Signature
    0x01,               //DSDT Revision ---> 32-bit table
    "Intel",            //OEMID
    "GRMTEST",          //TABLE ID
    0x20090511          //OEM Revision
    )
{
 
    External (\ABCD, UnknownObj)
 
 
    /* Device with _STA and _INI */
 
    Device (A1)
    {
        Method (_STA)
        {
            Return (0x0F)
        }
 
        Method (_INI)
        {
            Return
        }
    }
 
    /* Device with no _STA, has _INI */
 
    Device (A2)
    {
        Method (_INI)
        {
            Return
        }
    }
 
    /* Device with _STA, no _INI */
 
    Device (A3)
    {
        Method (_STA)
        {
            Return (0x0F)
        }
    }
 
    /* Device with _STA and _INI, but not present */
 
    Device (A4)
    {
        Method (_STA)
        {
            Return (Zero)
        }
 
        Method (_INI)
        {
            Return
        }
    }
 
 
    /* Resource descriptors */
 
    Device (IRES)
    {
        Name (PRT0, ResourceTemplate ()
        {
            IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
 
            StartDependentFn (1,1)
            {
                IRQNoFlags () {0,1,2}
            }
            EndDependentFn ()
        })
 
        Method (_CRS, 0, NotSerialized)
        {
            Store ("_CRS:", Debug)
            Store (PRT0, Debug)
            Return (PRT0)
        }
 
        Method (_SRS, 1, Serialized)
        {
            Store ("_SRS:", Debug)
            Store (Arg0, Debug)
            Return (Zero)
        }
    }
 
    Name (_NPK, Package ()
    {
        0x1111,
        0x2222,
        0x3333,
        0x4444
    })
 
 
    Device (RES)
    {
        Name (_PRT, Package (0x04)
        {
            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, NotSerialized)
        {
            Name (PRT0, ResourceTemplate ()
            {
                WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
                    0x0000, // Address Space Granularity
                    0xFFF2, // Address Range Minimum
                    0xFFF3, // Address Range Maximum
                    0x0032, // Address Translation Offset
                    0x0002,,,)
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000, // Address Space Granularity
                    0x0000, // Address Range Minimum
                    0x00FF, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0x0100,,,)
                WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
                    0x0000, // Address Space Granularity
                    0xA000, // Address Range Minimum
                    0xBFFF, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0x2000,,,)
                IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, // Address Space Granularity
                    0x0000, // Address Range Minimum
                    0x0CF7, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0x0CF8,,,
                    , TypeStatic)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, // Address Space Granularity
                    0x0D00, // Address Range Minimum
                    0xFFFF, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0xF300,,,
                    , TypeStatic)
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000, // Address Space Granularity
                    0x00000000, // Address Range Minimum
                    0x00000CF7, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0x00000CF8,,,
                    , TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, // Address Space Granularity
                    0x000C8000, // Address Range Minimum
                    0x000EFFFF, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0x00028000,,,
                    , AddressRangeMemory, TypeStatic)
                DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
                    0x00000000, // Address Space Granularity
                    0x000C8000, // Address Range Minimum
                    0x000EFFFF, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0x00028000,,,)
                QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000000000000000, // Address Space Granularity
                    0x0000000000000000, // Address Range Minimum
                    0x0000000000000CF7, // Address Range Maximum
                    0x0000000000000000, // Address Translation Offset
                    0x0000000000000CF8, 0x44, "This is a ResouceSource string",
                    , TypeStatic)
                QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000000000000000, // Address Space Granularity
                    0x0000000000000000, // Address Range Minimum
                    0x0000000000000CF7, // Address Range Maximum
                    0x0000000000000000, // Address Translation Offset
                    0x0000000000000CF8,,,
                    , TypeStatic)
                QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x0000000000000000, // Address Space Granularity
                    0x0000000000100000, // Address Range Minimum
                    0x00000000FFDFFFFF, // Address Range Maximum
                    0x0000000000000000, // Address Translation Offset
                    0x00000000FFD00000,,,
                    , AddressRangeMemory, TypeStatic)
                QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
                    0x0000000000000000, // Address Space Granularity
                    0x0000000000000000, // Address Range Minimum
                    0x0000000000000CF7, // Address Range Maximum
                    0x0000000000000000, // Address Translation Offset
                    0x0000000000000CF8,,,)
                ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000000000000000, // Address Space Granularity
                    0x0000000000000000, // Address Range Minimum
                    0x0000000000000CF7, // Address Range Maximum
                    0x0000000000000000, // Address Translation Offset
                    0x0000000000000CF8, // Address Length
                    0x0000000000000000, // Type Specific Attributes
                    , TypeStatic)
                ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x0000000000000000, // Address Space Granularity
                    0x0000000000100000, // Address Range Minimum
                    0x00000000FFDFFFFF, // Address Range Maximum
                    0x0000000000000000, // Address Translation Offset
                    0x00000000FFD00000, // Address Length
                    0x0000000000000000, // Type Specific Attributes
                    , AddressRangeMemory, TypeStatic)
                ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
                    0x0000000000000000, // Address Space Granularity
                    0x0000000000100000, // Address Range Minimum
                    0x00000000FFDFFFFF, // Address Range Maximum
                    0x0000000000000000, // Address Translation Offset
                    0x00000000FFD00000, // Address Length
                    0x0000000000000000) // Type Specific Attributes
                IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)
                IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)
                FixedIO (0x0061, 0x01)
                IRQNoFlags () {2}
                DMA (Compatibility, BusMaster, Transfer8_16) {4}
                DMA (Compatibility, BusMaster, Transfer8) {2,5,7}
                Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
                Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
                Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)
                Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)
                Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")
                {
                    0x00000E01,
                }
                Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
                {
                    0x00000601,
                    0x00000003,
                    0x00000002,
                    0x00000001,
                }
                Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
                {
                    0xFFFF0000,
                    0x00000003,
                    0x00000002,
                    0x00000001,
                    0x00000005,
                    0x00000007,
                    0x00000009,
                }
                VendorShort () {0x01, 0x02, 0x03}
                VendorLong ()
                {
                    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                    0x09
                }
                Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
                Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
                StartDependentFnNoPri ()
                {
                    IRQNoFlags () {0,1,2}
                    IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
                }
                EndDependentFn ()
            })
            CreateWordField (PRT0, 0x08, BMIN)
            CreateByteField (PRT0, R000._ASZ, RSIZ)
            Store (0x03, BMIN)
            Return (PRT0)
        }
 
        Method (_PRS, 0, NotSerialized)
        {
            Name (BUF0, ResourceTemplate ()
            {
                StartDependentFn (0x01, 0x02)
                {
                    IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
                    IRQNoFlags () {4}
                }
                StartDependentFn (0x02, 0x01)
                {
                    IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
                    IRQNoFlags () {4}
                }
                StartDependentFn (0x00, 0x02)
                {
                    IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
                    IRQNoFlags () {3}
                }
                StartDependentFn (0x00, 0x02)
                {
                    IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
                    IRQNoFlags () {3}
                }
                StartDependentFn (0x02, 0x00)
                {
                    IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
                    IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
                }
                EndDependentFn ()
            })
            Return (BUF0)
        }
 
        Method (_SRS, 1, Serialized)
        {
            Return (Zero)
        }
    }
 
 
    Name(\_S0,Package(0x04){
        0x00,
        0x00,
        0x00,
        0x00
    })
    Name(\_S3,Package(0x04){
        0x05,
        0x05,
        0x00,
        0x00
    })
    Name(\_S4,Package(0x04){
        0x06,
        0x06,
        0x00,
        0x00
    })
    Name(\_S5,Package(0x04){
        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, 0)
 
    /* Custom operation region */
 
    OperationRegion(MYOP,0x80,0xFD60,0x6)
    Field(MYOP,ByteAcc,NoLock,Preserve)
    {
        MFLD,8
    }
 
    Method (TCOP)
    {
        Name (_STR, Unicode ("test"))
        Store (4, MFLD)
        Store (MFLD, Local0)
    }
 
    Name (ERRS, 0x0)
 
    /* Warning should be issued for premature string termination */
 
    NAME (ESC1, "abcdefg\x00hijklmn")
    NAME (ESC2, "abcdefg\000hijklmn")
    Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432")
 
 
    Name(CRSA,ResourceTemplate()
    {
        WORDBusNumber(ResourceProducer,MinFixed,MaxFixed,PosDecode,0x0000,0x0019,0x001D,0x0000,0x0005)
        WORDIO(ResourceProducer,MinFixed,MaxFixed,PosDecode,NonISAOnlyRanges,0x0000,0xC000,0xCFFF,0x0000,0x1000)
        DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
 
    })
    Name(CRSB,ResourceTemplate()
    {
        DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
 
    })
 
    Name(CRSC,ResourceTemplate()
    {
        VendorShort () {0x1, 0x2, 0x3}
    })
    Name(CRSD,ResourceTemplate()
    {
        VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
    })
 
    Name(CRSE,ResourceTemplate()
    {
        IRQNoFlags(){3,4,10,11}
        IRQNoFlags(xxxt){3,4,10,11}
    })
    Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){})
    Method(_CRS,0,NotSerialized)
    {
        Return(CRSR)
    }
 
 
    //
    // Unnamed scope
    //
    Scope (\)
    {
        Name(Bxxx,0xFFFFFFFF)
    }
 
    Name (LANS, 0x0)
 
    PowerResource(LANP,1,0)
    {
        Method(_STA){
            If(LEqual(And(LANS,0x30),0x30)){
                Return(One)
            } Else {
                Return(Zero)
            }
        }
        Method(_ON){
            If(LNot(_STA())){
                Store (0x30, LANS)
            }
        }
        Method(_OFF){
            If(_STA()){
                Store (0, LANS)
            }
        }
    }
 
 
    /* Can a method define another method? */
 
    /**********************************
    Method (TASK, 2, SERIALIZED)
    {
        Sleep (100)
 
        Method (TAS2)
        {
            Sleep (100)
        }
 
        TAS2()
        Return
 
    }
    ************************************/
 
    /* A recursive method */
 
    Method (RCIV, 1)
    {
        Store (Arg0, Debug)
        If (Lequal (Arg0, 0))
        {
            Return ()
        }
        RCIV (Subtract (Arg0, 1))
    }
 
    Method (RTOP)
    {
        RCIV (100)
    }
 
 
    Scope(\_PR)
    {
        Processor(CPU0,0x0,0xFFFFFFFF,0x0) {}
    }
 
    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,3000)
    Name(B2DC,2600)
    Name(B1LF,3000)
    Name(B2LF,2600)
    Name(BPIF,0)
    Name(PBLL,0)
 
    Name(RBIF,Package()
    {
        0x1,
        2200,
        2200,
        0x1,
        10800,
        0,
        0,
        1,
        1,
        "CA54200-5003/5",
        "1",
        "LION",
        "Fujitsu"
    })
 
    Method(SMWE, 4)
    {
       return(ONES)
    }
 
    Method(SMRE, 4)
    {
       return(ONES)
    }
 
/*
    Method(RDBT,0,Serialized){
        If(LNot(SMWE(0x09,0x15,1,1))){
                    Store(0x18,Local2)
            }
    }
*/
    Scope(_SB)
    {
 
        Name (SBUF, Buffer (128) {})
 
        CreateBitField (SBUF, 3, BITY)
        CreateByteField (SBUF, 1, BYTY)
        CreateWordField (SBUF, 2, WRDZ)
        CreateDwordField (SBUF, 4, DWDZ)
        CreateQwordField (SBUF, 8, QWDZ)
        CreateField (SBUF, 128, 12, FLDZ)
        CreateField (SBUF, 148, 96, FLDY)
        CreateField (SBUF, 148, 96, \_SB_.FLDW)
 
        Method (_INI)
        {
            CreateField (\_SB_.SBUF, 148, 96, FLDV)
        }
 
 
        Device(PCI0)
        {
            Name(_HID,EISAID("PNP0A03"))
            Name(_ADR,0x0)
 
            Method(_CRS)
            {
                Name(PRT0, ResourceTemplate() {
                    WORDBusNumber(                          // Bus number resource(0)
                            ResourceConsumer,               // bit 0 of general flags is 1
                            MinFixed,                       // Range is notfixed
                            MaxFixed,                       // Range is not fixed
                            SubDecode,                      // SubDecode
                            0x0000,                           // Granularity
                            0xfff1,                           // Min
                            0xfff2,                           // Max
                            0x0032,                           // Translation
                            0x0002,,,                         // Range Length
                            BUS0
                    ) } )// PRT0
 
                CreateWordField(PRT0, BUS0._MIN, BMIN)          //Minimum bus number suported under this bridge.
 
                Store(3, BMIN)
                Return(PRT0)
 
            } // _CRS
 
            Method(_SRS)
            {
                Return ()
            }
 
            Device(EIO)
            {
                OperationRegion(FJIO,SystemIO,0xFD60,0x6)
                    Field(FJIO,ByteAcc,NoLock,Preserve)
                    {
                        GIDX,8,
 
                        GDTA,8,
 
                        PIDX,8,
 
                        PDTA,8,
 
                        SIDX,8,
 
                        SDTA,8
                    }
                    IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve)
                    {
                        Offset(0x2),
                         ,5,
                        VGAS,2,
                        Offset(0x4),
                         ,4,
                        DCKE,1,
                        Offset(0x5),
                         ,6,
                        ACPW,1,
 
                        Offset(0xA),
                        B1P,1,
 
                        B2P,1,
 
                        B1C,1,
 
                        B2C,1,
 
                        B1ER,1,
 
                        B2ER,1,
 
                        Offset(0xB),
                        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){
            Store(0x1FFF,Local1)
            If( Arg0 ){
                Store(0x2FFF,Local1)
            }
            Store(0x18,Local2)
            If( Arg1 ){
                Store(0x10,Local2)
            }
            If(LNot(SMRE(0x09,0x15,1,RefOf(Local0)))){
                If(LNot(SMWE(0x08,0x14,1,Local1))){
                    If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){
                        Store(Local1,Arg2)
                    }
                }
                Or(Local0,0xFFF,Local0)
                SMWE(0x08,0x14,1,Local0)
            }
        }
        Method(MKWD,2)
        {
            If(And(Arg1,0x80)) {
                Or(0xFFFF0000,Arg0,Local0)
                Or(Local0,ShiftLeft(Arg1,8),Local0)
                Subtract(Zero,Local0,Local0)
            } else {
                Store(Arg0,Local0)
                Or(Local0,ShiftLeft(Arg1,8),Local0)
            }
            Return(Local0)
        }
 
        Device(CMB1)
        {
            Name(_HID,EISAID("PNP0C0A"))
            Name(_UID,0x1)
            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)
                        {
                Store(B1P, B1PS)
                Store(B1CP,B1RS)
                Store(B1C, B1CS)
            }
 
            Method(_BIF){
                RDBT(Zero,Zero,RefOf(B1DC))
                RDBT(Zero,One,RefOf(B1LF))
                Store(B1DC,Index(RBIF,1))
                Store(B1LF,Index(RBIF,2))
                Store("CA54200-5003/5",Index(RBIF,9))
                Store("1",Index(RBIF,10))
                Return(RBIF)
            }
 
            Method(_BST) {
 
                _INI()
 
                Store(Zero,Local0)
 
                if (LAnd(B1P,LNot(B1C))){
                    Or(Local0,1,Local0)
                }
 
                if (LAnd(B1P,B1C)) {
                    Or(Local0,2,Local0)
                }
 
                if (LLessEqual(B1CP,1)) {
                    Or(Local0,4,Local0)
                }
 
                Store(MKWD(B1CL,B1CH),Local1)
 
                Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2)
 
                Store(MKWD(B1VL,B1VH),Local3)
 
                Name(STAT,Package(4){})
                Store(Local0,Index(STAT,0))
                Store(Local1,Index(STAT,1))
                Store(Local2,Index(STAT,2))
                Store(Local3,Index(STAT,3))
 
                If(LNot(BPIF)){
//                    \_SB.PCI0.EIO.EC0.IECT()
//                    \_SB.PCI0.EIO.EC0.SECT()
                    Store(One,BPIF)
                }
                return(STAT)
            }
 
        }
 
    Device (DEV1)
    {
    }
 
    Scope(\_TZ)
    {
        ThermalZone(TZ1)
        {
            Name(_PSL,Package()
            {
                \_PR.CPU0
            })
        }
    }
 
    Method (TZ2, 0, SERIALIZED)
    {
        Name(_PSL,Package()
        {
            \_PR.CPU0
        })
 
        Return (_PSL)
    }
 
    ThermalZone (THM1)
    {
    }
 
    Method (NOTI)
    {
        Notify (\DEV1, 0)
        Notify (\THM1, 0)
        Notify (\_PR.CPU0, 0)
    }
 
    Method (_ERR, 2)
    {
        Increment (ERRS)
        Store ("Run-time exception:", Debug)
        Store (Arg0, Debug)
        Store (Arg1, Debug)
 
        Return (0)          // Map error to AE_OK
    }
 
    Method (DIV0)
    {
        Store (1, Local0)
        Store (0, Local1)
        Divide (Local0, Local1, Local3)
 
        Store ("DIV0 - noabort", Debug)
    }
 
    Method (ERR_, 1)
    {
        if (LEqual (Arg0, 0))
        {
            Store ("+*+*+*+* MTHD_ERROR: Results not equal!", Debug)
        }
        if (LEqual (Arg0, 1))
        {
            Store ("+*+*+*+* MTHD_ERROR: Numeric result is incorrect!", Debug)
        }
        if (LEqual (Arg0, 2))
        {
            Store ("+*+*+*+* MTHD_ERROR: Operand was clobbered!", Debug)
        }
 
        Notify (DEV1, Arg0)
        Increment (ERRS)
    }
 
    Method (R226, 2)
    {
    }
    Method (R225, 2)
    {
        R226 (Arg0, Arg1)
    }
    Method (R224, 2)
    {
        R225 (Arg1, Arg0)
    }
    Method (R223, 2)
    {
        R224 (Arg0, Arg1)
    }
    Method (R222, 2)
    {
        R223 (Arg1, Arg0)
    }
    Method (R111)
    {
        Store (0x01010101, Local0)
        R222 (0xABAB, Local0)
        Store (Local0, Local1)
    }
 
    Method (MAIN)
    {
 
//      SIZE()
        Store (NUM1(), Local0)
        \CMB1._BST()
        RDBT(1,2,3)
        OBJ1(1)
        OBJ2(2)
        CHEK()
        RETZ()
        BITZ()
        LOGS()
        REFS()
        COND()
        TZ2()
 
        //
        // iPCO tests added
        //
        Store (\IFEL.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\NOSV.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\IDXF.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.NSTL.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\RTBF.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.RTLV.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.RETP.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\WHLR.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\ANDO.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\BRKP.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\ADSU.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\INDC.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\LOPS.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\FDSO.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\MLDV.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\NBIT.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\SHFT.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\XORD.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\CRBF.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\IDX4.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\EVNT.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\SZLV.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.BYTF.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\DWDF.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\DVAX.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\IDX6.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\IDX5.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.IDX0.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.IDX3.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\IDX7.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\MTCH.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\WHLB.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.IDX2.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\SIZO.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        Store (\_SB_.SMIS.TEST(), Local0)
        if (LGreater (Local0, 0))
        {
            ERR_ (1)
            Return(Local0)
        }
 
        if (LGreater (ERRS, 0))
        {
            Store ("****** There were errors during the execution of the test ******", Debug)
        }
 
        //
        // Last Test
        //
 
        Return(0) // Success
    }
 
 
    Method (OBJ1, 1, SERIALIZED)
    {
 
        Store (3, Local0)
        Name(BUFR, Buffer (Local0) {})
        Name(BUF1, Buffer (4) {1,2,3,4})
        Name(BUF2, Buffer (4) {})
 
        Store (BUF1, BUF2)
        Mutex (MTX1, 4)
 
        Alias (MTX1, MTX2)
    }
 
 
    Mutex (MTXT, 0)
    Mutex (MTXX, 0)
 
    /*
     * Field Creation
     */
 
    Method (FLDS)
    {
        Store ("++++++++ Creating BufferFields", Debug)
        Name (BUF2, Buffer (128) {})
 
        CreateBitField (BUF2, 3, BIT2)
        CreateByteField (BUF2, 1, BYT2)
        CreateWordField (BUF2, 2, WRD2)
        CreateDwordField (BUF2, 4, DWD2)
        CreateQwordField (BUF2, 8, QWD2)
        CreateField (BUF2, 128, 12, FLD2)
        CreateField (BUF2, 148, 96, FLD3)
 
        Store (0x1, BIT2)
        Store (BIT2, Local0)
        if (LNotEqual (Local0, 0x1))
        {
            ERR_ (1)
        }
        else
        {
            Store (DerefOf (Index (BUF2, 0)), Local0)
            if (LNotEqual (Local0, 0x08))
            {
                ERR_ (1)
            }
            else
            {
                Store ("++++++++ Bit BufferField I/O PASS", Debug)
            }
        }
 
        Store (0x1A, BYT2)
        Store (BYT2, Local0)
        if (LNotEqual (Local0, 0x1A))
        {
            ERR_ (1)
        }
        else
        {
            Store ("++++++++ Byte BufferField I/O PASS", Debug)
        }
 
        Store (0x1234, WRD2)
        Store (WRD2, Local0)
        if (LNotEqual (Local0, 0x1234))
        {
            ERR_ (1)
        }
        else
        {
            Store ("++++++++ Word BufferField I/O PASS", Debug)
        }
 
        Store (0x123, FLD2)
        Store (FLD2, Local0)
        if (LNotEqual (Local0, 0x123))
        {
            ERR_ (1)
        }
        else
        {
            Store ("++++++++ 12-bit BufferField I/O PASS", Debug)
        }
 
        Store (0x12345678, DWD2)
        Store (DWD2, Local0)
        if (LNotEqual (Local0, 0x12345678))
        {
            ERR_ (1)
        }
        else
        {
            Store ("++++++++ Dword BufferField I/O PASS", Debug)
        }
 
        Store (0x1234567887654321, QWD2)
        Store (QWD2, Local0)
        if (LNotEqual (Local0, 0x1234567887654321))
        {
            ERR_ (1)
        }
        else
        {
            Store ("++++++++ Qword BufferField I/O PASS", Debug)
        }
    }
 
 
    /* Field execution */
 
    Method (FLDX)
    {
        Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
        {   //  Field:  SMEM overlay using 32-bit field elements
            SMD0,   32, //  32-bits
            SMD1,   32,     //  32-bits
            SMD2,   32,     //  32-bits
            SMD3,   32  //  32-bits
        }   //  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,   69, //  larger than an integer (32 or 64)
            SME1,   97  //  larger than an integer
        }   //  Field:  SMEM overlay using greater than 32-bit field elements
    }
 
 
    Method (MTX_, )
    {
        /* Test "Force release" of mutex on method exit */
 
        Acquire (MTXT, 0xFFFF)
        Acquire (MTXX, 0xFFFF)
 
        Store ("++++++++ Acquiring Mutex MTX2", Debug)
        Acquire (_GL_, 0xFFFF)
 
 
        Store ("++++++++ Releasing Mutex MTX2", Debug)
        Release (_GL_)
    }
 
 
    Method (OBJ2, 1)
    {
        Store ("++++++++ Creating Buffer BUFO", Debug)
        Name (BUFO, Buffer (32) {})
 
        Store ("++++++++ Creating OpRegion OPR2", Debug)
        OperationRegion (OPR2, SystemMemory, Arg0, 256)
 
        Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug)
        Field (OPR2, ByteAcc, NoLock, Preserve)
        {
            IDX2, 8,
            DAT2, 8,
            BNK2, 4
        }
 
        Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug)
        //
        // mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1
        //
        BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve)
        {
            FET0, 4,
            FET1, 3
        }
 
        Store ("++++++++ Creating IndexField", Debug)
        IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
        {
            FET2, 4,
            FET3, 3
        }
 
        Store ("++++++++ SizeOf (BUFO)", Debug)
        SizeOf (BUFO)
 
        Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug)
        Store (SizeOf (BUFO), Local0)
 
        Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug)
        Concatenate ("abd", "def", Local0)
        Store (Local0, Debug)
 
        Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug)
        Concatenate ("abd", 0x7B, Local0)
        Store (Local0, Debug)
 
        Store ("++++++++ Creating Event EVT2", Debug)
        Event (EVT2)
 
        Store ("++++++++ Creating Mutex MTX2", Debug)
        Mutex (MTX2, 0)
 
        Store ("++++++++ Creating Alias MTXA to MTX2", Debug)
        Alias (MTX2, MTXA)
 
        Store ("++++++++ Acquiring Mutex MTX2", Debug)
        Acquire (MTX2, 0xFFFF)
 
        Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug)
        Acquire (MTX2, 1)
 
        Store ("++++++++ Releasing Mutex MTX2", Debug)
        Release (MTX2)
 
        // Type 1 opcodes
 
        Store ("++++++++ Signalling Event EVT2", Debug)
        Signal (EVT2)
 
        Store ("++++++++ Resetting Event EVT2", Debug)
        Reset (EVT2)
 
        Store ("++++++++ Signalling Event EVT2", Debug)
        Signal (EVT2)
 
        Store ("++++++++ Waiting Event EVT2", Debug)
        Wait (EVT2, 0xFFFF)
 
        Store ("++++++++ Sleep", Debug)
        Sleep (100)
 
        Store ("++++++++ Stall", Debug)
        Stall (254)
 
        Store ("++++++++ NoOperation", Debug)
        Noop
 
        // Type 2 Opcodes
 
        Store ("++++++++ Return from Method OBJ2", Debug)
        return (4)
    }
 
 
    Method (NUM1, 0)
    {
        /* ADD */
 
        Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug)
        Add (0x12345678, 0x11111111, Local0)
 
        Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug)
        Store (Add (0x12345678, 0x11111111), Local1)
 
        Store ("++++++++ Checking result from ADD", Debug)
        if (LNotEqual (Local0, Local1))
        {
            ERR_ (0)
        }
 
 
        /* SUBTRACT */
 
        Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug)
        Subtract (0x87654321, 0x11111111, Local4)
 
        Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug)
        Store (Subtract (0x87654321, 0x11111111), Local5)
 
        Store ("++++++++ Checking result from SUBTRACT", Debug)
        if (LNotEqual (Local4, Local5))
        {
            ERR_ (0)
        }
 
 
        /* MULTIPLY */
 
        Store ("++++++++ Multiply (33, 10, Local6)", Debug)
        Multiply (33, 10, Local6)
 
        Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug)
        Store (Multiply (33, 10), Local7)
 
 
        Store ("++++++++ Checking result from MULTIPLY", Debug)
        if (LNotEqual (Local6, Local7))
        {
            ERR_ (0)
        }
 
 
        /* DIVIDE */
 
        Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug)
        Divide (100, 9, Local1, Local2)
 
        Store ("++++++++ Store (Divide (100, 9), Local3)", Debug)
        Store (Divide (100, 9), Local3)
 
        Store ("++++++++ Checking (quotient) result from DIVIDE", Debug)
        if (LNotEqual (Local2, Local3))
        {
            ERR_ (0)
        }
 
 
        /* INCREMENT */
 
        Store ("++++++++ Increment (Local0)", Debug)
        Store (1, Local0)
        Store (2, Local1)
        Increment (Local0)
 
        Store ("++++++++ Checking result from INCREMENT", Debug)
        if (LNotEqual (Local0, Local1))
        {
            ERR_ (0)
        }
 
 
        /* DECREMENT */
 
        Store ("++++++++ Decrement (Local0)", Debug)
        Store (2, Local0)
        Store (1, Local1)
        Decrement (Local0)
 
        Store ("++++++++ Checking result from DECREMENT", Debug)
        if (LNotEqual (Local0, Local1))
        {
            ERR_ (0)
        }
 
 
        /* TOBCD */
        /* FROMBCD */
 
        Store ("++++++++ ToBCD (0x1234, Local5)", Debug)
        ToBCD (0x1234, Local5)
 
        Store ("++++++++ FromBCD (Local5, Local6)", Debug)
        FromBCD (Local5, Local6)
 
        Store ("++++++++ Return (Local6)", Debug)
        Return (Local6)
    }
 
 
    Method (CHEK)
    {
 
        Store (3, Local0)
        Store (3, Debug)
        Store (Local0, Debug)
        Store (7, Local1)
 
        Add (Local0, Local1)
        if (LNotEqual (Local0, 3))
        {
            ERR_ (2)
        }
        if (LNotEqual (Local1, 7))
        {
            ERR_ (2)
        }
 
 
        Add (Local0, Local1, Local2)
        if (LNotEqual (Local0, 3))
        {
            ERR_ (2)
        }
        if (LNotEqual (Local1, 7))
        {
            ERR_ (2)
        }
    }
 
 
    Method (RET1)
    {
        Store (3, Local0)
        Return (Local0)
    }
 
    Method (RET2)
    {
        Return (RET1())
    }
 
    Method (RETZ)
    {
        RET2 ()
    }
 
 
    Method (BITZ)
    {
        Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug)
        FindSetLeftBit (0x00100100, Local0)
        if (LNotEqual (Local0, 21))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug)
        FindSetRightBit (0x00100100, Local1)
        if (LNotEqual (Local1, 9))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug)
        And (0xF0F0F0F0, 0x11111111, Local2)
        if (LNotEqual (Local2, 0x10101010))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug)
        NAnd (0xF0F0F0F0, 0x11111111, Local3)
        if (LNotEqual (Local3, 0xEFEFEFEF))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug)
        Or (0x11111111, 0x22222222, Local4)
        if (LNotEqual (Local4, 0x33333333))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug)
        NOr (0x11111111, 0x22222222, Local5)
        if (LNotEqual (Local5, 0xCCCCCCCC))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug)
        XOr (0x11113333, 0x22222222, Local6)
        if (LNotEqual (Local6, 0x33331111))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug)
        ShiftLeft (0x11112222, 2, Local7)
        if (LNotEqual (Local7, 0x44448888))
        {
            ERR_ (1)
        }
 
        Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug)
        ShiftRight (Local7, 2, Local7)
        if (LNotEqual (Local7, 0x11112222))
        {
            ERR_ (1)
        }
 
 
        Store ("++++++++ Not (Local0, Local1)", Debug)
        Store (0x22224444, Local0)
        Not (Local0, Local1)
        if (LNotEqual (Local0, 0x22224444))
        {
            ERR_ (2)
        }
 
        if (LNotEqual (Local1, 0xDDDDBBBB))
        {
            ERR_ (1)
        }
 
        Return (Local7)
    }
 
 
    Method (LOGS)
    {
 
        Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug)
        Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)
 
        Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug)
        Store (LEqual (0xFFFFFFFF, 0x11111111), Local1)
 
        Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug)
        Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)
 
        Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug)
        Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)
 
        Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug)
        Store (LLess (0xFFFFFFFF, 0x11111111), Local4)
 
        Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug)
        Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)
 
        Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug)
        Store (0x00001111, Local6)
        Store (LNot (Local6), Local7)
        if (LNotEqual (Local6, 0x00001111))
        {
            ERR_ (2)
        }
 
        if (LNotEqual (Local7, 0x0))
        {
            ERR_ (1)
        }
 
 
        Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug)
        Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)
 
        Store ("++++++++ Lor (0x0, 0x1)", Debug)
        if (Lor (0x0, 0x1))
        {
            Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug)
        }
 
        return (Local7)
    }
 
 
    Method (COND)
    {
        Store ("++++++++ Store (0x4, Local0)", Debug)
        Store (0x4, Local0)
 
        Store ("++++++++ While (Local0)", Debug)
        While (Local0)
        {
            Store ("++++++++ Decrement (Local0)", Debug)
            Decrement (Local0)
        }
 
 
        Store ("++++++++ Store (0x3, Local6)", Debug)
        Store (0x3, Local6)
 
        Store ("++++++++ While (Subtract (Local6, 1))", Debug)
        While (Subtract (Local6, 1))
        {
            Store ("++++++++ Decrement (Local6)", Debug)
            Decrement (Local6)
        }
 
 
        Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
        If (LGreater (0x2, 0x1))
        {
            Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
            If (LEqual (0x11111111, 0x22222222))
            {
                Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
            }
 
            else
            {
                Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
                If (LNot (0x0))
                {
                    Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
                    If (LAnd (0xEEEEEEEE, 0x2))
                    {
                        Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
                        If (LLess (0x44444444, 0x3))
                        {
                            Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
                        }
 
                        else
                        {
                            Store ("++++++++ Exiting from nested IF/ELSE statements", Debug)
                        }
                    }
                }
            }
        }
 
 
        Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
        If (LGreater (0x2, 0x1))
        {
            Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
            If (LEqual (0x11111111, 0x22222222))
            {
                Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
            }
 
            else
            {
                Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
                If (LNot (0x0))
                {
                    Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
                    If (LAnd (0xEEEEEEEE, 0x2))
                    {
                        Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
                        If (LLess (0x44444444, 0x3))
                        {
                            Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
                        }
 
                        else
                        {
                            Store ("++++++++ Returning from nested IF/ELSE statements", Debug)
                            Return (Local6)
                        }
                    }
                }
            }
        }
 
    }
 
 
    Method (REFS)
    {
        Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7})
 
        Name (NEST, Package ()
        {
            Package ()
            {
                0x01, 0x02, 0x03, 0x04, 0x05, 0x06
            },
            Package ()
            {
                0x11, 0x12, 0x12, 0x14, 0x15, 0x16
            }
        })
 
    /* Parser thinks this is a method invocation!! */
 
        Store (RefOf (MAIN), Local5)
 
        // For this to work, ABCD must NOT exist.
 
        Store (CondRefOf (ABCD, Local0), Local1)
        if (LNotEqual (Local1, 0))
        {
            ERR_ (2)
        }
 
        Store (CondRefOf (BBUF, Local0), Local1)
        if (LNotEqual (Local1, Ones))
        {
            ERR_ (2)
        }
 
        Store (DeRefOf (Index (BBUF, 3)), Local6)
        if (LNotEqual (Local6, 0xB3))
        {
            ERR_ (2)
        }
 
        Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0)
        if (LNotEqual (Local0, 0x14))
        {
            ERR_ (2)
        }
 
 
        Store (0x11223344, Local0)
        Store (RefOf (Local0), Local1)
 
        Store (DerefOf (Local1), Local2)
        If (LNotEqual (Local2, 0x11223344))
        {
            ERR_ (2)
        }
 
 
    /* 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)
    {
        Name(STAT,Package(4){})
        Store(0x44443333,Index(STAT,0))
    }
 
//=================================================================
//=================================================================
//===================== iPCO TESTS ================================
//=================================================================
//=================================================================
//
//
// test IfElseOp.asl
//
//  test for IfOp and ElseOp, including validation of object stack cleanup
//
    Device (IFEL)
    {
        Name (DWRD, 1)
        Name (RSLT, 0)
 
        //  IFNR control method executes IfOp branch with NO nested Return
        //  and no Else branch
        Method (IFNR)
        {
            Store (DWRD, RSLT)
            If (LEqual (DWRD, 1))
            {
                Store (0, RSLT)
            }
        }   //  IFNR
 
        //  NINR control method does not execute If branch and has no Else branch
        Method (NINR)
        {
            Store (0, RSLT)
            If (LNotEqual (DWRD, 1))
            {
                Store (DWRD, RSLT)
            }
        }   //  NINR
 
        //  IENR control method executes IfOp branch with NO nested Return
        Method (IENR)
        {
            If (LEqual (DWRD, 1))
            {
                Store (0, RSLT)
            }
            Else
            {
                Store (DWRD, RSLT)
            }
        }   //  IENR
 
        //  ELNR control method executes ElseOp branch with NO nested Return
        Method (ELNR)
        {
            If (LNotEqual (DWRD, 1))
            {
                Store (DWRD, RSLT)
            }
            Else
            {
                Store (0, RSLT)
            }
        }   //  ELNR
 
        //  IFRT control method executes IfOp branch with nested Return with
        //  no Else branch
        Method (IFRT)
 
        {
            If (LEqual (DWRD, 1))
            {
                Return (0)
            }
            Return (DWRD)
        }   //  IFRT
 
        //  IERT control method executes IfOp branch with nested Return with
        //  Else branch
        Method (IERT)
        {
            If (LEqual (DWRD, 1))
            {
                Return (0)
            }
            Else
            {
                Return (DWRD)
            }
        }   //  IERT
 
        //  ELRT control method executes ElseOp branch with nested Return
        Method (ELRT)
        {
            If (LNotEqual (DWRD, 1))
            {
                Return (DWRD)
            }
            Else
            {
                Return (0)
            }
        }   //  ELRT
 
        Method (TEST)
        {
            Store ("++++++++ IfElseOp Test", Debug)
 
            //  IfOp with NO return value
            IFNR()
            If (LNotEqual (RSLT, 0))
            {
                Return (RSLT)
            }
 
            //  IfOp with NO return value
            NINR()
            If (LNotEqual (RSLT, 0))
            {
                Return (RSLT)
            }
 
            //  IfOp with NO return value
            IENR()
            If (LNotEqual (RSLT, 0))
            {
                Return (RSLT)
            }
 
            //  ElseOp with NO return value
            ELNR()
            If (LNotEqual (RSLT, 0))
            {
                Return (RSLT)
            }
 
            //  IfOp with return value
            Store (IFRT, RSLT)
            If (LNotEqual (RSLT, 0))
            {
                Return (RSLT)
            }
 
            //  IfOp with return value
            Store (IERT, RSLT)
            If (LNotEqual (RSLT, 0))
            {
                Return (RSLT)
            }
 
            //  ElseOp with return value
            Store (ELRT, RSLT)
            If (LNotEqual (RSLT, 0))
            {
                Return (RSLT)
            }
 
            Return (0)
        }   //  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)
        {
            Store ("++++++++ NoSave Test", Debug)
 
            Name (WRD, 0x1234)
 
            //
            //  Begin test of nested operators without saving results
            //
 
            //  Test If (And ()) with no save of And result
            If (And (3, 1, ))
            {
                Store (1, WRD)  //  pass -- just do something
            }
            else
            {
                Return (1)      //  fail
            }
 
            //  Test If (And ()) with no save of And result
            If (And (4, 1, ))
            {
                Return (2)      //  fail
            }
            else
            {
                Store (2, WRD)  //  pass -- just do something
            }
 
 
            //  Test If (NAnd ()) with no save of NAnd result
            If (NAnd (3, 1, ))
            {
                Store (3, WRD)  //  pass -- just do something
            }
            else
            {
                Return (3)      //  fail
            }
 
            //  Test If (NAnd ()) with no save of NAnd result
            If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, ))
            {
                Return (4)      // fail
            }
            else
            {
                Store (4, WRD)  //  pass -- just do something
            }
 
 
            //  Test If (NOr ()) with no save of NOr result
            If (NOr (0, 1, ))
            {
                Store (5, WRD)  //  pass -- just do something
            }
            else
            {
                Return (5)      //  fail
            }
 
            //  Test If (NOr ()) with no save of NOr result
            If (NOr (0xFFFFFFFE, 1, ))
            {
                Return (6)      // fail
            }
            else
            {
                Store (6, WRD)  //  pass -- just do something
            }
 
 
            //  Test If (Not ()) with no save of Not result
            If (Not (1, ))
            {
                Store (7, WRD)  //  pass -- just do something
            }
            else
            {
                Return (7)      //  fail
            }
 
            //  Test If (Not ()) with no save of Not result
            If (Not (0xFFFFFFFF, ))
            {
                Return (8)      // fail
            }
            else
            {
                Store (8, WRD)  //  pass -- just do something
            }
 
 
            //  Test If (Or ()) with no save of Or result
            If (Or (3, 1, ))
            {
                Store (9, WRD)  //  pass -- just do something
            }
            else
            {
                Return (9)      //  fail
            }
 
            //  Test If (Or ()) with no save of Or result
            If (Or (0, 0, ))
            {
                Return (10)     //  fail
            }
            else
            {
                Store (10, WRD) //  pass -- just do something
            }
 
 
            //  Test If (XOr ()) with no save of XOr result
            If (XOr (3, 1, ))
            {
                Store (11, WRD) //  pass -- just do something
            }
            else
            {
                Return (11)     // fail
            }
 
            //  Test If (XOr ()) with no save of XOr result
            If (XOr (3, 3, ))
            {
                Return (12)     // fail
            }
            else
            {
                Store (12, WRD) //  pass -- just do something
            }
 
 
            //
            //  Begin test of logical operators with no destination operands
            //
 
            //  Test If (LAnd ()) with no save of LAnd result
            If (LAnd (3, 3))
            {
                Store (21, WRD) //  pass -- just do something
            }
            else
            {
                Return (21)     // fail
            }
 
            //  Test If (LAnd ()) with no save of LAnd result
            If (LAnd (3, 0))
            {
                Return (22)     // fail
            }
            else
            {
                Store (22, WRD) //  pass -- just do something
            }
 
            //  Test If (LAnd ()) with no save of LAnd result
            If (LAnd (0, 3))
            {
                Return (23)     //  fail
            }
            else
            {
                Store (23, WRD) //  pass -- just do something
            }
 
            //  Test If (LAnd ()) with no save of LAnd result
            If (LAnd (0, 0))
            {
                Return (24)     //  fail
            }
            else
            {
                Store (24, WRD) //  pass -- just do something
            }
 
 
            //  Test If (LEqual ()) with no save of LEqual result
            If (LEqual (3, 3))
            {
                Store (31, WRD) //  pass -- just do something
            }
            else
            {
                Return (31)     //  fail
            }
 
            //  Test If (LEqual ()) with no save of LEqual result
            If (LEqual (1, 3))
            {
                Return (32)     //  fail
            }
            else
            {
                Store (32, WRD) //  pass -- just do something
            }
 
 
            //  Test If (LGreater ()) with no save of LGreater result
            If (LGreater (3, 1))
            {
                Store (41, WRD) //  pass -- just do something
            }
            else
            {
                Return (41)     //  fail
            }
 
            //  Test If (LGreater ()) with no save of LGreater result
            If (LGreater (4, 4))
            {
                Return (42)     //  fail
            }
            else
            {
                Store (42, WRD) //  pass -- just do something
            }
 
            //  Test If (LGreater ()) with no save of LGreater result
            If (LGreater (1, 4))
            {
                Return (43)     //  fail
            }
            else
            {
                Store (43, WRD) //  pass -- just do something
            }
 
            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
            If (LGreaterEqual (3, 1))
            {
                Store (44, WRD) //  pass -- just do something
            }
            else
            {
                Return (44)     //  fail
            }
 
            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
            If (LGreaterEqual (3, 3))
            {
                Store (45, WRD) //  pass -- just do something
            }
            else
            {
                Return (45)     //  fail
            }
 
            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
            If (LGreaterEqual (3, 4))
            {
                Return (46)     //  fail
            }
            else
            {
                Store (46, WRD) //  pass -- just do something
            }
 
 
            //  Test If (LLess ()) with no save of LLess result
            If (LLess (1, 3))
            {
                Store (51, WRD) //  pass -- just do something
            }
            else
            {
                Return (51)     //  fail
            }
 
            //  Test If (LLess ()) with no save of LLess result
            If (LLess (2, 2))
            {
                Return (52)     //  fail
            }
            else
            {
                Store (52, WRD) //  pass -- just do something
            }
 
            //  Test If (LLess ()) with no save of LLess result
            If (LLess (4, 2))
            {
                Return (53)     //  fail
            }
            else
            {
                Store (53, WRD) //  pass -- just do something
            }
 
 
            //  Test If (LLessEqual ()) with no save of LLessEqual result
            If (LLessEqual (1, 3))
            {
                Store (54, WRD) //  pass -- just do something
            }
            else
            {
                Return (54)     //  fail
            }
 
            //  Test If (LLessEqual ()) with no save of LLessEqual result
            If (LLessEqual (2, 2))
            {
                Store (55, WRD) //  pass -- just do something
            }
            else
            {
                Return (55)     //  fail
            }
 
            //  Test If (LLessEqual ()) with no save of LLessEqual result
            If (LLessEqual (4, 2))
            {
                Return (56)     //  fail
            }
            else
            {
                Store (56, WRD) //  pass -- just do something
            }
 
 
            //  Test If (LNot ()) with no save of LNot result
            If (LNot (0))
            {
                Store (61, WRD) //  pass -- just do something
            }
            else
            {
                Return (61)     //  fail
            }
 
            //  Test If (LNot ()) with no save of LNot result
            If (LNot (1))
            {
                Return (62)     //  fail
            }
            else
            {
                Store (62, WRD) //  pass -- just do something
            }
 
 
            //  Test If (LNotEqual ()) with no save of LNotEqual result
            If (LNotEqual (3, 3))
            {
                Return (63)     //  fail
            }
            else
            {
                Store (63, WRD) //  pass -- just do something
            }
 
            //  Test If (LNotEqual ()) with no save of LNotEqual result
            If (LNotEqual (1, 3))
            {
                Store (64, WRD) //  pass -- just do something
            }
            else
            {
                Return (64)     //  fail
            }
 
 
            //  Test If (LOr ()) with no save of LOr result
            If (LOr (3, 1))
            {
                Store (71, WRD) //  pass -- just do something
            }
            else
            {
                Return (71)     //  fail
            }
 
            //  Test If (LOr ()) with no save of LOr result
            If (LOr (0, 1))
            {
                Store (72, WRD) //  pass -- just do something
            }
            else
            {
                Return (72)     //  fail
            }
 
            //  Test If (LOr ()) with no save of LOr result
            If (LOr (3, 0))
            {
                Store (73, WRD) //  pass -- just do something
            }
            else
            {
                Return (73)     //  fail
            }
 
            //  Test If (LOr ()) with no save of LOr result
            If (LOr (0, 0))
            {
                Return (74)     //  fail
            }
            else
            {
                Store (74, WRD) //  pass -- just do something
            }
 
            Return (0)
        }   //  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, 0x100, 2)
        Field (SIO, ByteAcc, NoLock, Preserve)
        {
            INDX,   8,
            DATA,   8
        }
        IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
        {
            AccessAs (ByteAcc, 0),
            IFE0,   8,
            IFE1,   8,
            IFE2,   8,
            IFE3,   8,
            IFE4,   8,
            IFE5,   8,
            IFE6,   8,
            IFE7,   8,
            IFE8,   8,
            IFE9,   8,
        }
 
        Method (TEST)
        {
            Store ("++++++++ IndxFld Test", Debug)
 
            Store (IFE0, Local0)
            Store (IFE1, Local1)
            Store (IFE2, Local2)
 
            Return (0)
        }   //  TEST
    }   //  IDXF
 
//
// test NestdLor.asl
//
    Scope (\_SB)    //  System Bus
    {   //  _SB system bus
 
        Name (ZER0, 0)
        Name (ZER1, 0)
        Name (ZER2, 0)
        Name (ONE0, 1)
 
        Device (NSTL)
        {
            Method (TEST)
            {
                Store ("++++++++ NestdLor Test", Debug)
 
                If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0))))
                {   //  Indicate Pass
                    Store (0x00, Local0)
                }
 
                Else
                {   //  Indicate Fail
                    Store (0x01, Local0)
                }
 
                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)
        {
            Return (Arg0)
        }
 
        Method (RBUF)
        {   //  RBUF: Return Buffer from local variable
            Name (ABUF, Buffer() {"ARBITRARY_BUFFER"})
 
            //  store local buffer ABUF into Local0
            Store (ABUF, Local0)
 
            //  save Local0 object type value into Local1
            Store (ObjectType (Local0), Local1)
 
            //  validate Local0 is a Buffer
            If (LNotEqual (Local1, 3))  //  Buffer type is 3
            {
                Return (1)      //  failure
            }
 
            //  store value returned by control method SUBR into Local0
            Store (SUBR (ABUF), Local0)
 
            //  save Local0 object type value into Local1
            Store (ObjectType (Local0), Local1)
 
            //  validate Local0 is a Buffer
            If (LNotEqual (Local1, 3))  //  Buffer type is 3
            {
                Return (2)      //  failure
            }
 
            //  allocate buffer using Local1 as buffer size (run-time evaluation)
            Store (5, Local1)
            Name (BUFR, Buffer(Local1) {})
 
            //  store value returned by control method SUBR into Local0
            Store (SUBR (BUFR), Local0)
 
            //  save Local0 object type value into Local1
            Store (ObjectType (Local0), Local1)
 
            //  validate Local0 is a Buffer
            If (LNotEqual (Local1, 3))  //  Buffer type is 3
            {
                Return (3)      //  failure
            }
 
            //  store BUFR Buffer into Local0
            Store (BUFR, Local0)
 
            //  save Local0 object type value into Local1
            Store (ObjectType (Local0), Local1)
 
            //  validate Local0 is a Buffer
            If (LNotEqual (Local1, 3))  //  Buffer type is 3
            {
                Return (4)      //  failure
            }
 
 
            //  return Local0 Buffer
            Return (Local0)
        }   //  RBUF
 
        Method (TEST)
        {
            Store ("++++++++ RetBuf Test", Debug)
 
            //  store RBUF Buffer return value into Local0
            Store (RBUF, Local0)
 
            //  save Local0 object type value into Local1
            Store (ObjectType (Local0), Local1)
 
            //  validate Local0 is a Buffer
            If (LNotEqual (Local1, 3))  //  Buffer type is 3
            {
                Return (10)     //  failure
            }
            Else
            {
                Return (0)      //  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)
        {
            Store ("Method GPE2._L03 invoked", Debug)
            Return ()
        }
 
        Method (_E05)
        {
            Store ("Method GPE2._E05 invoked", Debug)
            Return ()
        }
    }
 
    Device (PRW2)
    {
        Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3})
    }
 
 
    Scope (\_GPE)
    {
        Name (ACST, 0xFF)
 
        Method (_L08)
        {
            Store ("Method _GPE._L08 invoked", Debug)
            Return ()
        }
 
        Method (_E09)
        {
            Store ("Method _GPE._E09 invoked", Debug)
            Return ()
        }
 
        Method (_E11)
        {
            Store ("Method _GPE._E11 invoked", Debug)
            Notify (\PRW1, 2)
        }
 
        Method (_L22)
        {
            Store ("Method _GPE._L22 invoked", Debug)
            Return ()
        }
 
        Method (_L33)
        {
            Store ("Method _GPE._L33 invoked", Debug)
            Return ()
        }
 
        Method (_E64)
        {
            Store ("Method _GPE._E64 invoked", Debug)
            Return ()
        }
 
    }   //  _GPE
 
    Device (PRW1)
    {
        Name (_PRW, Package(2) {0x11, 3})
    }
 
    Device (PWRB)
    {
        Name (_HID, EISAID("PNP0C0C"))
        Name (_PRW, Package(2) {0x33, 3})
    }
 
 
    Scope (\_SB)    //  System Bus
    {   //  _SB system bus
 
        Device (ACAD)
        {   //  ACAD:   AC adapter device
            Name (_HID, "ACPI0003") //  AC adapter device
 
            Name (_PCL, Package () {\_SB})
 
            OperationRegion (AREG, SystemIO, 0x0372, 2)
            Field (AREG, ByteAcc, NoLock, Preserve)
            {
                AIDX,   8,
                ADAT,   8
            }
            IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
            {
                     ,  1,  //  skips
                ACIN,   1,
                     ,  2,  //  skips
                CHAG,   1,
                     ,  3,  //  skips
                     ,  7,  //  skips
                ABAT,   1,
            }   //  IndexField
 
            Method (_PSR)
            {
                Store (\_GPE.ACST, Local0)
                Store (ACIN, Local1)
                If (LNotEqual (\_GPE.ACST, Local1))
                {
                    Store (Local1, \_GPE.ACST)
                    // 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)
            {
                Return (0x0F)
            }
 
            Method (_INI)
            {
                Store (ACIN, \_GPE.ACST)
            }
        }   //  ACAD:   AC adapter device
 
        //  test implicit return from control method
        Method (DIS_, 1)
        {
            Store (Arg0, Local0)
        }
 
        Device (RTLV)
        {
            //  test implicit return inside nested if with explicit return of Lvalue
            Method (_DCK, 1)
            //  Arg0:   1 == dock, 0 == undock
            {
                If (Arg0)
                {   //  dock
                    Store (0x87, Local0)
 
                    If (Local0)
                    {
                        DIS_ (0x23)
                        Return (1)
                    }
 
                    Return (0)
                }   //  dock
                Else
                {   //  undock
                    Store (Arg0, Local0)
 
                    If (Local0)
                    {
                        DIS_ (0x23)
                        Return (1)
                    }
 
                    Return (0)
                }   //  undock
            }   //  _DCK control method
 
            Method (TEST)
            {
                Store ("++++++++ RetLVal Test", Debug)
 
                //  store _PSR return value into Local0
                Store (\_SB_.ACAD._PSR, Local0)
 
                //  save Local0 object type value into Local1
                Store (ObjectType (Local0), Local1)
 
                //  validate Local0 is a Number
                If (LNotEqual (Local1, 1))  //  Number/Integer type is 1
                {
                    Return (1)      //  failure
                }
 
                //  test implicit return inside nested if with explicit return of Lvalue
                Store (_DCK (1), Local2)
 
                //  save Local2 object type value into Local3
                Store (ObjectType (Local2), Local3)
 
                //  validate Local2 is a Number
                If (LNotEqual (Local3, 1))  //  Number/Integer type is 1
                {
                    Return (2)      //  failure
                }
 
                If (LNotEqual (Local2, 1))
                {
                    Return (3)      //  failure
                }
 
                Return (0)  //  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
            Name (_UID, 1)
        }
        Device(LNKB)
        {
            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
            Name (_UID, 2)
        }
        Device(LNKC)
        {
            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
            Name (_UID, 3)
        }
        Device(LNKD)
        {
            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
            Name (_UID, 4)
        }
 
        Device (PCI1)
        {   //  PCI1:   Root PCI Bus
            Name (_HID, "PNP0A03")  //  Need _HID for root device (String format)
            Name (_ADR,0x00000000)
            Name (_CRS,0)
 
            Name (_PRT, Package ()
            {
                Package () {0x0004ffff, 0, LNKA, 0},            //  Slot 1, INTA
                Package () {0x0004ffff, 1, LNKB, 0},            //  Slot 1, INTB
                Package () {0x0004ffff, 2, LNKC, 0},            //  Slot 1, INTC
                Package () {0x0004ffff, 3, LNKD, 0},            //  Slot 1, INTD
                Package () {0x0005ffff, 0, \_SB_.LNKB, 0},  //  Slot 2, INTA
                Package () {0x0005ffff, 1, \_SB_.LNKC, 0},  //  Slot 2, INTB
                Package () {0x0005ffff, 2, \_SB_.LNKD, 0},  //  Slot 2, INTC
                Package () {0x0006ffff, 3, \_SB_.LNKA, 0},  //  Slot 2, INTD
                Package () {0x0006ffff, 0, LNKC, 0},            //  Slot 3, INTA
                Package () {0x0006ffff, 1, LNKD, 0},            //  Slot 3, INTB
                Package () {0x0006ffff, 2, LNKA, 0},            //  Slot 3, INTC
                Package () {0x0006ffff, 3, LNKB, 0},            //  Slot 3, INTD
            })
 
            Device (PX40)
            {   // Map f0 space, Start PX40
                Name (_ADR,0x00070000)  //  Address+function.
            }
        }   //  PCI0:   Root PCI Bus
 
        Device (RETP)
        {
            Method (RPKG)
            {   //  RPKG: Return Package from local variable
 
                //  store _PRT package into Local0
                Store (\_SB_.PCI1._PRT, Local0)
 
                //  return Local0 Package
                Return (Local0)
            }   //  RPKG
 
            Method (TEST)
            {
                Store ("++++++++ RetPkg Test", Debug)
 
                //  store RPKG package return value into Local0
                Store (RPKG, Local0)
 
                //  save Local0 object type value into Local1
                Store (ObjectType (Local0), Local1)
 
                //  validate Local0 is a Package
                If (LNotEqual (Local1, 4))  //  Package type is 4
                    {   Return (1)  }   //  failure
                Else
                    {   Return (0)  }   //  success
            }   //  TEST
        }   //  RETP
    } // _SB_
 
//
// test WhileRet.asl
//
//  WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp.
//
    Device (WHLR)
    {
        Name (LCNT, 0)
        Method (WIR)
        {   //  WIR:    control method that returns inside of IfOp inside of WhileOp
            While (LLess (LCNT, 4))
            {
                    If (LEqual (LCNT, 2))
                    {
                        Return (0)
                    }
 
                Increment (LCNT)
            }
 
            Return (LCNT)
        }   //  WIR:    control method that returns inside of IfOp inside of WhileOp
 
        Method (TEST)
        {
            Store ("++++++++ WhileRet Test", Debug)
 
            Store (WIR, Local0)
 
            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, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,  //  8-bit BYTE
        }// 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, 0x0000)
 
        //And with DWord Data
        Name (DWD1, 0xffffffff)
        Name (DWD2, 0xffffffff)
        Name (DRSL, 0x00000000)
 
        Method (ANDP)
        {
            //Check with 1 And 1 on byte data
            And(BYT1, BYT2, BRSL)
            if(LNotEqual(BRSL,0xff))
            {Return(1)}
 
            //Check with 1 And 1 on Word data
            And(WRD1, WRD2, WRSL)
            if(LNotEqual(WRSL,0xffff))
            {
                Return (1)      //  failure
            }
 
            //Check with 1 And 1 Dword
            And(DWD1, DWD2, DRSL)
            if(LNotEqual(DRSL,0xffffffff))
            {
                Return (1)      //  failure
            }
 
            //Check with 0 And 0 on byte data
            Store(0x00,BYT1)
            Store(0x00,BYT2)
            Store(0x00,BRSL)
            And(BYT1, BYT2, BRSL)
            if(LNotEqual(BRSL,0x00))
            {
                Return (1)      //  failure
            }
 
            //Check with 0 And 0 on Word data
            Store (0x0000,WRD1)
            Store (0x0000,WRD2)
            Store (0x0000,WRSL)
            And(WRD1, WRD2, WRSL)
            if(LNotEqual(WRSL,0x0000))
            {
                Return (1)      //  failure
            }
 
            //Check with 0 And 0 Dword
            Store (0x00000000,DWD1)
            Store (0x00000000,DWD2)
            Store (0x00000000,DRSL)
            And(DWD1, DWD2, DRSL)
            if(LNotEqual(DRSL,0x00000000))
            {
                Return (1)      //  failure
            }
 
 
            //Check with 1 And 0 on byte data
            Store(0x55,BYT1)
            Store(0xAA,BYT2)
            Store(0x00,BRSL)
            And(BYT1, BYT2, BRSL)
            if(LNotEqual(BRSL,0x00))
            {
                Return (1)      //  failure
            }
 
            //Check with 1 And 0 on Word data
            Store (0x5555,WRD1)
            Store (0xAAAA,WRD2)
            Store (0x0000,WRSL)
            And(WRD1, WRD2, WRSL)
            if(LNotEqual(WRSL,0x0000))
            {
                Return (1)      //  failure
            }
 
            //Check with 1 And 0 on Dword
            Store (0x55555555,DWD1)
            Store (0xAAAAAAAA,DWD2)
            Store (0x00000000,DRSL)
            And(DWD1, DWD2, DRSL)
            if(LNotEqual(DRSL,0x00000000))
            {
                Return (1)      //  failure
            }
 
            Store (0x1FFF, TOUD)
            Store (TOUD, Local0)
            if(LNotEqual(Local0,0x1FFF))
            {
                Return (1)      //  failure
            }
 
            //TBD- Do We need to check for system memory data also for each test case ??
 
            Return(0)
 
        }//ANDP
 
        Method (OROP)
        {
 
            //Check with 1 Ored with 1 on byte data
            Store(0xff,BYT1)
            Store(0xff,BYT2)
            Store(0x00,BRSL)
            Or(BYT1, BYT2, BRSL)
            if(LNotEqual(BRSL,0xff))
            {
                Return (1)      //  failure
            }
 
 
            //Check with 1 Ored with 1 on Word data
            Store(0xffff,WRD1)
            Store(0xffff,WRD2)
            Store(0x0000,WRSL)
            Or(WRD1, WRD2, WRSL)
            if(LNotEqual(WRSL,0xffff))
            {
                Return (1)      //  failure
            }
 
            //Check with 1 Ored with 1 on Dword data
            Store(0xffffffff,DWD1)
            Store(0xffffffff,DWD2)
            Store(0x00000000,DRSL)
            Or(DWD1, DWD2, DRSL)
            if(LNotEqual(DRSL,0xffffffff))
            {
                Return (1)      //  failure
            }
 
            //Check with 0 Ored with 0 on byte data
            Store(0x00,BYT1)
            Store(0x00,BYT2)
            Store(0x00,BRSL)
            Or(BYT1, BYT2, BRSL)
            if(LNotEqual(BRSL,0x00))
            {
                Return (1)      //  failure
            }
 
            //Check with 0 Ored with 0 on Word data
            Store (0x0000,WRD1)
            Store (0x0000,WRD2)
            Store (0x0000,WRSL)
            Or(WRD1, WRD2, WRSL)
            if(LNotEqual(WRSL,0x0000))
            {
                Return (1)      //  failure
            }
 
            //Check with 0 Ored with  0 Dword data
            Store (0x00000000,DWD1)
            Store (0x00000000,DWD2)
            Store (0x00000000,DRSL)
            Or(DWD1, DWD2, DRSL)
            if(LNotEqual(DRSL,0x00000000))
            {
                Return (1)      //  failure
            }
 
 
            //Check with 1 Ored with 0 on byte data
            Store(0x55,BYT1)
            Store(0xAA,BYT2)
            Store(0x00,BRSL)
            Or(BYT1, BYT2, BRSL)
            if(LNotEqual(BRSL,0xff))
            {
                Return (1)      //  failure
            }
 
            //Check with 1 Ored with 0 on Word data
            Store (0x5555,WRD1)
            Store (0xAAAA,WRD2)
            Store (0x0000,WRSL)
            Or(WRD1, WRD2, WRSL)
            if(LNotEqual(WRSL,0xffff))
            {
                Return (1)      //  failure
            }
 
            //Check with 1 Ored with 0 on Dword data
            Store (0x55555555,DWD1)
            Store (0xAAAAAAAA,DWD2)
            Store (0x00000000,DRSL)
            Or(DWD1, DWD2, DRSL)
            if(LNotEqual(DRSL,0xffffffff))
            {
                Return (1)      //  failure
            }
 
            //TBD - Do We need to check for system memory data also for each test case ??
 
            Return(0)
 
        }//OROP
 
        Method(TEST)
        {
            Store ("++++++++ AndOrOp Test", Debug)
 
            Name(RSLT,1)
            //Call Andop method
            Store(ANDP,RSLT)
            if(LEqual(RSLT,1))
            {
                Return (RSLT)
            }
 
            //Call OrOp Method
            Store(OROP,RSLT)
            if(LEqual(RSLT,1))
            {
                Return(RSLT)
            }
 
            //
            // Return original conditions to allow iterative execution
            //
            Store(0xff,BYT1)
            Store(0xff,BYT2)
            Store(0x00,BRSL)
            Store (0xffff,WRD1)
            Store (0xffff,WRD2)
            Store (0x0000,WRSL)
            Store (0xffffffff,DWD1)
            Store (0xffffffff,DWD2)
            Store (0x00000000,DRSL)
 
            Return(0)
        }   //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,0)
 
        Method (BK1)
        {
            BreakPoint
            Return(0)
        }
 
        Method (TEST)
        {
            Store ("++++++++ BreakPnt Test", Debug)
 
            Store(0,CNT0)
 
            //Check BreakPoint statement
            While(LLess(CNT0,10))
            {
                Increment(CNT0)
            }
 
            //Check the BreakPoint statement
            If(LEqual(CNT0,10))
            {
    //            BreakPoint
                Return(0)
            }
 
            //failed
            Return(1)
        }
    }
 
//
// test AddSubOp.asl
//
    Device (ADSU)
    {
        //  create System Memory Operation Region and field overlays
        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,  //  8-bit BYTE
        }   //  Field(RAM)
 
        Method (TEST)
        {
            Store ("++++++++ AddSubOp Test", Debug)
 
            Name (DWRD, 0x12345678)
            Name (WRD, 0x1234)
            Name (BYT, 0x12)
 
            //  Test AddOp with DWORD data
            Store (0x12345678, DWRD)
            Add (DWRD, 7, DWRD)
            If (LNotEqual (DWRD, 0x1234567F))
                {   Return (DWRD)   }
 
            //  Test AddOp with WORD data
            Add (WRD, 5, WRD)
            If (LNotEqual (WRD, 0x1239))
                {   Return (WRD)    }
 
            //  Test AddOp with BYTE data
            Add (BYT, 3, BYT)
            If (LNotEqual (BYT, 0x15))
                {   Return (BYT)    }
 
            //  Test SubtractOp with DWORD data
            Subtract (DWRD, 7, DWRD)
            If (LNotEqual (DWRD, 0x12345678))
                {   Return (DWRD)   }
 
            //  Test SubtractOp with WORD data
            Subtract (WRD, 3, WRD)
            If (LNotEqual (WRD, 0x1236))
                {   Return (WRD)    }
 
            //  Test SubtractOp with BYTE data
            Subtract (BYT, 3, BYT)
            If (LNotEqual (BYT, 0x12))
                {   Return (BYT)    }
 
 
            //  test AddOp with DWORD SystemMemory OpRegion
            Store (0x01234567, SMDW)
            Add (SMDW, 8, SMDW)
            If (LNotEqual (SMDW, 0x0123456F))
                {   Return (SMDW)   }
 
            //  test SubtractOp with DWORD SystemMemory OpRegion
            Subtract (SMDW, 7, SMDW)
            If (LNotEqual (SMDW, 0x01234568))
                {   Return (SMDW)   }
 
 
            //  test AddOp with WORD SystemMemory OpRegion
            Store (0x0123, SMWD)
            Add (SMWD, 6, SMWD)
            If (LNotEqual (SMWD, 0x0129))
                {   Return (SMWD)   }
 
            //  test SubtractOp with WORD SystemMemory OpRegion
            Subtract (SMWD, 5, SMWD)
            If (LNotEqual (SMWD, 0x0124))
                {   Return (SMWD)   }
 
 
            //  test AddOp with BYTE SystemMemory OpRegion
            Store (0x01, SMBY)
            Add (SMBY, 4, SMBY)
            If (LNotEqual (SMBY, 0x05))
                {   Return (SMBY)   }
 
            //  test SubtractOp with BYTE SystemMemory OpRegion
            Subtract (SMBY, 3, SMBY)
            If (LNotEqual (SMBY, 0x02))
                {   Return (SMBY)   }
 
            Return (0)
        }   //  TEST
    }   //  ADSU
 
//
// test IncDecOp.asl
//
    Device (INDC)
    {
        //  create System Memory Operation Region and field overlays
        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,  //  8-bit BYTE
        }   //  Field(RAM)
 
        Method (TEST)
        {
            Store ("++++++++ IncDecOp Test", Debug)
 
            Name (DWRD, 0x12345678)
            Name (WRD, 0x1234)
            Name (BYT, 0x12)
 
            //  Test IncrementOp with DWORD data
            Store (0x12345678, DWRD)
            Increment (DWRD)
            If (LNotEqual (DWRD, 0x12345679))
                {   Return (DWRD)   }
 
            //  Test IncrementOp with WORD data
            Increment (WRD)
            If (LNotEqual (WRD, 0x1235))
                {   Return (WRD)    }
 
            //  Test IncrementOp with BYTE data
            Increment (BYT)
            If (LNotEqual (BYT, 0x13))
                {   Return (BYT)    }
 
            //  Test DecrementOp with DWORD data
            Decrement (DWRD)
            If (LNotEqual (DWRD, 0x12345678))
                {   Return (DWRD)   }
 
            //  Test DecrementOp with WORD data
            Decrement (WRD)
            If (LNotEqual (WRD, 0x1234))
                {   Return (WRD)    }
 
            //  Test DecrementOp with BYTE data
            Decrement (BYT)
            If (LNotEqual (BYT, 0x12))
                {   Return (BYT)    }
 
 
            //  test IncrementOp with DWORD SystemMemory OpRegion
            Store (0x01234567, SMDW)
            Increment (SMDW)
            If (LNotEqual (SMDW, 0x01234568))
                {   Return (SMDW)   }
 
            //  test DecrementOp with DWORD SystemMemory OpRegion
            Decrement (SMDW)
            If (LNotEqual (SMDW, 0x01234567))
                {   Return (SMDW)   }
 
 
            //  test IncrementOp with WORD SystemMemory OpRegion
            Store (0x0123, SMWD)
            Increment (SMWD)
            If (LNotEqual (SMWD, 0x0124))
                {   Return (SMWD)   }
 
            //  test DecrementOp with WORD SystemMemory OpRegion
            Decrement (SMWD)
            If (LNotEqual (SMWD, 0x0123))
                {   Return (SMWD)   }
 
 
            //  test IncrementOp with BYTE SystemMemory OpRegion
            Store (0x01, SMBY)
            Increment (SMBY)
            If (LNotEqual (SMBY, 0x02))
                {   Return (SMBY)   }
 
            //  test DecrementOp with BYTE SystemMemory OpRegion
            Decrement (SMBY)
            If (LNotEqual (SMBY, 0x01))
                {   Return (SMBY)   }
 
            Return (0)
        }   //  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, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,  //  8-bit BYTE
        }// 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, 0x0000)
 
        //And with DWord Data
        Name (DWD1, 0xffffffff)
        Name (DWD2, 0xffffffff)
        Name (DRSL, 0x00000000)
 
        Name(RSLT,1)
 
        Method (ANDL,2) // Test Logical And
        {
            //test with the arguments passed
            if(LEqual(Arg0,Arg1))
            { Store(LAnd(Arg0,Arg1),RSLT)
                if(LNotEqual(Ones,RSLT))
                {Return(11)}
            }
 
            //test with he locals
            Store(Arg0,Local0)
            Store(Arg1,Local1)
 
            if(LEqual(Local0,Local1))
            {
                Store(LAnd(Local0,Local1),RSLT)
                if(LNotEqual(Ones,RSLT))
                    {Return(12)}
            }
 
            //test with BYTE data
            if(LEqual(BYT1,BYT2))
            { Store(LAnd(BYT1,BYT2),BRSL)
                if(LNotEqual(Ones,BRSL))
                {Return(13)}
            }
 
            //test with WORD data
            if(LEqual(WRD1,WRD2))
            { Store(LAnd(WRD1,WRD2),WRSL)
                if(LNotEqual(Ones,WRSL))
                {Return(14)}
            }
 
            //test with DWORD data
            if(LEqual(DWD1,DWD2))
            { Store(LAnd(DWD1,DWD2),DRSL)
                if(LNotEqual(Ones,DRSL))
                {Return(15)}
            }
 
            //Test for system memory data for each test case.
 
                Store(0xff,BYT1)
                Store(0xff,SMBY)
                Store(0x00,BRSL)
 
            //test with BYTE system memory data
            if(LEqual(BYT1,SMBY))
            { Store(LAnd(BYT1,SMBY),BRSL)
                if(LNotEqual(Ones,BRSL))
                {Return(16)}
            }
 
            Store (0xffff,WRD1)
            Store(0xffff,SMWD)
            Store(0x0000,WRSL)
            //test with WORD system memory data
            if(LEqual(WRD1,SMWD))
            { Store(LAnd(WRD1,SMWD),WRSL)
                if(LNotEqual(Ones,WRSL))
                {Return(17)}
            }
 
            Store(0x000000,DRSL)
            Store (0xffffff,DWD1)
            Store(0xffffff,SMDW)
 
            //test with DWORD system memory data
            if(LEqual(DWD1,SMDW))
            { Store(LAnd(DWD1,SMDW),DRSL)
                if(LNotEqual(Ones,DRSL))
                {Return(18)}
            }
 
            Return(0)
 
        }//ANDL
 
        //Test the LOr Operator
 
        Method (ORL_,2)
        {//ORL_
 
            //test with the arguments passed
            if(LEqual(Arg0,Arg1))
            {
                Store(LOr(Arg0,Arg1),RSLT)
                if(LNotEqual(Ones,RSLT))
                {
                    Return(21)
                }
            }
 
            //test with he locals
            Store(Arg0,Local0)
            Store(Arg1,Local1)
 
            if(LEqual(Local0,Local1))
            {
                Store(LOr(Local0,Local1),RSLT)
                if(LNotEqual(Ones,RSLT))
                    {Return(22)}
            }
 
            //Check with 1 LOred with 0 on byte data
            Store(0xff,BYT1)
            Store(0x00,BYT2)
            Store(0x00,BRSL)
 
            if(LNotEqual(BYT1, BYT2))
            {
                Store(LOr(BYT1, BYT2), BRSL)
                if(LNotEqual(Ones,BRSL))
                {Return(23)}
            }
 
            //Check with 1 LOred with 0 on WORD data
            Store(0xffff,WRD1)
            Store(0x0000,WRD2)
            Store(0x0000,WRSL)
 
            if(LNotEqual(WRD1, WRD2))
            {
                Store(LOr(WRD1, WRD2), WRSL)
                if(LNotEqual(Ones,WRSL))
                {Return(24)}
            }
 
            //Check with 1 LOred with 0 on DWORD data
            Store(0xffffffff,DWD1)
            Store(0x00000000,DWD2)
            Store(0x00000000,DRSL)
 
            if(LNotEqual(DWD1, DWD2))
            {
                Store(LOr(DWD1, DWD2), DRSL)
                if(LNotEqual(Ones,DRSL))
                {Return(25)}
            }
 
            Store(0x00,BYT1)
            Store(0xff,SMBY)
            Store(0x00,BRSL)
 
            //test with BYTE system memory data
            if(LEqual(BYT1,SMBY))
            { Store(LOr(BYT1,SMBY),BRSL)
                if(LNotEqual(Ones,BRSL))
                {Return(26)}
            }
 
            Store (0x0000,WRD1)
            Store(0xffff,SMWD)
            Store(0x0000,WRSL)
 
            //test with WORD system memory data
            if(LEqual(WRD1,SMWD))
            { Store(LOr(WRD1,SMWD),WRSL)
                if(LNotEqual(Ones,WRSL))
                {Return(27)}
            }
 
 
            Store(0x00000000,DWD1)
            Store(0xffffffff,SMDW)
            Store(0x00000000,DRSL)
 
            //test with DWORD system memory data
            if(LEqual(DWD1,SMDW))
            { Store(LAnd(DWD1,SMDW),DRSL)
                if(LNotEqual(Ones,DRSL))
                {Return(28)}
            }
            Return(0)
 
        }//ORL_
 
        //This method tests LGreater and LNot operator
        Method(LSGR,2)
        {//LSGR
 
            //Test on arguements passed
 
            //in test data, Arg1 > Arg0
            if(LEqual(Ones,LNot(LGreater(Arg1,Arg0))))
            {Return(31)}
 
            //test LLessEqual
            if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0))))
            {Return(32)}
 
            if(LEqual(Ones,LLess(Arg1,Arg0)))
            {Return(33)}
 
            //test LLessEqual
            if(LEqual(Ones,LLessEqual(Arg1,Arg0)))
            {Return(34)}
 
            Store(Arg0,Local0)
            Store(Arg1,Local1)
 
            //test with the locals
            if(LNot(LGreater(Local1,Local0)))
                {Return(35)}
 
            //test on Byte data
            Store(0x12,BYT1)
            Store(0x21,BYT2)
 
            if(LNot(LGreater(BYT2,BYT1)))
                {Return(36)}
 
            if(LNot(LLess(BYT1,BYT2)))
                {Return(37)}
 
            //test LGreaterEqual with byte data
            if(LNot(LGreaterEqual(BYT2,BYT1)))
                {Return(38)}
 
            //test LLessEqual byte data
            if(LNot(LLessEqual(BYT1,BYT2)))
                {Return(39)}
 
 
            //test on Word data
            Store(0x1212,WRD1)
            Store(0x2121,WRD2)
 
            if(LNot(LGreater(WRD2,WRD1)))
                {Return(310)}
 
            if(LNot(LLess(WRD1,WRD2)))
                {Return(311)}
 
            //Test LGreaterEqual with Word Data
            if(LNot(LGreaterEqual(WRD2,WRD1)))
                {Return(312)}
 
 
            //Test LLessEqual with Word Data
            if(LNot(LLessEqual(WRD1,WRD2)))
                {Return(313)}
 
            //test on DWord data
            Store(0x12121212,DWD1)
            Store(0x21212121,DWD2)
 
            if(LNot(LGreater(DWD2,DWD1)))
                {Return(314)}
 
            if(LNot(LLess(DWD1,DWD2)))
                {Return(315)}
 
 
            //Test LGreaterEqual with Dword
            if(LNot(LGreaterEqual(DWD2,DWD1)))
                {Return(316)}
 
            //Test LLessEqual DWord
            if(LNot(LLessEqual(DWD1,DWD2)))
                {Return(317)}
 
            Return(0)
        }//LSGR
 
        //The test method
        Method(TEST)
        {
            Store ("++++++++ LOps Test", Debug)
 
            Store(0,RSLT)
            //Call LAndOp method
            Store(ANDL(2,2),RSLT)
            if(LNotEqual(RSLT,0))
             {Return(RSLT)}
 
            //Call LOrOp Method
            Store(ORL_(5,5),RSLT)
            if(LNotEqual(RSLT,0))
            {Return(RSLT)}
 
            //Call LSGR Method
            Store(LSGR(5,7),RSLT)
            if(LNotEqual(RSLT,0))
            {Return(RSLT)}
 
            Return(0)
        }//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, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,      //  8-bit BYTE
        }   //  Field(RAM)
 
        //  Byte Data
        Name (BYT1, 1)
        Name (BRSL, 0x00)
 
        //  Word Data
        Name (WRD1, 0x100)
        Name (WRSL, 0x0000)
 
        //  DWord Data
        Name (DWD1, 0x10000)
        Name (DRSL, 0x00000000)
        Name (RSLT, 1)
        Name (CNTR, 1)
 
        Method (SHFT,2)
        //  Arg0 is the actual data and Arg1 is the bit position
        {   //  SHFT
            Store (Arg0, Local0)
            Store (Arg1, Local1)
 
            FindSetLeftBit (Arg0, BRSL)
            If (LNotEqual (BRSL, Arg1))
                {   Return (0x11)   }
            If (LNotEqual (Arg0, Local0))
                {   Return (0x12)   }
 
            FindSetLeftBit (Local0, BRSL)
            If (LNotEqual (BRSL, Local1))
                {   Return (0x13)   }
            If (LNotEqual (Arg0, Local0))
                {   Return (0x14)   }
 
            //  test the byte value for SetLeftBit
            Store (7, BYT1)
            FindSetLeftBit (BYT1, BRSL)
            If (LNotEqual (BRSL, 3))
                {   Return (0x15)   }
            If (LNotEqual (BYT1, 7))
                {   Return (0x16)   }
 
            Store (1, BYT1)
            Store (1, CNTR)
            While (LLessEqual (CNTR, 8))
            {   //  FindSetLeftBit check loop for byte data
                FindSetLeftBit (BYT1, BRSL)
                If (LNotEqual (BRSL, CNTR))
                    {   Return (0x17)   }
 
                //  Shift the bits to check the same
                ShiftLeft (BYT1, 1, BYT1)
                Increment (CNTR)
            }   //  FindSetLeftBit check loop for byte data
 
 
            //  Check BYTE value for SetRightBit
            Store (7, BYT1)
            FindSetRightBit (BYT1, BRSL)
            If (LNotEqual (BRSL, 1))
                {   Return (0x21)   }
            If (LNotEqual (BYT1, 7))
                {   Return (0x22)   }
 
            Store (1, CNTR)
            Store (0xFF, BYT1)
            While (LLessEqual (CNTR, 8))
            {   //  FindSetRightBit check loop for byte data
                FindSetRightBit (BYT1, BRSL)
                If (LNotEqual (BRSL, CNTR))
                    {   Return (0x23)   }
 
                ShiftLeft (BYT1, 1, BYT1)
                Increment (CNTR)
            }   //  FindSetRightBit check loop for byte data
 
 
            //  Test Word value for SetLeftBit
            Store (9, CNTR)
            Store (0x100, WRD1)
            While (LLessEqual (CNTR, 16))
            {
                //  FindSetLeftBit check loop for Word data
                FindSetLeftBit (WRD1, WRSL)
                If (LNotEqual (WRSL, CNTR))
                    {   Return (0x31)   }
 
                //  Shift the bits to check the same
                ShiftLeft (WRD1, 1, WRD1)
                Increment (CNTR)
            }   //  FindSetLeftBit check loop for Word data
 
            //  Check Word value for SetRightBit
            Store (9, CNTR)
            Store (0xFF00, WRD1)
            While (LLessEqual (CNTR, 16))
            {
                //  FindSetRightBit check loop for Word data
                FindSetRightBit (WRD1, WRSL)
                If (LNotEqual (WRSL, CNTR))
                    {   Return (0x32)   }
 
                ShiftLeft (WRD1, 1, WRD1)
                Increment (CNTR)
            }   //  FindSetRightBit check loop for Word data
 
            //  Test the DWord value for SetLeftBit
            Store (17, CNTR)
            Store (0x10000, DWD1)
            While (LLessEqual (CNTR, 32))
            {
                //  FindSetLeftBit check loop for Dword
                FindSetLeftBit (DWD1, DRSL)
                If (LNotEqual (DRSL, CNTR))
                    {   Return (0x41)   }
 
                //  Shift the bits to check the same
                ShiftLeft (DWD1, 1, DWD1)
                Increment (CNTR)
            }   //  FindSetLeftBit check loop for Dword
 
            //  Check DWord value for SetRightBit
            Store (17, CNTR)
            Store (0xFFFF0000, DWD1)
            While (LLessEqual (CNTR, 32))
            {   //  FindSetRightBit Check loop for DWORD
                FindSetRightBit (DWD1, DRSL)
                If (LNotEqual (DRSL, CNTR))
                    {   Return (0x42)   }
 
                ShiftLeft (DWD1, 1, DWD1)
                Increment (CNTR)
            }   //  FindSetRightBit Check loop for DWORD
 
            Return (0)
        }   //  SHFT
 
        //  Test method called from amlexec
        Method (TEST)
        {   //  TEST
 
            Store ("++++++++ FdSetOps Test", Debug)
 
            Store (SHFT (0x80, 8), RSLT)
            If (LNotEqual (RSLT, 0))
                {   Return (RSLT)   }
 
            Return (0)  //  pass
        }   //  TEST
    }   //  Device FDSO
 
//
// test MulDivOp.asl
//
    Device (MLDV)
    {
        //  create System Memory Operation Region and field overlays
        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,  //  8-bit BYTE
        }   //  Field(RAM)
 
        Method (TEST)
        {
            Store ("++++++++ MulDivOp Test", Debug)
 
            Name (RMDR, 0)
            Name (DWRD, 0x12345678)
            Name (WRD, 0x1234)
            Name (BYT, 0x12)
 
            //  Test MultiplyOp with DWORD data
            Store (0x12345678, DWRD)
            Multiply (DWRD, 3, DWRD)
            If (LNotEqual (DWRD, 0x369D0368))
                {   Return (DWRD)   }
 
            //  Test MultiplyOp with WORD data
            Multiply (WRD, 4, WRD)
            If (LNotEqual (WRD, 0x48D0))
                {   Return (WRD)    }
 
            //  Test MultiplyOp with BYTE data
            Multiply (BYT, 5, BYT)
            If (LNotEqual (BYT, 0x5A))
                {   Return (BYT)    }
 
            //  Test DivideOp with DWORD data
            Divide (DWRD, 3, DWRD, RMDR)
            If (LNotEqual (DWRD, 0x12345678))
                {   Return (DWRD)   }
            If (LNotEqual (RMDR, 0))
                {   Return (RMDR)   }
 
            //  Test DivideOp with WORD data
            Divide (WRD, 4, WRD, RMDR)
            If (LNotEqual (WRD, 0x1234))
                {   Return (WRD)    }
            If (LNotEqual (RMDR, 0))
                {   Return (RMDR)   }
 
            //  Test DivideOp with BYTE data
            Divide (BYT, 5, BYT, RMDR)
            If (LNotEqual (BYT, 0x12))
                {   Return (BYT)    }
            If (LNotEqual (RMDR, 0))
                {   Return (RMDR)   }
 
 
            //  test MultiplyOp with DWORD SystemMemory OpRegion
            Store (0x01234567, SMDW)
            Multiply (SMDW, 2, SMDW)
            If (LNotEqual (SMDW, 0x02468ACE))
                {   Return (SMDW)   }
 
            //  test DivideOp with DWORD SystemMemory OpRegion
            Divide (SMDW, 3, SMDW, RMDR)
            If (LNotEqual (SMDW, 0x00C22E44))
                {   Return (SMDW)   }
            If (LNotEqual (RMDR, 2))
                {   Return (RMDR)   }
 
 
            //  test MultiplyOp with WORD SystemMemory OpRegion
            Store (0x0123, SMWD)
            Multiply (SMWD, 3, SMWD)
            If (LNotEqual (SMWD, 0x369))
                {   Return (SMWD)   }
 
            //  test DivideOp with WORD SystemMemory OpRegion
            Divide (SMWD, 2, SMWD, RMDR)
            If (LNotEqual (SMWD, 0x01B4))
                {   Return (SMWD)   }
            If (LNotEqual (RMDR, 1))
                {   Return (RMDR)   }
 
 
            //  test MultiplyOp with BYTE SystemMemory OpRegion
            Store (0x01, SMBY)
            Multiply (SMBY, 7, SMBY)
            If (LNotEqual (SMBY, 0x07))
                {   Return (SMBY)   }
 
            //  test DivideOp with BYTE SystemMemory OpRegion
            Divide (SMBY, 4, SMBY, RMDR)
            If (LNotEqual (SMBY, 0x01))
                {   Return (SMBY)   }
            If (LNotEqual (RMDR, 3))
                {   Return (RMDR)   }
 
            Return (0)
        }   //  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, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,  //  8-bit BYTE
        }// 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, 0x0000)
 
        //And with DWord Data
        Name (DWD1, 0xffffffff)
        Name (DWD2, 0xffffffff)
        Name (DRSL, 0x00000000)
        Name(RSLT,1)
 
 
        Name(ARSL,0x00)
        Name(LRSL,0x00)
 
        Method(NNDB,2)
        {//NNDB
 
            Store(0xffffffff,SMDW)
            Store(0xffff,SMWD)
            Store(0xff,SMBY)
 
 
            NAnd(Arg0,Arg1,ARSL)
            if(LNotEqual(ARSL,0xfffffffd))
             {Return(11)}
 
             Store(Arg0,local0)
             Store(Arg1,Local1)
 
             NAnd(Local0,Local1,LRSL)
                if(LNotEqual(LRSL,0xfffffffd))
             {Return(12)}
 
 
            //Byte data
            NAnd(BYT1,BYT2,BRSL)
            if(LNotEqual(BRSL,0xffffff00))
             {Return(13)}
 
            //Word Data
             NAnd(WRD1,WRD2,WRSL)
            if(LNotEqual(WRSL,0xffff0000))
             {Return(14)}
 
             //DWord Data
             NAnd(DWD1,DWD2,DRSL)
            if(LNotEqual(DRSL,0x00000000))
             {Return(15)}
 
             //Byte data
            NAnd(SMBY,0xff,BRSL)
            if(LNotEqual(BRSL,0xffffff00))
             {Return(16)}
 
            //Word Data
             NAnd(SMWD,0xffff,WRSL)
            if(LNotEqual(WRSL,0xffff0000))
             {Return(17)}
 
             //DWord Data
             NAnd(SMDW,0xffffffff,DRSL)
            if(LNotEqual(DRSL,0x00000000))
             {Return(18)}
 
            Return(0)
 
        }//NNDB
 
        Method(NNOR,2)
        {//NNOR
 
            NOr(Arg0,Arg1,ARSL)
            if(LNotEqual(ARSL,0xfffffffd))
             {Return(21)}
 
            Store(Arg0,local0)
            Store(Arg1,Local1)
 
            NOr(Local0,Local1,LRSL)
            if(LNotEqual(LRSL,0xfffffffd))
             {Return(22)}
 
 
            //Byte data
            NOr(BYT1,BYT2,BRSL)
            if(LNotEqual(BRSL,0xffffff00))
             {Return(23)}
 
            //Word Data
            NOr(WRD1,WRD2,WRSL)
            if(LNotEqual(WRSL,0xffff0000))
             {Return(24)}
 
            //DWord Data
            NOr(DWD1,DWD2,DRSL)
            if(LNotEqual(DRSL,0x00000000))
             {Return(25)}
 
             //System Memory Byte data
            NOr(SMBY,0xff,BRSL)
            if(LNotEqual(BRSL,0xffffff00))
             {Return(26)}
 
            //System Memory Word Data
            NOr(SMWD,0xffff,WRSL)
            if(LNotEqual(WRSL,0xffff0000))
             {Return(27)}
 
            //System Memory DWord Data
            NOr(SMDW,0xffffffff,DRSL)
            if(LNotEqual(DRSL,0x00000000))
             {Return(28)}
 
            Return(0)
 
        }//NNOR
 
        Method(NNOT,2)
        {//NNOT
 
            Or(Arg0,Arg1,ARSL)
            Not(ARSL,ARSL)
            if(LNotEqual(ARSL,0xfffffffd))
             {Return(31)}
 
            Store(Arg0,local0)
            Store(Arg1,Local1)
 
            Or(Local0,Local1,LRSL)
            Not(LRSL,LRSL)
            if(LNotEqual(LRSL,0xfffffffd))
             {Return(32)}
 
 
            //Byte data
            Or(BYT1,BYT2,BRSL)
            Not(BRSL,BRSL)
            if(LNotEqual(BRSL,0xffffff00))
             {Return(33)}
 
            //Word Data
            Or(WRD1,WRD2,WRSL)
            Not(WRSL,WRSL)
            if(LNotEqual(WRSL,0xffff0000))
             {Return(34)}
 
            //DWord Data
            Or(DWD1,DWD2,DRSL)
            Not(DRSL,DRSL)
            if(LNotEqual(DRSL,0x00000000))
             {Return(35)}
 
             //System Memory Byte data
            Or(SMBY,0xff,BRSL)
            Not(BRSL,BRSL)
            if(LNotEqual(BRSL,0xffffff00))
             {Return(36)}
 
            //System Memory Word Data
            Or(SMWD,0xffff,WRSL)
            Not(WRSL,WRSL)
            if(LNotEqual(WRSL,0xffff0000))
             {Return(37)}
 
            //System Memory DWord Data
            Or(SMDW,0xffffffff,DRSL)
            Not(DRSL,DRSL)
            if(LNotEqual(DRSL,0x00000000))
             {Return(38)}
 
            Return(0)
        }//NNOT
 
 
        Method(TEST)
        {
 
            Store ("++++++++ NBitOps Test", Debug)
 
            Store(NNDB(2,2),RSLT)
            if(LNotEqual(RSLT,0))
                {Return(RSLT)}
 
            Store(NNOR(2,2),RSLT)
            if(LNotEqual(RSLT,0))
                {Return(RSLT)}
 
            Store(NNOT(2,2),RSLT)
            if(LNotEqual(RSLT,0))
                {Return(RSLT)}
 
 
           Return(0)
        }
 
    }//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, 0x400000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {
            SMDW,   32, //  32-bit DWORD
            SMWD,   16, //  16-bit WORD
            SMBY,   8,  //  8-bit BYTE
        }// Field(RAM)
 
 
        Name(SHFC,0x00)
 
        //And with Byte Data
        Name (BYT1, 0xff)
        Name (BRSL, 0x00)
 
        //And with Word Data
        Name (WRD1, 0xffff)
        Name (WRSL, 0x0000)
 
        //And with DWord Data
        Name (DWD1, 0xffffffff)
        Name (DRSL, 0x00000000)
 
        Name(RSLT,1)
 
        Name(ARSL,0x00)
        Name(LRSL,0x00)
 
        Method(SLFT,2)
        {//SLFT
 
            Store(0xffffffff,SMDW)
            Store(0xffff,SMWD)
            Store(0xff,SMBY)
 
 
            //Arg0-> 2 & Arg1->2
            ShiftLeft(Arg0,Arg1,ARSL)
            if(LNotEqual(ARSL,8))
            {Return(11)}
 
             Store(Arg0,local0)
             Store(Arg1,Local1)
 
             //Local0->8 and Local1->2
             ShiftLeft(Local0,Local1,LRSL)
                if(LNotEqual(LRSL,8))
             {Return(12)}
 
            Store(2,SHFC)
            //Byte data
            ShiftLeft(BYT1,SHFC,BRSL)
            if(LNotEqual(BRSL,0x3FC))
             {Return(13)}
 
            Store(4,SHFC)
            //Word Data
             ShiftLeft(WRD1,SHFC,WRSL)
            if(LNotEqual(WRSL,0xFFFF0))
             {Return(14)}
 
            Store(8,SHFC)
            //DWord Data
            ShiftLeft(DWD1,SHFC,DRSL)
            if(LNotEqual(DRSL,0xFFFFFF00))
             {Return(15)}
 
 
             //System Memory Byte data
            Store(4,SHFC)
            ShiftLeft(SMBY,SHFC,BRSL)
            if(LNotEqual(BRSL,0xFF0))
            {Return(16)}
 
            //Word Data
            Store(4,SHFC)
            ShiftLeft(SMWD,SHFC,WRSL)
            if(LNotEqual(WRSL,0xffff0))
             {Return(17)}
 
            //DWord Data
            Store(8,SHFC)
            ShiftLeft(SMDW,SHFC,DRSL)
            if(LNotEqual(DRSL,0xFFFFFF00))
                {Return(18)}
 
            Return(0)
 
        }//SLFT
 
        Method(SRGT,2)
        {//SRGT
            //And with Byte Data
            Store (0xff,BYT1)
            Store (0x00,BRSL)
 
            //And with Word Data
            Store (0xffff,WRD1)
            Store (0x0000,WRSL)
 
            //And with DWord Data
            Store(0xffffffff,DWD1)
            Store (0x00000000,DRSL)
 
            //Reinitialize the result objects
            Store(0x00,ARSL)
            Store(0x00,LRSL)
 
            Store(0xffffffff,SMDW)
            Store(0xffff,SMWD)
            Store(0xff,SMBY)
 
            //Arg0-> 2 & Arg1->2
            ShiftRight(Arg0,Arg1,ARSL)
            if(LNotEqual(ARSL,0))
            {Return(21)}
 
             Store(Arg0,local0)
             Store(Arg1,Local1)
 
             //Local0->8 and Local1->2
             ShiftRight(Local0,Local1,LRSL)
                if(LNotEqual(LRSL,0))
             {Return(22)}
 
            Store(2,SHFC)
            //Byte data
            ShiftRight(BYT1,SHFC,BRSL)
            if(LNotEqual(BRSL,0x3F))
             {Return(23)}
 
            Store(4,SHFC)
            //Word Data
             ShiftRight(WRD1,SHFC,WRSL)
            if(LNotEqual(WRSL,0xFFF))
             {Return(24)}
 
            Store(8,SHFC)
            //DWord Data
            ShiftRight(DWD1,SHFC,DRSL)
            if(LNotEqual(DRSL,0xFFFFFF))
             {Return(25)}
 
            //System Memory Byte data
            Store(4,SHFC)
            ShiftRight(SMBY,SHFC,BRSL)
            if(LNotEqual(BRSL,0xF))
            {Return(26)}
 
            //Word Data
            Store(4,SHFC)
            ShiftRight(SMWD,SHFC,WRSL)
            if(LNotEqual(WRSL,0xFFF))
             {Return(27)}
 
            //DWord Data
            Store(8,SHFC)
            ShiftRight(SMDW,SHFC,DRSL)
            if(LNotEqual(DRSL,0xFFFFFF))
                {Return(28)}
 
            Return(0)
        }//SRGT
 
        //Test method called from amlexec
        Method(TEST)
        {
            Store ("++++++++ ShftOp Test", Debug)
 
            Store(SLFT(2,2),RSLT)
            if(LNotEqual(RSLT,0))
                {Return(RSLT)}
            Store(SRGT(2,2),RSLT)
            if(LNotEqual(RSLT,0))
                {Return(RSLT)}
           Return(0)
        }
 
    }//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)
        {
            Store ("++++++++ Xor Test", Debug)
 
            //Overlay in system memory
            OperationRegion (RAM, SystemMemory, 0x800000, 256)
            Field (RAM, ByteAcc, NoLock, Preserve)
            {
                RES1,   1,  //Offset
                BYT1,   8,  //First BYTE
                BYT2,   8,  //Second BYTE
                RBYT,   8,  //Result Byte
                RES2,   1,  //Offset
                WRD1,   16, //First WORD field
                WRD2,   16, //Second WORD field
                RWRD,   16, //RSLT WORD field
                RES3,   1,  //Offset
                DWD1,   32, //First Dword
                DWD2,   32, //Second Dword
                RDWD,   32, //Result Dword
                RES4,   1,  //Offset
            }
 
            // Store bits in the single bit fields for checking
            //  at the end
            Store(1, RES1)
            Store(1, RES2)
            Store(1, RES3)
            Store(1, RES4)
 
            // Check the stored single bits
            if(LNotEqual(RES1, 1))
            {
                Return(1)
            }
 
            if(LNotEqual(RES2, 1))
            {
                Return(1)
            }
 
            if(LNotEqual(RES3, 1))
            {
                Return(1)
            }
 
            if(LNotEqual(RES4, 1))
            {
                Return(1)
            }
 
            //************************************************
            // (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition
            Store(0x00,BYT1)
            Store(0x00,BYT2)
            XOr(BYT1,BYT2,Local0)
            Store (Local0, RBYT)
            if(LNotEqual(RBYT,0))
            {   Return(1)}
 
            // (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition
            Store(0xff,BYT1)
            Store(0xff,BYT2)
            XOr(BYT1,BYT2,Local0)
            Store (Local0, RBYT)
            if(LNotEqual(RBYT,0))
            {   Return(1)}
 
            // (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition
            Store(0x55,BYT1)
            Store(0xAA,BYT2)
            XOr(BYT1,BYT2,Local0)
            Store (Local0, RBYT)
            if(LNotEqual(RBYT,0xFF))
            {   Return(1)}
 
            //(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition
            Store(0xAA,BYT1)
            Store(0x55,BYT2)
            XOr(BYT1,BYT2,Local0)
            Store (Local0, RBYT)
            if(LNotEqual(RBYT,0xFF))
            {   Return(1)}
 
            Store(0x12,BYT1)
            Store(0xED,BYT2)
 
            XOr(BYT1,BYT2,Local0)
            Store (Local0, RBYT)
            if(LNotEqual(RBYT,0xFF))
            {
                Return(1)
            }
 
            // Store known values for checking later
            Store(0x12, BYT1)
            if(LNotEqual(BYT1, 0x12))
            {
                Return(1)
            }
 
            Store(0xFE, BYT2)
            if(LNotEqual(BYT2, 0xFE))
            {
                Return(1)
            }
 
            Store(0xAB, RBYT)
            if(LNotEqual(RBYT, 0xAB))
            {
                Return(1)
            }
 
            //***********************************************
            // (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition
            Store(0x0000,WRD1)
            Store(0x0000,WRD2)
            XOr(WRD1,WRD2,RWRD)
            if(LNotEqual(RWRD,0))
            {   Return(1)}
 
            // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition
            Store(0xffff,WRD1)
            Store(0xffff,WRD2)
            XOr(WRD1,WRD2,RWRD)
            if(LNotEqual(RWRD,0))
            {   Return(1)}
 
            // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition
            Store(0x5555,WRD1)
            Store(0xAAAA,WRD2)
            XOr(WRD1,WRD2,RWRD)
            if(LNotEqual(RWRD,0xFFFF))
            {   Return(1)}
 
            //(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition
            Store(0xAAAA,WRD1)
            Store(0x5555,WRD2)
            XOr(WRD1,WRD2,RWRD)
            if(LNotEqual(RWRD,0xFFFF))
            {   Return(1)}
 
            Store(0x1234,WRD1)
            Store(0xEDCB,WRD2)
            XOr(WRD1,WRD2,RWRD)
            if(LNotEqual(RWRD,0xFFFF))
            {   Return(1)}
 
            // Store known values for checking later
            Store(0x1234, WRD1)
            if(LNotEqual(WRD1, 0x1234))
            {
                Return(1)
            }
 
            Store(0xFEDC, WRD2)
            if(LNotEqual(WRD2, 0xFEDC))
            {
                Return(1)
            }
 
            Store(0x87AB, RWRD)
            if(LNotEqual(RWRD, 0x87AB))
            {
                Return(1)
            }
 
 
            //**************************************************
            // (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition
            Store(0x00000000,DWD1)
            Store(0x00000000,DWD2)
            XOr(DWD1,DWD2,RDWD)
            if(LNotEqual(RDWD,0))
            {   Return(1)}
 
            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition
            Store(0xffffffff,DWD1)
            Store(0xffffffff,DWD2)
            XOr(DWD1,DWD2,RDWD)
            if(LNotEqual(RDWD,0))
            {   Return(1)}
 
            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
            Store(0x55555555,DWD1)
            Store(0xAAAAAAAA,DWD2)
            XOr(DWD1,DWD2,RDWD)
            if(LNotEqual(RDWD,0xFFFFFFFF))
            {   Return(1)}
 
            //(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition
            Store(0xAAAAAAAA,DWD1)
            Store(0x55555555,DWD2)
            XOr(DWD1,DWD2,RDWD)
            if(LNotEqual(RDWD,0xFFFFFFFF))
            {   Return(1)}
 
            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
            Store(0x12345678,DWD1)
            Store(0xEDCBA987,DWD2)
            XOr(DWD1,DWD2,RDWD)
            if(LNotEqual(RDWD,0xFFFFFFFF))
            {   Return(1)}
 
            Store(0x12345678,DWD1)
            if(LNotEqual(DWD1,0x12345678))
            {
                Return(1)
            }
 
            Store(0xFEDCBA98,DWD2)
            if(LNotEqual(DWD2,0xFEDCBA98))
            {
                Return(1)
            }
 
            Store(0x91827364,RDWD)
            if(LNotEqual(RDWD,0x91827364))
            {
                Return(1)
            }
 
            //****************************************************
            // Check the stored single bits
            if(LNotEqual(RES1, 1))
            {
                Return(1)
            }
 
            if(LNotEqual(RES2, 1))
            {
                Return(1)
            }
 
            if(LNotEqual(RES3, 1))
            {
                Return(1)
            }
 
            if(LNotEqual(RES4, 1))
            {
                Return(1)
            }
 
            // Change all of the single bit fields to zero
            Store(0, RES1)
            Store(0, RES2)
            Store(0, RES3)
            Store(0, RES4)
 
            // Now, check all of the fields
 
            // Byte
            if(LNotEqual(BYT1, 0x12))
            {
                Return(1)
            }
 
            if(LNotEqual(BYT2, 0xFE))
            {
                Return(1)
            }
 
            if(LNotEqual(RBYT, 0xAB))
            {
                Return(1)
            }
 
            // Word
            if(LNotEqual(WRD1, 0x1234))
            {
                Return(1)
            }
 
            if(LNotEqual(WRD2, 0xFEDC))
            {
                Return(1)
            }
 
            if(LNotEqual(RWRD, 0x87AB))
            {
                Return(1)
            }
 
            // Dword
            if(LNotEqual(DWD1, 0x12345678))
            {
                Return(1)
            }
 
            if(LNotEqual(DWD2, 0xFEDCBA98))
            {
                Return(1)
            }
 
            if(LNotEqual(RDWD, 0x91827364))
            {
                Return(1)
            }
 
            // Bits
            if(LNotEqual(RES1, 0))
            {
                Return(1)
            }
 
            if(LNotEqual(RES2, 0))
            {
                Return(1)
            }
 
            if(LNotEqual(RES3, 0))
            {
                Return(1)
            }
 
            if(LNotEqual(RES4, 0))
            {
                Return(1)
            }
 
 
            Return(0)
        }   //  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)
        {
            Store ("++++++++ CrBytFld Test", Debug)
 
            //  Local0 is unitialized buffer with 4 elements
            Store (Buffer (4) {}, Local0)
 
            //  create Byte Field named BF0 based on Local0 element 0
            CreateByteField (Local0, 0, BF0)
 
            //  validate CreateByteField did not alter Local0
            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
                {   Return (2)  }
 
            //  store something into BF0
            Store (1, BF0)
 
            //  validate Store did not alter Local0 object type
            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
                {   Return (3)  }
 
            //  verify that the Store into BF0 was successful
            If (LNotEqual (BF0, 1))
                {   Return (4)  }
 
 
            //  create Byte Field named BF1 based on Local0 element 1
            CreateByteField (Local0, 1, BF1)
 
            //  validate CreateByteField did not alter Local0
            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
                {   Return (10) }
 
            //  store something into BF1
            Store (5, BF1)
 
            //  validate Store did not alter Local0 object type
            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
                {   Return (11) }
 
            //  verify that the Store into BF1 was successful
            If (LNotEqual (BF1, 5))
                {   Return (12) }
 
            //  verify that the Store into BF1 did not alter BF0
            If (LNotEqual (BF0, 1))
                {   Return (13) }
 
 
            //  store something into BF0
            Store (0xFFFF, BF0)
 
            //  verify that the Store into BF0 was successful
            If (LNotEqual (BF0, 0xFF))
                {   Return (20) }
 
            //  verify that the Store into BF0 did not alter BF1
            If (LNotEqual (BF1, 5))
                {   Return (21) }
 
 
            Return (0)
        }   //  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)    //  Misaligned Dynamic RAM SystemMemory OperationRegion
        //  Arg0    --  SystemMemory OperationRegion base address
        {   //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
            OperationRegion (RAM, SystemMemory, Arg0, 0x100)
            Field (RAM, DwordAcc, NoLock, Preserve)
            {   //  aligned field definition (for verification)
                DWD0,   32, //  aligned DWORD field
                DWD1,   32      //  aligned DWORD field
            }
            Field (RAM, ByteAcc, NoLock, Preserve)
            {   //  bit access field definition
                BIT0,   1,      //  single bit field entry
                BIT1,   1,      //  single bit field entry
                BIT2,   1,      //  single bit field entry
                BIT3,   1,      //  single bit field entry
                BIT4,   1,      //  single bit field entry
                BIT5,   1,      //  single bit field entry
                BIT6,   1,      //  single bit field entry
                BIT7,   1,      //  single bit field entry
                BIT8,   1,      //  single bit field entry
                BIT9,   1,      //  single bit field entry
                BITA,   1,      //  single bit field entry
                BITB,   1,      //  single bit field entry
                BITC,   1,      //  single bit field entry
                BITD,   1,      //  single bit field entry
                BITE,   1,      //  single bit field entry
                BITF,   1,      //  single bit field entry
                BI10,   1,      //  single bit field entry
                BI11,   1,      //  single bit field entry
                BI12,   1,      //  single bit field entry
                BI13,   1,      //  single bit field entry
                BI14,   1,      //  single bit field entry
                BI15,   1,      //  single bit field entry
                BI16,   1,      //  single bit field entry
                BI17,   1,      //  single bit field entry
                BI18,   1,      //  single bit field entry
                BI19,   1,      //  single bit field entry
                BI1A,   1,      //  single bit field entry
                BI1B,   1,      //  single bit field entry
                BI1C,   1,      //  single bit field entry
                BI1D,   1,      //  single bit field entry
                BI1E,   1,      //  single bit field entry
                BI1F,   1       //  single bit field entry
            }   //  bit access field definition
 
            Field (RAM, ByteAcc, NoLock, Preserve)
            {   //  two-bit access field definition
                B2_0,   2,      //  single bit field entry
                B2_1,   2,      //  single bit field entry
                B2_2,   2,      //  single bit field entry
                B2_3,   2,      //  single bit field entry
                B2_4,   2,      //  single bit field entry
                B2_5,   2,      //  single bit field entry
                B2_6,   2,      //  single bit field entry
                B2_7,   2,      //  single bit field entry
                B2_8,   2,      //  single bit field entry
                B2_9,   2,      //  single bit field entry
                B2_A,   2,      //  single bit field entry
                B2_B,   2,      //  single bit field entry
                B2_C,   2,      //  single bit field entry
                B2_D,   2,      //  single bit field entry
                B2_E,   2,      //  single bit field entry
                B2_F,   2       //  single bit field entry
            }   //  bit access field definition
 
            //  initialize memory contents using aligned field entries
            Store (0x5AA55AA5, DWD0)
            Store (0x5AA55AA5, DWD1)
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BIT0)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT0, 0))
                    {   Return (1)  }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55AA4))
                    {   Return (2)  }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BIT1)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT1, 1))
                    {   Return (3)  }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55AA6))
                    {   Return (4)  }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BIT2)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT2, 0))
                    {   Return (5)  }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55AA2))
                    {   Return (6)  }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BIT3)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT3, 1))
                    {   Return (7)  }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55AAA))
                    {   Return (8)  }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BIT4)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT4, 1))
                    {   Return (9)  }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55ABA))
                    {   Return (10) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BIT5)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT5, 0))
                    {   Return (11) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55A9A))
                    {   Return (12) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BIT6)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT6, 1))
                    {   Return (13) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55ADA))
                    {   Return (14) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BIT7)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT7, 0))
                    {   Return (15) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55A5A))
                    {   Return (16) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BIT8)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT8, 1))
                    {   Return (17) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55B5A))
                    {   Return (18) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BIT9)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BIT9, 0))
                    {   Return (19) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA5595A))
                    {   Return (20) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BITA)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BITA, 1))
                    {   Return (21) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA55D5A))
                    {   Return (22) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BITB)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BITB, 0))
                    {   Return (23) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA5555A))
                    {   Return (24) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BITC)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BITC, 0))
                    {   Return (25) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA5455A))
                    {   Return (26) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BITD)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BITD, 1))
                    {   Return (27) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA5655A))
                    {   Return (28) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BITE)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BITE, 0))
                    {   Return (29) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA5255A))
                    {   Return (30) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BITF)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BITF, 1))
                    {   Return (31) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA5A55A))
                    {   Return (32) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI10)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI10, 0))
                    {   Return (33) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA4A55A))
                    {   Return (34) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI11)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI11, 1))
                    {   Return (35) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA6A55A))
                    {   Return (36) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI12)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI12, 0))
                    {   Return (37) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AA2A55A))
                    {   Return (38) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI13)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI13, 1))
                    {   Return (39) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5AAAA55A))
                    {   Return (40) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI14)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI14, 1))
                    {   Return (41) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5ABAA55A))
                    {   Return (42) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI15)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI15, 0))
                    {   Return (43) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5A9AA55A))
                    {   Return (44) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI16)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI16, 1))
                    {   Return (45) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5ADAA55A))
                    {   Return (46) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI17)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI17, 0))
                    {   Return (47) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5A5AA55A))
                    {   Return (48) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI18)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI18, 1))
                    {   Return (49) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5B5AA55A))
                    {   Return (50) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI19)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI19, 0))
                    {   Return (51) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x595AA55A))
                    {   Return (52) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI1A)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI1A, 1))
                    {   Return (53) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x5D5AA55A))
                    {   Return (54) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI1B)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI1B, 0))
                    {   Return (55) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x555AA55A))
                    {   Return (56) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI1C)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI1C, 0))
                    {   Return (57) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x455AA55A))
                    {   Return (58) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI1D)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI1D, 1))
                    {   Return (59) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x655AA55A))
                    {   Return (60) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, BI1E)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI1E, 0))
                    {   Return (61) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x255AA55A))
                    {   Return (62) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, BI1F)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (BI1F, 1))
                    {   Return (63) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55AA55A))
                    {   Return (64) }
 
 
            //  set memory contents to known values using misaligned field entries
            Store (3, B2_0)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_0, 3))
                    {   Return (65) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55AA55B))
                    {   Return (66) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, B2_1)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_1, 1))
                    {   Return (67) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55AA557))
                    {   Return (68) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, B2_2)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_2, 0))
                    {   Return (69) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55AA547))
                    {   Return (70) }
 
            //  set memory contents to known values using misaligned field entries
            Store (3, B2_3)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_3, 3))
                    {   Return (71) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55AA5C7))
                    {   Return (72) }
 
            //  set memory contents to known values using misaligned field entries
            Store (3, B2_4)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_4, 3))
                    {   Return (73) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55AA7C7))
                    {   Return (74) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, B2_5)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_5, 0))
                    {   Return (75) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55AA3C7))
                    {   Return (76) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, B2_6)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_6, 1))
                    {   Return (77) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55A93C7))
                    {   Return (78) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, B2_7)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_7, 1))
                    {   Return (79) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55A53C7))
                    {   Return (80) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, B2_8)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_8, 0))
                    {   Return (81) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55853C7))
                    {   Return (82) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, B2_9)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_9, 1))
                    {   Return (83) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA55453C7))
                    {   Return (84) }
 
            //  set memory contents to known values using misaligned field entries
            Store (2, B2_A)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_A, 2))
                    {   Return (85) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA56453C7))
                    {   Return (86) }
 
            //  set memory contents to known values using misaligned field entries
            Store (2, B2_B)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_B, 2))
                    {   Return (87) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA5A453C7))
                    {   Return (88) }
 
            //  set memory contents to known values using misaligned field entries
            Store (3, B2_C)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_C, 3))
                    {   Return (89) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xA7A453C7))
                    {   Return (90) }
 
            //  set memory contents to known values using misaligned field entries
            Store (3, B2_D)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_D, 3))
                    {   Return (91) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0xAFA453C7))
                    {   Return (92) }
 
            //  set memory contents to known values using misaligned field entries
            Store (1, B2_E)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_E, 1))
                    {   Return (93) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x9FA453C7))
                    {   Return (94) }
 
            //  set memory contents to known values using misaligned field entries
            Store (0, B2_F)
                //  verify memory contents using misaligned field entries
                If (LNotEqual (B2_F, 0))
                    {   Return (95) }
                //  verify memory contents using aligned field entries
                If (LNotEqual (DWD0, 0x1FA453C7))
                    {   Return (96) }
 
 
            Return (0)  //  pass
        }   //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
 
        Method (TEST)
        {
            Store ("++++++++ IndexOp4 Test", Debug)
 
            //  MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments:
            //      Arg0    --  SystemMemory OperationRegion base address
            Store (MADM (0x800000), Local0)
            If (LNotEqual (Local0, 0))      //  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)
        //  Arg0:   time to Wait for event in milliseconds
        {   //  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
            Store (Wait (EVNT, Arg0), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x21)   }       //  Local1 indicates Local0 is not a Number
 
            If (LNotEqual (Local0, 0))  //  Number is type 1
                {   Return (0x22)   }       //  timeout occurred without acquiring signal
 
            Store ("Acquire 1st existing signal PASS", Debug)
 
 
            //  acquire existing signal
            Store (Wait (EVNT, Arg0), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x31)   }       //  Local1 indicates Local0 is not a Number
 
            If (LNotEqual (Local0, 0))  //  Number is type 1
                {   Return (0x32)   }       //  timeout occurred without acquiring signal
 
            Store ("Acquire 2nd existing signal PASS", Debug)
 
 
            //  ensure WaitOp timeout test cases do not hang
            if (LEqual (Arg0, 0xFFFF))
                {   Store (0xFFFE, Arg0)    }
 
            //  acquire non-existing signal
            Store (Wait (EVNT, Arg0), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x41)   }       //  Local1 indicates Local0 is not a Number
 
            If (LEqual (Local0, 0))     //  Number is type 1
                {   Return (0x42)   }       //  non-existant signal was acquired
 
            Store ("Acquire signal timeout PASS", Debug)
 
 
            //  prime EVNT with two outstanding signals
            Signal (EVNT)
            Signal (EVNT)
 
            //  reset EVNT to initialization (zero) state
            Reset (EVNT)
 
            //  acquire non-existing signal
            Store (Wait (EVNT, Arg0), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x51)   }       //  Local1 indicates Local0 is not a Number
 
            If (LEqual (Local0, 0))     //  Number is type 1
                {   Return (0x52)   }       //  non-existant signal was acquired
 
            Store ("Reset signal PASS", Debug)
 
 
            //  acquire non-existing signal using Lvalue timeout
            Store (Wait (EVNT, Zero), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x61)   }       //  Local1 indicates Local0 is not a Number
 
            If (LEqual (Local0, 0))     //  Number is type 1
                {   Return (0x62)   }       //  non-existant signal was acquired
 
            Store ("Zero Lvalue PASS", Debug)
 
 
            //  acquire non-existing signal using Lvalue timeout
            Store (Wait (EVNT, One), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x71)   }       //  Local1 indicates Local0 is not a Number
 
            If (LEqual (Local0, 0))     //  Number is type 1
                {   Return (0x72)   }       //  non-existant signal was acquired
 
            Store ("One Lvalue PASS", Debug)
 
            //  Lvalue Event test cases
    // ILLEGAL SOURCE OPERAND        Store (EVNT, Local2)
 
            //  validate Local2 is an Event
            Store (ObjectType (EVNT), Local1)
            If (LNotEqual (Local1, 7))  //  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
            Store (Wait (EVNT, Arg0), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x82)   }       //  Local1 indicates Local0 is not a Number
 
            If (LNotEqual (Local0, 0))  //  Number is type 1
                {   Return (0x83)   }       //  timeout occurred without acquiring signal
 
            Store ("Acquire Lvalue existing signal PASS", Debug)
 
 
            //  acquire non-existing signal
            Store (Wait (EVNT, Arg0), Local0)
 
            //  validate Local0 is a Number
            Store (ObjectType (Local0), Local1)
            If (LNotEqual (Local1, 1))  //  Number is type 1
                {   Return (0x84)   }       //  Local1 indicates Local0 is not a Number
 
            If (LEqual (Local0, 0))     //  Number is type 1
                {   Return (0x85)   }       //  non-existant signal was acquired
 
            Store ("Acquire Lvalue signal timeout PASS", Debug)
 
 
            Return (0)  //  success
        }   //  TEVN control method to test ResetOp, SignalOp, and WaitOp
 
        Method (TEST)
        {
            Store ("++++++++ Event Test", Debug)
 
            Store (TEVN (100), Local0)
 
            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 (3)
        {0x0123, 0x4567, 0x89AB}
    )   //  PKG0
 
    Name (PKG1,
        Package (3)
        {
            Package (3) {0x0123, 0x4567, 0x89AB},
            Package (3) {0xCDEF, 0xFEDC, 0xBA98},
            Package (3) {0x7654, 0x3210, 0x1234}
        }
    )   //  PKG1
 
    Name (PKG2,
        Package (4)
        {0x0123, 0x4567, 0x89AB, 0x8888}
    )   //  PKG2
 
    Name (PKG3,
        Package (5)
        {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 (10) {})
    Name (BUF1, Buffer (10) {})
    Name (BUF2, Buffer (8)  {})
    Name (BUF3, Buffer (5)  {})
 
//  End Buffers     **********************************************************
    Device (SZLV)
    {
 
        Method (CMPR, 2)
        {
            //  CMPR is passed two arguments.  If unequal, return 1 to indicate
            //  that, otherwise return 0 to indicate SizeOf each is equal.
 
            Store (0x01, Local0)
 
            if (LEqual (SizeOf(Arg0), SizeOf(Arg1)))
            {
                Store (0x00, Local0)
            }
 
            return (Local0)
        }   //  CMPR
 
 
        Method (TEST)
        {
 
            Store ("++++++++ SizeOfLv Test", Debug)
 
            //  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 (LNotEqual (0x00, CMPR (STR0, STR1)))
            {
                Return (0x01)
            }
 
            if (LNotEqual (0x00, CMPR (STR3, BUF3)))
            {
                Return (0x02)
            }
 
            if (LNotEqual (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
            Store (STR0, Local0)
            Store (STR1, Local1)
 
            if (LNotEqual (SizeOf (Local0), SizeOf (Local1)))
            {
                Return (0x04)
            }
 
            //  Now create a case where Local0 and Local1 are different
            Store (STR2, Local1)
 
            if (LEqual (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 (LNotEqual (0x05, SizeOf (BUF3)))
            {
                Return (0x06)
            }
 
            Return (0)
        }   //  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)
            {
                Store ("++++++++ BytField Test", Debug)
 
                Return (\_TZ.C19B.RSLT)
            }   //  TEST
        }   //  BYTF
 
        Device (C005)
        {   //  Device C005
            Device (C013)
            {   //  Device C013
            }   //  Device C013
        }   //  Device C005
 
        Method (C115)
        {   //  C115 control method
            Acquire (\_GL, 0xFFFF)
            Store (\_SB.C005.C013.C058.C07E, Local0)
            Release (\_GL)
            And (Local0, 16, Local0)
            Store (ShiftRight (Local0, 4, ), Local1)
            If (LEqual (Local1, 0))
                {   Return (1)  }
            Else
                {   Return (0)  }
        }   //  C115 control method
    }   //  _SB system bus
 
    OperationRegion (C018, SystemIO, 0x5028, 4)
    Field (C018, AnyAcc, NoLock, Preserve)
    {   //  Field overlaying C018
        C019,   32
    }   //  Field overlaying C018
 
    OperationRegion (C01A, SystemIO, 0x5030, 4)
    Field (C01A, ByteAcc, NoLock, Preserve)
    {   //  Field overlaying C01A
        C01B,   8,
        C01C,   8,
        C01D,   8,
        C01E,   8
    }   //  Field overlaying C01A
 
    Mutex (\C01F, 0)
    Name (\C020, 0)
    Name (\C021, 0)
 
    Method (\C022, 0)
    {   //  \C022 control method
        Acquire (\C01F, 0xFFFF)
        If (LEqual (\C021, 0))
        {
            Store (C019, Local0)
            And (Local0, 0xFFFEFFFE, Local0)
            Store (Local0, C019)
            Increment (\C021)
        }
        Release (\C01F)
    }   //  \C022 control method
 
    Scope (\_SB.C005.C013)
    {   //  Scope \_SB.C005.C013
        Device (C058)
        {   //  Device C058
            Name (_HID, "*PNP0A06")
 
            OperationRegion (C059, SystemIO, 0xE0, 2)
            Field (C059, ByteAcc, NoLock, Preserve)
            {   //  Field overlaying C059
                C05A,   8,
                C05B,   8
            }   //  Field overlaying C059
 
            OperationRegion (C05C, SystemIO, 0xE2, 2)
            Field (C05C, ByteAcc, NoLock, Preserve)
            {   //  Field overlaying C05C
                C05D,   8,
                C05E,   8
            }   //  Field overlaying C05C
            IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
            {   //  IndexField overlaying C05D/C05E
                ,       0x410,  //  skip
                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,
                ,       0x70,       //  skip
                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, 2)
            Field (C07F, ByteAcc, NoLock, Preserve)
            {   //  Field overlaying C07F
                C080,   8,
                C081,   8
            }   //  Field overlaying C07F
 
            OperationRegion (C082, SystemIO, 0xE0, 1)
            Field (C082, ByteAcc, NoLock, Preserve)
            {   //  Field overlaying C082
                C083,   8
            }   //  Field overlaying C082
 
            OperationRegion (C084, SystemIO, 0xFF, 1)
            Field (C084, ByteAcc, NoLock, Preserve)
            {   //  Field overlaying C084
                C085,   8
            }   //  Field overlaying C084
 
            OperationRegion (C086, SystemIO, 0xFD, 1)
            Field (C086, ByteAcc, NoLock, Preserve)
            {   //  Field overlaying C086
                C087,   8
            }   //  Field overlaying C086
 
            Mutex (C088, 0)
            Mutex (C089, 0)
            Mutex (C08A, 0)
            Mutex (C08B, 0)
            Mutex (C08C, 0)
            Mutex (C08D, 0)
 
            Name (C08E, 0xFFFFFFFD)
            Name (C08F, 0)
 
            Method (C0AA, 4)
            {   //  C0AA control method
                Store (Buffer (4) {}, Local7)
                CreateByteField (Local7, 0, C0AB)
                CreateByteField (Local7, 1, C0AC)
                CreateByteField (Local7, 2, C0AD)
                CreateByteField (Local7, 3, C0AE)
                Acquire (^C08B, 0xFFFF)
                Acquire (\_GL, 0xFFFF)
                \C022 ()
                Store (1, \_SB.C005.C013.C058.C06B)
                While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
                    {   Stall (100) }
                Store (Arg3, \_SB.C005.C013.C058.C06E)
                Store (Arg2, \_SB.C005.C013.C058.C06D)
                Store (Arg1, \_SB.C005.C013.C058.C06C)
                Store (Arg0, \_SB.C005.C013.C058.C06B)
                While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
                    {   Stall (100) }
                Store (\_SB.C005.C013.C058.C06E, C0AB)
                Store (\_SB.C005.C013.C058.C06D, C0AC)
                Store (\_SB.C005.C013.C058.C06C, C0AD)
                Store (\_SB.C005.C013.C058.C06B, C0AE)
                If (LNot (LEqual (Arg0, 23)))
                {
                    Store (2, \_SB.C005.C013.C058.C06B)
                    Stall (100)
                }
                Release (\_GL)
                Release (^C08B)
                Return (Local7)
            }   //  C0AA control method
        }   //  Device C058
    }   //  Scope \_SB.C005.C013
 
    Scope (\_TZ)
    {   //  \_TZ thermal zone scope
        Name (C18B, Package (2)
        {
            Package (2)
            {
                Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
                Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
            },
            Package (2)
            {
                Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
                Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
            }
        })  //  C18B
 
        Name (C18C, Package (2)
        {
            Package (2)
            {
                Package (3) {0x64, 0x4B, 0x32},
                Package (3) {0x64, 0x4B, 0x32}
            }
        })  //  C81C
 
        Name (C18D, 0)
        Name (C18E, 0)
        Name (C18F, 0)
        Name (C190, 0)
        Name (C191, 3)
        Name (C192, 0)
        Name (C193, 1)
        Name (C194, 2)
        Mutex (C195, 0)
        Name (C196, 1)
        Name (C197, 0x0B9C)
        Name (C198, 0x0B9C)
        Name (C199, 0xFFFFFFFD)
        Name (C19A, 0)
 
        Device (C19B)
        {   //  Device C19B
            Name (RSLT, 0)  //  default to zero
 
            Method (XINI)
            {   //  _INI control method (Uses Global Lock -- can't run under AcpiExec)
                Store (\_SB.C115, C19A)
                \_TZ.C19C._SCP (0)
                Subtract (0x0EB2, 0x0AAC, Local1)   //  Local1 = AACh - EB2h
                Divide (Local1, 10, Local0, Local2) //  Local0 = Local1 / 10
                                                                //  Local2 = Local1 % 10
                \_SB.C005.C013.C058.C0AA (14, Local2, 0, 0)
                Store
                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D)
                Store
                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E)
                Store
                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F)
 
                Store (1, RSLT) //  set RSLT to 1 if _INI control method completes
            }   //  _INI control method
 
            //  PowerResource (C19D) {...}
        }   //  Device C19B
 
        ThermalZone (C19C)
        {
            Method (_SCP, 1)
            {   //  _SCP control method
                Store (Arg0, Local0)
                If (LEqual (Local0, 0))
                {
                    Store (0, \_TZ.C192)
                    Store (1, \_TZ.C193)
                    Store (2, \_TZ.C194)
                    Store (3, \_TZ.C191)
                }
                Else
                {
                    Store (0, \_TZ.C191)
                    Store (1, \_TZ.C192)
                    Store (2, \_TZ.C193)
                    Store (3, \_TZ.C194)
                }
            }   //  _SCP control method
        }   //  ThermalZone C19C
    }   //  \_TZ thermal zone scope
 
 
//
// test DwrdFld.asl
//
    Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} )
 
    Device (DWDF)
    {
        Method (TEST)
        {
            Store ("++++++++ DwrdFld Test", Debug)
 
            CreateByteField (BUFR, 0, BYTE)
            Store (0xAA, BYTE)
 
            CreateWordField (BUFR, 1, WORD)
            Store (0xBBCC, WORD)
 
            CreateDWordField (BUFR, 3, DWRD)
            Store (0xDDEEFF00, DWRD)
 
            CreateByteField (BUFR, 7, BYT2)
            Store (0x11, BYT2)
 
            CreateWordField (BUFR, 8, WRD2)
            Store (0x2233, WRD2)
 
            Return (0)
 
        }   //  End Method TEST
    }   //  Device DWDF
 
    //
    // test DivAddx.asl
    //
    Name (B1LO, 0xAA)
    Name (B1HI, 0xBB)
 
    Method (MKW_, 2)
    {   //  This control method will take two bytes and make them into a WORD
 
        Multiply (B1HI, 256, Local0)    //  Make high byte.....high
        Or (Local0, B1LO, Local0)       //  OR in the low byte
        Return (Local0)                 //  Return the WORD
 
    }   //  MKW_
 
    Device (DVAX)
    {
        Method (TEST)
        {
 
            Store ("++++++++ DivAddx Test", Debug)
 
            Store (25, B1LO)
            Store (0, B1HI)
 
            //  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(
                Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63),
                            //  Dividend,
                100,        //  Divisor
                Local4,     //  Remainder
                Local2)     //  Quotient
 
            If (LAnd (LEqual (74, Local4), LEqual (1, Local2)))
            {   //  Indicate Pass
                Store (0x00, Local0)
            }
 
            Else
            {   //  Indicate Fail
                Store (0x01, Local0)
            }
 
            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, 0x100, 2)
        Field (SIO, ByteAcc, NoLock, Preserve)
        {
            INDX,   8,
            DATA,   8
        }
        IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
        {
            AccessAs (ByteAcc, 0),
            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, 0x100, 2)
            Field (SIO2, ByteAcc, NoLock, Preserve)
            {
                IND2,   8,
                DAT2,   8
            }
            IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
            {
                IFE0,   8,  //  duplicate IndexField name with different scope
                IFE1,   8
            }
        }   //  TST_:   provides a different namespace scope for IFE0 and IFE1
 
        Method (TEST)
        {
            Store ("++++++++ IndexOp6 Test", Debug)
 
            Store (IFE0, Local0)
            Store (IFE1, Local1)
            Store (IFE2, Local2)
 
            //  validate name resolution of IndexFields with different scopes
            Store (\IDX6.IFE0, Local3)
            Store (\IDX6.IFE1, Local4)
            //  verioading of namespace can resolve following names
            Store (\IDX6.TST_.IFE0, Local5)
            Store (\IDX6.TST_.IFE1, Local6)
 
            Return (0)
        }   //  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, 0)  //  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)    //  Control Method to compare two strings
        {   //  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 (LLess (SizeOf (Arg0), SizeOf (Arg1)))
                {   Return (0)  }
 
            //  increment length to include NULL termination character
            Add (SizeOf (Arg0), 1, Local0)  //  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
            Store (Arg0, BUF0)
            Store (Arg1, BUF1)
 
            //  validate BUF0 and BUF1 are still buffers
            Store (ObjectType (BUF0), Local1)
            If (LNotEqual (Local1, 3))  //  Buffer is type 3
                {   Return (20) }
            Store (ObjectType (BUF1), Local1)
            If (LNotEqual (Local1, 3))  //  Buffer is type 3
                {   Return (21) }
 
            // Decrement because the Index base below is zero based
            //  while Local0 length is one based.
            Decrement (Local0)
 
            While (Local0)
            {   //  loop through all BUF0 buffer elements
                Decrement (Local0)
 
                //  check if BUF0[n] == BUF1[n]
                If (LEqual (DerefOf (Index (BUF0, Local0, )),
                        DerefOf (Index (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)
        {
            Store ("++++++++ IndexOp5 Test", Debug)
 
            If (MCTH (\_OS, "Microsoft Windows NT"))
                {   Store (1, OSFL) }
 
            If (LNotEqual (OSFL, 1))
                {   Return (11) }
 
            Return (0)
        }   //  TEST
    }   //  IDX5
 
//
// test IndexOp.asl
//
    Scope (\_SB)    //  System Bus
    {   //  _SB system bus
 
        Method (C097)
            {   Return (1)  }
 
        Device (PCI2)
        {   //  Root PCI Bus
            Name (_HID, EISAID("PNP0A03"))
            Name (_ADR, 0x00000000)
            Name (_CRS, Buffer(26)  {"\_SB_.PCI2._CRS..........."})
            Method (_STA)   {Return (0x0F)}
 
            Device (ISA)
            {   //  ISA bridge
                Name (_ADR, 0x00030000)     //  ISA bus ID
 
                Device (EC0)
                {   //  Embedded Controller
                    Name (_GPE, 0)              //  EC use GPE0
                    Name (_ADR, 0x0030000)  //  PCI address
 
                    Method (_STA,0)         //  EC Status
                        {   Return(0xF) }       //  EC is functioning
 
                    Name (_CRS, ResourceTemplate()
                        {
                            IO (Decode16, 0x62, 0x62, 1, 1)
                            IO (Decode16, 0x66, 0x66, 1, 1)
                        }
                    )
 
                //  create EC's region and field
                    OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
                    Field (RAM, AnyAcc, NoLock, Preserve)
                    {
                        //  AC information
                        ADP,    1,      //  AC Adapter 1:On-line, 0:Off-line
                        AFLT,   1,      //  AC Adapter Fault  1:Fault  0:Normal
                        BAT0,   1,      //  BAT0  1:present, 0:not present
                        ,       1,      //  reserved
                        ,       28, //  filler to force DWORD alignment
 
                        //  CMBatt information
                        BPU0,   32, //  Power Unit
                        BDC0,   32, //  Designed Capacity
                        BFC0,   32, //  Last Full Charge Capacity
                        BTC0,   32, //  Battery Technology
                        BDV0,   32, //  Design Voltage
                        BST0,   32, //  Battery State
                        BPR0,   32, //  Battery Present Rate
                                        //  (Designed Capacity)x(%)/{(h)x100}
                        BRC0,   32, //  Battery Remaining Capacity
                                        //  (Designed Capacity)(%)^100
                        BPV0,   32, //  Battery Present Voltage
                        BTP0,   32, //  Trip Point
                        BCW0,   32, //  Design capacity of Warning
                        BCL0,   32, //  Design capacity of Low
                        BCG0,   32, //  capacity granularity 1
                        BG20,   32, //  capacity granularity 2
                        BMO0,   32, //  Battery model number field
                        BIF0,   32, //  OEM Information(00h)
                        BSN0,   32, //  Battery Serial Number
                        BTY0,   32, //  Battery Type (e.g., "Li-Ion")
                        BTY1,   32      //  Battery Type (e.g., "Li-Ion")
                    }   //  Field
                }   //  EC0: Embedded Controller
            }   //  ISA bridge
        }   //  PCI2 Root PCI Bus
 
        Device (IDX0)
        {   //  Test device name
            Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
            Name (_PCL, Package() {\_SB})
            Method (_STA)
            {
                //  _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)
            {
                Name (BUFR, Package(13) {})
                Store (\_SB.PCI2.ISA.EC0.BPU0, Index (BUFR,0))  //  Power Unit
                Store (\_SB.PCI2.ISA.EC0.BDC0, Index (BUFR,1))  //  Designed Capacity
                Store (\_SB.PCI2.ISA.EC0.BFC0, Index (BUFR,2))  //  Last Full Charge Capa.
                Store (\_SB.PCI2.ISA.EC0.BTC0, Index (BUFR,3))  //  Battery Technology
                Store (\_SB.PCI2.ISA.EC0.BDV0, Index (BUFR,4))  //  Designed Voltage
                Store (\_SB.PCI2.ISA.EC0.BCW0, Index (BUFR,5))  //  Designed warning level
                Store (\_SB.PCI2.ISA.EC0.BCL0, Index (BUFR,6))  //  Designed Low level
                Store (\_SB.PCI2.ISA.EC0.BCG0, Index (BUFR,7))  //  Capacity granularity 1
                Store (\_SB.PCI2.ISA.EC0.BG20, Index (BUFR,8))  //  Capacity granularity 2
 
                Store ("", Index (BUFR,9))                              //  Model Number
 
                Store ("", Index (BUFR,10))                         //  Serial Number
 
                Store ("LiOn", Index (BUFR,11))                     //  Battery Type
 
                Store ("Chicony", Index (BUFR,12))                  //  OEM Information
 
                Return (BUFR)
            }   //  _BIF
 
            Method (_BST)
            {
                Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180})
                Return (BUFR)
            }   //  _BST
 
            Method (_BTP,1)
            {
                Store (arg0, \_SB.PCI2.ISA.EC0.BTP0)    //  Set Battery Trip point
            }
 
            Method (TEST)
            {
 
                Store ("++++++++ IndexOp Test", Debug)
 
                //  test storing into uninitialized package elements
                Name (PBUF, Package(4) {})  //  leave unitialized
                Store (0x01234567, Index (PBUF,0))
                Store (0x89ABCDEF, Index (PBUF,1))
                Store (0xFEDCBA98, Index (PBUF,2))
                Store (0x76543210, Index (PBUF,3))
 
                //  verify values stored into uninitialized package elements
                If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567))
                    {   Return (0x10)   }
 
                If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF))
                    {   Return (0x11)   }
 
                If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98))
                    {   Return (0x12)   }
 
                If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210))
                    {   Return (0x13)   }
 
 
                //  store _BIF package return value into Local0
                Store (_BIF, Local0)
 
                //  save Local0 object type value into Local1
                Store (ObjectType (Local0), Local1)
 
                //  validate Local0 is a Package
                If (LNotEqual (Local1, 4))  //  Package type is 4
                    {   Return (0x21)   }   //  failure
 
 
                //  test storing into buffer field elements
                Name (BUFR, Buffer(16)
                    {   //  initial values
                        00, 00, 00, 00, 00, 00, 00, 00,
                        00, 00, 00, 00, 00, 00, 00, 00,
                    }
                )   //  BUFR
                //  test storing into buffer field elements
                Store (0x01234567, Index (BUFR,0))  //  should only store 0x67
                Store (0x89ABCDEF, Index (BUFR,4))  //  should only store 0xEF
                Store (0xFEDCBA98, Index (BUFR,8))  //  should only store 0x98
                Store (0x76543210, Index (BUFR,12)) //  should only store 0x10
 
                //  verify storing into buffer field elements
                If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67))
                    {   Return (0x30)   }
 
                If (LNotEqual (DerefOf (Index (BUFR,1)), 0))
                    {   Return (0x31)   }
 
                If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF))
                    {   Return (0x34)   }
 
                If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98))
                    {   Return (0x38)   }
 
                If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10))
                    {   Return (0x3C)   }
 
 
                Return (0)  //  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, 0x800000, 0x100)
        Field (RAM, AnyAcc, NoLock, Preserve)
        {   //  Any access
            TREE,   3,
            WRD0,   16,
            WRD1,   16,
            WRD2,   16,
            WRD3,   16,
            WRD4,   16,
            DWRD,   32, //  DWORD field
        }
        Field (RAM, AnyAcc, NoLock, Preserve)
        {   //  Any access
            THRE,   3,
            WD00,   16,
            WD01,   16,
            WD02,   16,
            WD03,   16,
            WD04,   16,
            BYT0,   8,  //  Start off with a BYTE
            BIT0,   1,  //  single-bit field
            BIT1,   1,  //  single-bit field
            BIT2,   1,  //  single-bit field
            BIT3,   1,  //  single-bit field
            BIT4,   1,  //  single-bit field
            BIT5,   1,  //  single-bit field
            BIT6,   1,  //  single-bit field
            BIT7,   1,  //  single-bit field
            BIT8,   1,  //  single-bit field
            BIT9,   1,  //  single-bit field
            BITA,   1,  //  single-bit field
            BITB,   1,  //  single-bit field
            BITC,   1,  //  single-bit field
            BITD,   1,  //  single-bit field
            BITE,   1,  //  single-bit field
            BITF,   1,  //  single-bit field
            BYTZ,   8,  //  End with a BYTE for a total of 32 bits
        }
 
        Device (BITI)
        {   //  Test device name
 
            Method (MBIT)   //  Test single bit memory accesses
            {
 
                If (LNotEqual (DWRD, 0x00))
                {
                    Store (0xFF00, Local0)
                }
                Else
                {
                    //  Prime Local0 with 0...assume passing condition
                    Store (0, Local0)
 
                    //  set memory contents to known values using DWORD field
                    Store (0x5A5A5A5A, DWRD)
 
                    //  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)
                    {
                        Or (Local0, 0x01, Local0)
                    }
 
                    If (LNot (BIT1))
                    {
                        Or (Local0, 0x02, Local0)
                    }
 
                    If (BIT2)
                    {
                        Or (Local0, 0x04, Local0)
                    }
 
                    If (LNot (BIT3))
                    {
                        Or (Local0, 0x08, Local0)
                    }
 
                    //  Now check the upper nibble.  Only the "even" bits should
                    //  be set.  BIT4, BIT6.  BIT5 and BIT7 should be clear.
                    If (LNot (BIT4))
                    {
                        Or (Local0, 0x10, Local0)
                    }
 
                    If (BIT5)
                    {
                        Or (Local0, 0x20, Local0)
                    }
 
                    If (LNot (BIT6))
                    {
                        Or (Local0, 0x40, Local0)
                    }
 
                    If (BIT7)
                    {
                        Or (Local0, 0x80, Local0)
                    }
                }   //  End Else DWRD zeroed out
 
                Return (Local0)
            }   //  MBIT:   Test single bit memory accesses
 
            Method (TEST)
            {
 
                Store ("++++++++ BitIndex Test", Debug)
 
                //  Zero out DWRD
                Store (0x00000000, DWRD)
 
                //  MBIT returns zero if successful
                //  This may be causing problems -- Return (MBIT)
                Store (MBIT, Local0)
 
                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, 13)
        Name (C175, 8)
 
        Device (C158)
        {   //  C158:   AC Adapter device
            Name (_HID, "ACPI0003") //  AC Adapter device
            Name (_PCL, Package (1) {\_SB})
 
            Method (_PSR)
            {
                Acquire (\_GL, 0xFFFF)
                Release (\_GL)
                And (Local0, 1, Local0) //  Local0 &= 1
                Return (Local0)
            }   //  _PSR
        }   //  C158:   AC Adapter device
 
        Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"})
 
        Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F})
 
        Name (C178, Package (4)
        {
            Package (4) {0, 0, 0x966B, 0x4190},
            Package (4) {0, 0, 0x966B, 0x4190},
            Package (4) {0, 0, 0x966B, 0x4190},
            Package (4) {0, 0, 0x966B, 0x4190}
        })  //  C178
 
        Name (C179, Package (4) {0, 0, 0x966B, 0x4190})
 
        Name (C17A, Package (4)
        {
            Package (3) {0, 0, 0},
            Package (3) {0, 0, 0},
            Package (3) {0, 0, 0},
            Package (3) {0, 0, 0}
        })  //  C17A
 
        Method (C17B, 1)
        {   //  C17B:   _BIF implementation
            Name (C17C, Package (13)
            {   //  C17C:   _BIF control method return package
                0,                  //  Power Unit (0 ==> mWh and mW)
                0x99F5,         //  Design Capacity
                0x99F5,         //  Last Full Charge Capacity
                1,                  //  Battery Technology (1 ==> rechargeable)
                0x3840,         //  Design Voltage
                0x1280,         //  Design Capacity of Warning
                0x0AC7,         //  Design Capacity of Low
                1,                  //  Battery Capacity Granularity 1 (Low -- Warning)
                1,                  //  Battery Capacity Granularity 2 (Warning -- Full)
                "2891",         //  Model Number (ASCIIZ)
                "(-Unknown-)",  //  Serial Number (ASCIIZ)
                "LIon",         //  Battery Type (ASCIIZ)
                0                   //  OEM Information (ASCIIZ)
            })  //  C17C:   _BIF control method return package
 
            And (Arg0, 7, Local0)                       //  Local0 = Arg0 & 7
 
            ShiftRight (Local0, 1, Local4)          //  Local4 = Local0 >> 1
 
            Store (C179, Index (C178, Local4, ))    //  C178->Local4 = 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)
            Store (0x1234, Index (C179, 2, ))               //  C179[2] = 0x1234
            Store (DerefOf (Index (C179, 2, )), Local2) //  Local2 = C179[2]
            if (LNotEqual (Local2, 0x1234))
                {   Return (0x1234) }
                                                                        //  Local2 = C178[0,2]
            Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2)
            if (LNotEqual (Local2, 0x966B))
                {   Return (0x1234) }
 
            // Restore data to allow iterative execution
            Store (0x966B, Index (C179, 2, ))               //  C179[2] = 0x966B
 
                                                                        //  C178[0,3] = 0x5678
            Store (0x5678, Index (DerefOf (Index (C178, 0, )), 3, ))
                                                                        //  Local2 = C178[0,3]
            Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 3, )), Local2)
            if (LNotEqual (Local2, 0x5678))
                {   Return (0x5678) }
 
            Store (DerefOf (Index (C179, 3, )), Local2) //  Local2 = C179[3]
            if (LNotEqual (Local2, 0x4190))
                {   Return (0x5678) }
 
            // Restore data to allow iterative execution
            Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, ))    //  C179[2] = 0x4190
 
            Return (C17C)
        }   //  C17B:   _BIF implementation
 
        Device (C154)
        {   //  C154:   Battery 0
            Name (_HID, "*PNP0C0A")     //  Control Method Battey ID
            Name (_UID, 0)                  //  first instance
 
            Method (_BIF)
            {   //  _BIF
                Return (C17B (48))
            }   //  _BIF
        }   //  C154:   Battery 0
 
        Device (IDX3)
        {
            Method (LCLB)
            {   //  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 ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
 
                //  save PKG into Local1
                Store (BUFR, Local1)
 
                //  save Local2 object type value into Local3
                Store (ObjectType (Local1), Local3)
 
                //  validate Local1 is a Buffer
                If (LNotEqual (Local3, 3))      //  Buffer type is 3
                    {   Return (0x9F)   }
 
 
                Store (0, Local0)
                While (LLess (Local0, 5))
                {   //  While (Local0 < 5)
                    //  Local2 = Local1[Local0]
                    Store (DerefOf (Index (Local1, Local0, )), Local2)
 
                    //  save Local2 object type value into Local3
                    Store (ObjectType (Local2), Local3)
 
                    //  validate Local2 is a Number
                    If (LNotEqual (Local3, 1))      //  Number type is 1
                        {   Return (0x9E)   }
 
                    //  validate Local1[Local0] value == Local0
                    If (LNotEqual (Local0, Local2))
                    {   //  Local0 != Local2 == PKG[Local0]
                        //  Local4 = 0x90 + loop index (Local0)
                        Add (0x90, Local0, Local4)
 
                        //  return 0x90 + loop index
                        Return (Local4)
                    }
 
                    Increment (Local0)
                }   //  While (Local0 < 5)
 
                Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug)
 
                Return (0)  //  Pass
            }   //  LCLB control method: test Index(Local#) where Local# is buffer
 
            Method (LCLP)
            {   //  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 ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
 
                //  save PKG into Local1
                Store (PKG, Local1)
 
                //  save Local2 object type value into Local3
                Store (ObjectType (Local1), Local3)
 
                //  validate Local1 is a Package
                If (LNotEqual (Local3, 4))      //  Package type is 4
                    {   Return (0x8F)   }
 
 
                Store (0, Local0)
                While (LLess (Local0, 5))
                {   //  While (Local0 < 5)
                    //  Local2 = Local1[Local0]
                    Store (DerefOf (Index (Local1, Local0, )), Local2)
 
                    //  save Local2 object type value into Local3
                    Store (ObjectType (Local2), Local3)
 
                    //  validate Local2 is a Number
                    If (LNotEqual (Local3, 1))      //  Number type is 1
                        {   Return (0x8E)   }
 
                    //  validate Local1[Local0] value == Local0
                    If (LNotEqual (Local0, Local2))
                    {   //  Local0 != Local2 == PKG[Local0]
                        //  Local4 = 0x80 + loop index (Local0)
                        Add (0x80, Local0, Local4)
 
                        //  return 0x80 + loop index
                        Return (Local4)
                    }
 
                    Increment (Local0)
                }   //  While (Local0 < 5)
 
                Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug)
 
                Return (0)  //  Pass
            }   //  LCLP control method: test Index(Local#) where Local# is package
 
            Method (TEST)
            {
 
                Store ("++++++++ IndexOp3 Test", Debug)
 
                //  store _BIF package return value into Local0
                Store (\_SB.C154._BIF, Local0)
 
                //  save Local0 object type value into Local1
                Store (ObjectType (Local0), Local1)
 
                //  validate Local0 is a Package
                If (LNotEqual (Local1, 4))      //  Package type is 4
                {   //  failure: did not return a Package (type 4)
                    //  if Local0 is a Number, it contains an error code
                    If (LEqual (Local1, 1))     //  Number type is 1
                        {   Return (Local0) }   //  return Local0 error code
                    Else                                //  Local0 is not a Number
                        {   Return (1)  }           //  return default error code
                }   //  failure: did not return a Package (type 4)
 
                //  save LCLB control method return value into Local2
                Store (LCLB, Local2)
                If (LNotEqual (Local2, 0))
                    {   Return (Local2) }   //  return failure code
 
                //  save LCLP control method return value into Local2
                Store (LCLP, Local2)
                If (LNotEqual (Local2, 0))
                    {   Return (Local2) }   //  return failure code
 
                Return (0)  //  Pass
            }   //  TEST
        }   //  IDX3:   Test device name
    }   //  _SB system bus
 
//
// MTL developed test to exercise Indexes into buffers
//
    Device(IDX7)
    {
 
        Name (PKG4, Package() {
                0x2,
                "A short string",
                Buffer() {0xA, 0xB, 0xC, 0xD},
                0x1234,
                Package() {IDX7, 0x3}
                })
 
        //
        // Generic Test method
        //
        // This test returns 0xE (14) - ObjectType = Buffer Field
        Method(TST1)
        {
            Name (DEST, Buffer ()                           //  62 characters plus NULL
                {"Destination buffer that is longer than the short source buffer"})
 
            //  verify object type returned by Index(Buffer,Element,)
            Store (Index (DEST, 2, ), Local1)
            Store (ObjectType (Local1), Local2)
            If (LEqual(Local2, 14))
            {
                Return(0)
            }
            Else
            {
                Return(0x1)
            }
 
        }
 
        Method(TST2)
        {
            Name (BUF0, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
            Store(0x55, Index(BUF0, 2))
            Store(DerefOf(Index(BUF0, 2)), Local0)
            If (LEqual(Local0, 0x55))
            {
                Return(0)
            }
            Else
            {
                Return(0x2)
            }
 
 
        }
 
        Method(TST3)
        {
            Name (BUF1, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
            Store(Index(BUF1, 1), Local0)
            Store(DerefOf(Local0), Local1)
            If (LEqual(Local1, 0x2))
            {
                Return(0)
            }
            Else
            {
                Return(0x3)
            }
 
        }
 
        Method(TST4)
        {
            // Index (PKG4, 0) is a Number
            Store (Index (PKG4, 0), Local0)
            Store (ObjectType(Local0), Local1)
            If (LEqual(Local1, 0x1))
            {
                Return(0)
            }
            Else
            {
                Return(0x4)
            }
 
        }
 
        Method(TST5)
        {
            // Index (PKG4, 1) is a String
            Store (Index (PKG4, 1), Local0)
            Store (ObjectType(Local0), Local1)
            If (LEqual(Local1, 0x2))
            {
                Return(0)
            }
            Else
            {
                Return(0x5)
            }
 
        }
 
        Method(TST6)
        {
            // Index (PKG4, 2) is a Buffer
            Store (Index (PKG4, 2), Local0)
            Store (ObjectType(Local0), Local1)
            If (LEqual(Local1, 0x3))
            {
                Return(0)
            }
            Else
            {
                Return(0x6)
            }
 
        }
 
        Method(TST7)
        {
            // Index (PKG4, 3) is a Number
            Store (Index (PKG4, 3), Local0)
            Store (ObjectType(Local0), Local1)
            If (LEqual(Local1, 0x1))
            {
                Return(0)
            }
            Else
            {
                Return(0x7)
            }
 
        }
 
        Method(TST8)
        {
            // Index (PKG4, 4) is a Package
            Store (Index (PKG4, 4), Local0)
            Store (ObjectType(Local0), Local1)
            If (LEqual(Local1, 0x4))
            {
                Return(0)
            }
            Else
            {
                Return(0x8)
            }
 
        }
 
        Method(TST9)
        {
            // DerefOf (Index (PKG4, 0)) is a Number
            Store (DerefOf (Index (PKG4, 0)), Local0)
            If (LEqual(Local0, 0x2))
            {
                Return(0)
            }
            Else
            {
                Return(0x9)
            }
 
        }
 
        Method(TSTA)
        {
            // DerefOf (Index (PKG4, 1)) is a String
            Store (DerefOf (Index (PKG4, 1)), Local0)
            Store (SizeOf(Local0), Local1)
            If (LEqual(Local1, 0xE))
            {
                Return(0)
            }
            Else
            {
                Return(0xA)
            }
 
        }
 
        Method(TSTB)
        {
            // DerefOf (Index (PKG4, 2)) is a Buffer
            Store (DerefOf (Index (PKG4, 2)), Local0)
            Store (SizeOf(Local0), Local1)
            If (LEqual(Local1, 0x4))
            {
                Return(0)
            }
            Else
            {
                Return(0xB)
            }
 
        }
 
        Method(TSTC)
        {
            // DerefOf (Index (PKG4, 3)) is a Number
            Store (DerefOf (Index (PKG4, 3)), Local0)
            If (LEqual(Local0, 0x1234))
            {
                Return(0)
            }
            Else
            {
                Return(0xC)
            }
 
        }
 
        Method(TSTD)
        {
            // DerefOf (Index (PKG4, 4)) is a Package
            Store (DerefOf (Index (PKG4, 4)), Local0)
            Store (SizeOf(Local0), Local1)
            If (LEqual(Local1, 0x2))
            {
                Return(0)
            }
            Else
            {
                Return(0xD)
            }
 
        }
 
        Method(TSTE)
        {
            // DerefOf (Index (PKG4, 2)) is a Buffer
            Store (DerefOf (Index (PKG4, 2)), Local0)
            // DerefOf (Index (Local0, 1)) is a Number
            Store (DerefOf (Index (Local0, 1)), Local1)
            If (LEqual(Local1, 0xB))
            {
                Return(0)
            }
            Else
            {
                Return(0xE)
            }
 
        }
 
        Method (TSTF)
        {
            Name (SRCB, Buffer (12) {}) //  12 characters
            Store ("Short Buffer", SRCB)
 
            Name (DEST, Buffer ()                       //  62 characters plus NULL
                {"Destination buffer that is longer than the short source buffer"})
 
            //  overwrite DEST contents, starting at buffer position 2
            Store (SRCB, Index (DEST, 2))
 
            //
            //  The DEST buffer element should be replaced with the last element of
            //      the SRCB element (i.e. 's'->'r')
            Store (DerefOf (Index (DEST, 2)), Local0)
 
            If (LNotEqual (Local0, 0x72))       //  'r'
            {
                //  DEST element does not match the value from SRCB
                Return(Or(Local0, 0x1000))
            }
 
            Return(0)
        }
 
        Method (TSTG)
        {
 
            Name (SRCB, Buffer (12) {}) //  12 characters
            Store ("Short Buffer", SRCB)
 
            Name (DEST, Buffer ()                       //  62 characters plus NULL
                {"Destination buffer that is longer than the short source buffer"})
 
            //  overwrite DEST contents, starting at buffer position 2
            Store (SRCB, Index (DEST, 2))
 
            //
            // The next element of DEST should be unchanged
            //
            Store (DerefOf (Index (DEST, 3)), Local0)
 
            If (LNotEqual (Local0, 0x74))       //  't'
            {
                //  DEST has been changed
                Return(Or(Local0, 0x2000))
            }
 
            //
            // The next element of DEST should be unchanged
            //
            Store (DerefOf (Index (DEST, 4)), Local0)
 
            If (LNotEqual (Local0, 0x69))       //  'i'
            {
                //  DEST has been changed
                Return(Or(Local0, 0x2100))
            }
 
            //
            // The next element of DEST should be unchanged
            //
            Store (DerefOf (Index (DEST, 5)), Local0)
 
            If (LNotEqual (Local0, 0x6E))       //  'n'
            {
                //  DEST has been changed
                Return(Or(Local0, 0x2200))
            }
 
            //
            // The next element of DEST should be unchanged
            //
            Store (DerefOf (Index (DEST, 6)), Local0)
 
            If (LNotEqual (Local0, 0x61))       //  'a'
            {
                //  DEST has been changed
                Return(Or(Local0, 0x2300))
            }
 
            //
            // The next element of DEST should be unchanged
            //
            Store (DerefOf (Index (DEST, 7)), Local0)
 
            If (LNotEqual (Local0, 0x74))       //  't'
            {
                //  DEST has been changed
                Return(Or(Local0, 0x2400))
            }
 
            //
            //  Verify DEST elements beyond end of SRCB buffer copy
            //  have not been changed
            Store (DerefOf (Index (DEST, 14)), Local0)
 
            If (LNotEqual (Local0, 0x66))       // 'f'
            {
                //  DEST has been changed
                Return(Or(Local0, 0x2400))
            }
 
            Return(0)
        }
 
        //
        // 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)
        {
            // Create a Destination Buffer
            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
 
            // Store a number > UINT8 into an index of the buffer
            Store (0x12345678, Index(DBUF, 2))
 
            // Check the results
            Store (DerefOf (Index (DBUF, 2)), Local0)
            If (LNotEqual (Local0, 0x78))   // 0x78
            {
                Return(Or(Local0, 0x3000))
            }
 
            Store (DerefOf (Index (DBUF, 3)), Local0)
            If (LNotEqual (Local0, 0x64))   // 'd'
            {
                Return(Or(Local0, 0x3100))
            }
 
            Store (DerefOf (Index (DBUF, 4)), Local0)
            If (LNotEqual (Local0, 0x65))   // 'e'
            {
                Return(Or(Local0, 0x3200))
            }
 
            Store (DerefOf (Index (DBUF, 5)), Local0)
            If (LNotEqual (Local0, 0x66))   // 'f'
            {
                Return(Or(Local0, 0x3300))
            }
 
            Return(0)
        }
 
        Method (TSTI)
        {
            // Create a Destination Buffer
            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
 
            // Store a String into an index of the buffer
            Store ("ABCDEFGH", Index(DBUF, 2))
 
            // Check the results
            Store (DerefOf (Index (DBUF, 2)), Local0)
            If (LNotEqual (Local0, 0x48))   // 'H'
            {
                Return(Or(Local0, 0x4000))
            }
 
            Store (DerefOf (Index (DBUF, 3)), Local0)
            If (LNotEqual (Local0, 0x64))   // 'd'
            {
                Return(Or(Local0, 0x4100))
            }
 
            Store (DerefOf (Index (DBUF, 4)), Local0)
            If (LNotEqual (Local0, 0x65))   // 'e'
            {
                Return(Or(Local0, 0x4200))
            }
 
            Store (DerefOf (Index (DBUF, 5)), Local0)
            If (LNotEqual (Local0, 0x66))   // 'f'
            {
                Return(Or(Local0, 0x4300))
            }
 
            Return(0)
        }
 
        Method(TSTJ)
        {
            // Create a Destination Buffer
            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
 
            // Store a number > UINT8 into an index of the buffer
            Store (0x1234, Index(DBUF, 2))
 
            // Check the results
            Store (DerefOf (Index (DBUF, 2)), Local0)
            If (LNotEqual (Local0, 0x34))   // 0x34
            {
                Return(Or(Local0, 0x3000))
            }
 
            Store (DerefOf (Index (DBUF, 3)), Local0)
            If (LNotEqual (Local0, 0x64))   // 'd'
            {
                Return(Or(Local0, 0x3100))
            }
 
            Store (DerefOf (Index (DBUF, 4)), Local0)
            If (LNotEqual (Local0, 0x65))   // 'e'
            {
                Return(Or(Local0, 0x3200))
            }
 
            Store (DerefOf (Index (DBUF, 5)), Local0)
            If (LNotEqual (Local0, 0x66))   // 'f'
            {
                Return(Or(Local0, 0x3300))
            }
 
            Return(0)
        }
 
        Method(TSTK)
        {
            // Create a Destination Buffer
            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
 
            // Store a number > UINT8 into an index of the buffer
            Store (0x123456, Index(DBUF, 2))
 
            // Check the results
            Store (DerefOf (Index (DBUF, 2)), Local0)
            If (LNotEqual (Local0, 0x56))   // 0x56
            {
                Return(Or(Local0, 0x3000))
            }
 
            Store (DerefOf (Index (DBUF, 3)), Local0)
            If (LNotEqual (Local0, 0x64))   // 'd'
            {
                Return(Or(Local0, 0x3100))
            }
 
            Store (DerefOf (Index (DBUF, 4)), Local0)
            If (LNotEqual (Local0, 0x65))   // 'e'
            {
                Return(Or(Local0, 0x3200))
            }
 
            Store (DerefOf (Index (DBUF, 5)), Local0)
            If (LNotEqual (Local0, 0x66))   // 'f'
            {
                Return(Or(Local0, 0x3300))
            }
 
            Return(0)
        }
 
        Method(TSTL)
        {
            // Create a Destination Buffer
            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
 
            // Store a number > UINT8 into an index of the buffer
            Store (0x12, Index(DBUF, 2))
 
            // Check the results
            Store (DerefOf (Index (DBUF, 2)), Local0)
            If (LNotEqual (Local0, 0x12))   // 0x12
            {
                Return(Or(Local0, 0x3000))
            }
 
            Store (DerefOf (Index (DBUF, 3)), Local0)
            If (LNotEqual (Local0, 0x64))   // 'd'
            {
                Return(Or(Local0, 0x3100))
            }
 
            Store (DerefOf (Index (DBUF, 4)), Local0)
            If (LNotEqual (Local0, 0x65))   // 'e'
            {
                Return(Or(Local0, 0x3200))
            }
 
            Store (DerefOf (Index (DBUF, 5)), Local0)
            If (LNotEqual (Local0, 0x66))   // 'f'
            {
                Return(Or(Local0, 0x3300))
            }
 
            Return(0)
        }
 
        Method(TEST)
        {
            Store ("++++++++ IndexOp7 Test", Debug)
 
            Store(TST1(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST2(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST3(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST4(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST5(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST6(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST7(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST8(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TST9(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTA(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTB(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTC(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTD(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTE(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
    /* No longer ACPI compliant */
    /*
            Store(TSTF(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
    */
 
            Store(TSTG(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTH(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
    /* No longer ACPI compliant */
    /*
            Store(TSTI(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
    */
            Store(TSTJ(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTK(), Local0)
            if (LGreater (Local0, 0))
            {
                Return(Local0)
            }
 
            Store(TSTL(), Local0)
            if (LGreater (Local0, 0))
            {
                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)
        {
            Store ("++++++++ MatchOp Test", Debug)
 
            Name (TIM0, Package ()
                {
                    Package ()  {0x78, 0xB4, 0xF0, 0x0384},
                    Package ()  {0x23, 0x21, 0x10, 0},
                    Package ()  {0x0B, 9, 4, 0},
                    Package ()  {0x70, 0x49, 0x36, 0x27, 0x19},
                    Package ()  {0, 1, 2, 1, 2},
                    Package ()  {0, 0, 0, 1, 1},
                    Package ()  {4, 3, 2, 0},
                    Package ()  {2, 1, 0, 0}
                })  //  TIM0
 
            Name (TMD0, Buffer (20) {0xFF, 0xFF, 0xFF, 0xFF })
            CreateDWordField (TMD0, 0, PIO0)    //  0xFFFFFFFF
            CreateDWordField (TMD0, 4, DMA0)
            CreateDWordField (TMD0, 8, PIO1)
            CreateDWordField (TMD0, 12, DMA1)
            CreateDWordField (TMD0, 16, CHNF)
 
 
            //  validate PIO0 value
            Store (PIO0, Local3)
 
            //  save Local3 object type value into Local2
            Store (ObjectType (Local3), Local2)
 
            //  validate Local3 is a Number
            If (LNotEqual (Local2, 1))  //  Number type is 1
                {   Return (2)  }   //  failure
 
            //  validate Local3 Number value
            If (LNotEqual (Local3, 0xFFFFFFFF)) //  Number value 0xFFFFFFFF
                {   Return (3)  }   //  failure
 
            Store ("DWordField PASS", Debug)
 
 
            Store (0, Local5)
            Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6)
 
            //  save Local6 object type value into Local2
            Store (ObjectType (Local6), Local2)
 
            //  validate Local6 is a Number
            If (LNotEqual (Local2, 1))  //  Number type is 1
                {   Return (4)  }   //  failure
 
            Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug)
 
 
            //  validate following produces a nested package to validate
            //  that MatchOp did not corrupt SearchPackage (TIM0)
            Store (DerefOf (Index (TIM0, 1, )), Local4)
 
            //  save Local4 object type value into Local2
            Store (ObjectType (Local4), Local2)
 
            //  validate Local4 is a Package
            If (LNotEqual (Local2, 4))  //  Package type is 4
                {   Return (5)  }   //  failure
 
            Store ("DerefOf(Index(TIM0,1)),... PASS", Debug)
 
 
            And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0)
 
            //  save Local0 object type value into Local2
            Store (ObjectType (Local0), Local2)
 
            //  validate Local0 is a Number
            If (LNotEqual (Local2, 1))  //  Number type is 1
                {   Return (6)  }   //  failure
 
            //  validate Local0 Number value
            If (LNotEqual (Local0, 3))  //  Number value 3
                {   Return (7)  }   //  failure
 
            Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug)
 
 
            //  again, validate following produces a nested package
            Store (DerefOf (Index (TIM0, 1, )), Local4)
 
            //  save Local4 object type value into Local2
            Store (ObjectType (Local4), Local2)
 
            //  validate Local4 is a Package
            If (LNotEqual (Local2, 4))  //  Package type is 4
                {   Return (8)  }   //  failure
 
            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
 
 
            //  again, validate following produces a nested package
            Store (DerefOf (Index (TIM0, 1, )), Local4)
 
            //  save Local4 object type value into Local2
            Store (ObjectType (Local4), Local2)
 
            //  validate Local4 is a Package
            If (LNotEqual (Local2, 4))  //  Package type is 4
                {   Return (9)  }   //  failure
 
            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
 
 
            //  test nested DerefOf(Index) operators
            Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), 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
                {   Return (10) }   //  failure
 
            //  zero indicates pass, non-zero is an error code
            If (LNotEqual (Local1, 0))
                {   Return (11) }   //  failure
 
            Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug)
 
 
            //  again, validate following produces a nested package
            Store (DerefOf (Index (TIM0, 1, )), Local4)
 
            //  save Local4 object type value into Local2
            Store (ObjectType (Local4), Local2)
 
            //  validate Local4 is a Package
            If (LNotEqual (Local2, 4))  //  Package type is 4
                {   Return (12) }   //  failure
 
            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
 
 
            //  retest nested DerefOf(Index) operators
            Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), 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
                {   Return (13) }   //  failure
 
            //  zero indicates pass, non-zero is an error code
            If (LNotEqual (Local1, 0))
                {   Return (14) }   //  failure
 
            Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug)
 
 
            //  again, validate following produces a nested package
            Store (DerefOf (Index (TIM0, 1, )), Local4)
 
            //  save Local4 object type value into Local2
            Store (ObjectType (Local4), Local2)
 
            //  validate Local4 is a Package
            If (LNotEqual (Local2, 4))  //  Package type is 4
                {   Return (15) }   //  failure
 
            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
 
 
            Return (0)  //  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, 0)
        Name (CNT1, 0)
 
        Method (TEST)
        {
            //  Check Break statement nested in If nested in While nested in
            //  While only exits inner-most While loop
            Store (0, CNT0)
 
            While (LLess (CNT0, 4))
            {
                Store (0, CNT1)
                While (LLess (CNT1, 10))
                {
                    if (LEqual (CNT1, 1))
                    {
                        Break       //  exit encompassing loop
                    }
 
                    Increment (CNT1)
                }
 
                If (LNotEqual (CNT1, 1))
                {
                    //  failure
                    Return (7)
                }
 
                Increment (CNT0)
            }
 
            //  Verify Break only exited inner-most While loop
 
            If (LNotEqual (CNT0, 4))
            {
                //  failure
                Return (8)
            }
 
            Store ("While/While/If/Break PASS", Debug)
 
            Store ("++++++++ WhileBrk Test", Debug)
 
            //  Check Break statement nested in While
            Store (0, CNT0)
 
            While (LLess (CNT0, 10))
            {
                Break       //  exit encompassing package
                Increment (CNT0)
            }
 
            If (LNotEqual (CNT0, 0))    //  instruction after Break executed
            {
                Return (4)
            }
 
 
            Store (0, CNT0)
 
            //  Test While Term
            While (LLess (CNT0, 10))
            {
                Increment (CNT0)
            }
 
            //  Check if the while loop was executed until the condition is satisfied.
            If (LNotEqual (CNT0, 10))
            {
                Return (1)
            }
 
 
            //  While loop in a reverse order
            While (LGreater (CNT0, 0))
            {
                Decrement (CNT0)
            }
 
            //  Check if the while loop was executed until the condition is satisfied.
            If (LNotEqual (CNT0, 0))
            {
                Return (2)
            }
 
 
            Store ("While/Break PASS", Debug)
 
 
            //  Check Break statement nested in If nested in While
            Store (0, CNT0)
 
            While (LLess (CNT0, 10))
            {
                if (LEqual (CNT0, 5))
                {
                    Break       //  exit encompassing Package (If)
 
                    //  if we execute the next instruction,
                    //  Break did not exit the loop
                    Store (20, CNT0)    //  exit While loop with value larger
                                            //  than above
                }
 
                Increment (CNT0)    //  check if Break exited both If and While
            }   //  While
 
            If (LGreater (CNT0, 19))
            {   //  instruction after Break inside IfOp executed
                Return (5)
            }
 
            //
            // Break will exit out of the while loop, therefore
            //  the CNT0 counter should still Increment until 5
            //
            If (LNotEqual (CNT0, 5))
            {   //  instruction after Break inside WhileOp executed
                Return (6)
            }
            Store ("While/If/Break PASS", Debug)
 
 
            //  All the conditions passed
            Return (0)
        }   //  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, 0x010CD041)
            Name (_STA, 0x0F)
 
            OperationRegion (SMEM, SystemMemory, 0x800000, 0x100)
            Field (SMEM, AnyAcc, NoLock, Preserve)
            {   //  Field:  SMEM overlay using 32-bit field elements
                SMD0,   32, //  32-bits
                SMD1,   32,     //  32-bits
                SMD2,   32,     //  32-bits
                SMD3,   32  //  32-bits
            }   //  Field:  SMEM overlay using 32-bit field elements
            Field (SMEM, AnyAcc, NoLock, Preserve)
            {   //  Field:  SMEM overlay using greater than 32-bit field elements
                SME0,   69, //  larger than an integer (32 or 64)
                SME1,   97  //  larger than an integer
            }   //  Field:  SMEM overlay using greater than 32-bit field elements
 
            OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
            Field (SRAM, AnyAcc, NoLock, Preserve)
            {   //  Field:  SRAM overlay
                    ,   0x34000,    //  skip
                IEAX,   0x20,
                IEBX,   0x20,
                IECX,   0x20,
                IEDX,   0x20,
                IESI,   0x20,
                IEDI,   0x20,
                IEBP,   0x20,
                    ,   0x20,
                OEAX,   0x20,
                OEBX,   0x20,
                OECX,   0x20,
                OEDX,   0x20,
                OESI,   0x20,
                OEDI,   0x20,
                OEBP,   0x20,
                    ,   0x618,  //  skip
                ACST,   1,
                BES1,   1,
                BES2,   1,
                    ,   5,          //  skip
                BMN1,   0x68,
                BSN1,   0x58,
                BTP1,   0x48,
                BPU1,   0x20,
                BDC1,   0x20,
                BLF1,   0x20,
                BTC1,   0x20,
                BDV1,   0x20,
                BST1,   0x20,
                BPR1,   0x20,
                BRC1,   0x20,
                BPV1,   0x20,
                    ,   0x20,
                BCW1,   0x20,
                BCL1,   0x20,
                BG11,   0x20,
                BG21,   0x20,
                BOI1,   0x20,
                    ,   0x530,  //  skip
                BMN2,   0x68,
                BSN2,   0x58,
                BTP2,   0x48,
                BPU2,   0x20,
                BDC2,   0x20,
                BLF2,   0x20,
                BTC2,   0x20,
                BDV2,   0x20,
                BST2,   0x20,
                BPR2,   0x20,
                BRC2,   0x20,
                BPV2,   0x20,
                    ,   0x20,
                BCW2,   0x20,
                BCL2,   0x20,
                BG12,   0x20,
                BG22,   0x20,
                BOI2,   0x20,
                    ,   0x518,  //  skip
                AC01,   0x10,
                AC11,   0x10,
                PSV1,   0x10,
                CRT1,   0x10,
                TMP1,   0x10,
                AST1,   0x10,
                AC21,   0x10,
                AC31,   0x10,
                AC02,   0x10,
                AC12,   0x10,
                PSV2,   0x10,
                CRT2,   0x10,
                TMP2,   0x10,
                AST2,   0x10,
                AC22,   0x10,
                AC32,   0x10,
                AC03,   0x10,
                AC13,   0x10,
                PSV3,   0x10,
                CRT3,   0x10,
                TMP3,   0x10,
                AST3,   0x10,
                AC23,   0x10,
                AC33,   0x10,
                    ,   0x80,       //  skip
                TMPF,   0x10,
                    ,   0x570,  //  skip
                FANH,   1,
                FANL,   7,
                TF11,   1,
                TF21,   1,
                TF31,   1,
                    ,   1,
                TF10,   1,
                TF20,   1,
                TF30,   1,
                    ,   1,
                TP11,   1,
                TP21,   1,
                TP31,   1,
                    ,   0x6D,   //  109
                GP50,   1,
                GP51,   1,
                GP52,   1,
                GP53,   1,
                    ,   4,
                GP60,   1,
                GP61,   1,
                GP62,   1,
                GP63,   1,
                GP64,   1,
                GP65,   1,
                GP66,   1,
                    ,   1,
                GP70,   1,
                GP71,   1,
                GP72,   1,
                GP73,   1,
                GP74,   1,
                GP75,   1,
                GP76,   1,
                    ,   1,
                WED0,   1,
                WED1,   1,
                WED2,   1,
                WED3,   1,
                WED4,   1,
                    ,   3,
                SBL0,   1,
                SBL1,   1,
                SBL2,   1,
                SBL3,   1,
                    ,   4,
                LIDS,   1,
                VALF,   1,
                    ,   2,
                DCKI,   1,
                DCKF,   1,
                BT1F,   1,
                BT2F,   1,
                    ,   0x7D0,  //  skip
                HKCD,   8,
                    ,   8,
                DLID,   0x20,
                DSRN,   0x20,
                    ,   0x20,
                BDID,   0x20,
                DSPW,   1,
                VGAF,   1,
                VWE0,   1,
                VWE1,   1,
                PPSC,   1,
                SPSC,   1,
                EWLD,   1,
                EWPS,   1,
                    ,   0x1768, //  skip
                PRES,   0x8000
            }   //  Field:  SRAM overlay
        }   //  MEM
 
        Device (BAT1)
        {   //  BAT1
            Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
            Name (_UID, 1)
            Name (_PCL, Package (1) {\_SB})
 
            Method (_STA)
            {   //  _STA
                If (\_SB.MEM.BES1)
                    {   Return (0x1F)   }   //  battery present
                Else
                    {   Return (0x0F)   }   //  battery not present
            }   //  _STA
 
            Method (_BIF)
            {   //  _BIF
                Name (BUFR, Package (13)    {})
 
                Store (\_SB.MEM.BPU1, Index (BUFR, 0))
                Store (\_SB.MEM.BDC1, Index (BUFR, 1))
                Store (\_SB.MEM.BLF1, Index (BUFR, 2))
                Store (\_SB.MEM.BTC1, Index (BUFR, 3))
                Store (\_SB.MEM.BDV1, Index (BUFR, 4))
                Store (\_SB.MEM.BCW1, Index (BUFR, 5))
                Store (\_SB.MEM.BCL1, Index (BUFR, 6))
                Store (\_SB.MEM.BG11, Index (BUFR, 7))
                Store (\_SB.MEM.BG21, Index (BUFR, 8))
                Store (\_SB.MEM.BMN1, Index (BUFR, 9))
                Store (\_SB.MEM.BSN1, Index (BUFR, 10))
                Store (\_SB.MEM.BTP1, Index (BUFR, 11))
                Store (\_SB.MEM.BOI1, Index (BUFR, 12))
 
                Return (BUFR)
            }   //  _BIF
        }   //  BAT1
 
        Device (IDX2)
        {
            Method (B2IB)
            {   //  B2IB:   store from Buffer into Index'ed Buffer
 
                Name (SRCB, Buffer ()   {"Short Buffer"})   //  12 characters plus NULL
 
                Name (DEST, Buffer ()                           //  62 characters plus NULL
                    {"Destination buffer that is longer than the short source buffer"})
 
 
                //  verify object type returned by Index(Buffer,Element,)
 
                Store (Index (DEST, 2, ), Local1)
                Store (ObjectType (Local1), Local2)
 
                If (LNotEqual (Local2, 14))     //  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
 
                Store (DerefOf (Local1), Local3)
                Store (ObjectType (Local3), Local4)
 
                If (LNotEqual (Local4, 1))          //  Number is type 1
                {
                    //  Local2 indicates Local1 is not a Number
                    Return (0x62)
                }
                Else
                {
                    If (LNotEqual (Local3, 0x73))       //  expect 's' element from DEST
                    {
                        Return (0x63)
                    }
                }
 
                Store ("DerefOf(Index(Buffer,,)) PASS", Debug)
 
 
                //
                // 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]
 
                Store (SRCB, Index (DEST, 2, ))
 
                //
                // Check that the next byte is not changed
                //
                Store (DerefOf (Index (DEST, 3, )), Local0)
                If (LNotEqual (Local0, 0x74))       //  't'
                {
                    //  DEST element is not matching original value
                    If (LEqual (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.
                //
                Store (DerefOf (Index (DEST, 14)), Local0)
 
                //
                // This should be an 'f'.
                //
                If (LNotEqual (Local0, 0x66))
                {
                    //  DEST element was zero'd by buffer copy
                    If (LEqual (Local0, 0))
                    {
                        //  DEST element is zero
                        Return (0x6A)
                    }
                    Else
                    {
                        //  DEST element is unknown value
                        Return (0x6B)
                    }
                }
 
                Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug)
 
                //
                //  verify altering SRCB does NOT alter DEST
                //
                Store (0x6A, Index (SRCB, 1))   //  SRCB = "Sjort Buffer"
 
                Store (DerefOf (Index (SRCB, 1)), Local0)
 
                If (LNotEqual (Local0, 0x6A))       //  'j'
                {
                    //  SRCB element is unaltered
                    Return (0x71)
                }
 
                Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that...
 
                If (LNotEqual (Local0, 0x74))       //  't'
                {
                    //  DEST element is altered
                    If (LEqual (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
 
                Store (0x6B, Index (DEST, 4, )) //  DEST = "DeSkination buffer..."
 
                Store (DerefOf (Index (DEST, 4, )), Local0)
 
                If (LNotEqual (Local0, 0x6B))       //  'k'
                {
                    //  DEST element is unaltered
                    Return (0x74)
                }
 
                Store (DerefOf (Index (SRCB, 2, )), Local0)
 
                If (LNotEqual (Local0, 0x6F))       //  'o'
                {   //  SRC element is altered
                    If (LEqual (Local0, 0x6B))  //  'k'
                    {
                        //  DEST change altered SRCB element
                        Return (0x75)
                    }
                    Else
                    {
                        //  SRCB element is unknown value
                        Return (0x76)
                    }
                }
 
                Store ("SRCB and DEST independent PASS", Debug)
 
 
                // verify string can be written to Index target/destination
                // Only FIRST byte is written
 
                Store ("New Buff", Index (DEST, 2, ))   //  DEST = "DeNkination buffer..."
 
                Store (DerefOf (Index (DEST, 2, )), Local0)
 
                If (LNotEqual (Local0, 0x4E))       //  'N'
                {
                    //  DEST element is unaltered
                    Return (0x81)
                }
 
                Store (DerefOf (Index (DEST, 6, )), Local0)
 
                If (LNotEqual (Local0, 0x61))       //  'a'
                {
                    //  DEST element is unaltered
                    Return (0x82)
                }
 
                Store (DerefOf (Index (DEST, 10, )), Local0)
 
                If (LNotEqual (Local0, 0x6E))       //  'n'
                {
                    //  DEST element is unaltered
                    Return (0x83)
                }
 
                Store ("Store(String,Index) PASS", Debug)
 
 
                Return (0)  //  pass
            }   //  B2IB:   store from Buffer into Index'ed Buffer
 
            Method (FB2P)
            {   //  FB2P:   store from Field Buffer into Index'ed Package
                Name (DEST, Package (2) {})
 
                //  initialize memory using 32-bit field elements
                Store (0x01234567, \_SB.MEM.SMD0)
                Store (0x89ABCDEF, \_SB.MEM.SMD1)
                Store (0xFEDCBA98, \_SB.MEM.SMD2)
                Store (0x76543210, \_SB.MEM.SMD3)
 
                //  move greater than 64-bit buffers into DEST package
                Store (\_SB.MEM.SME0, Index (DEST, 0))
                Store (\_SB.MEM.SME1, Index (DEST, 1))
 
                //  validate DEST contents
                Store (DerefOf (Index (DEST, 0, )), Local0)
                Store (DerefOf (Index (DEST, 1, )), Local1)
 
                //  verify Local0 and Local1 are Buffers
                Store (ObjectType (Local0), Local2)
                if (LNotEqual (Local2, 3))  //  Buffer type is 3
                {
                    Return (0x11)
                }
 
                Store (ObjectType (Local1), Local3)
                if (LNotEqual (Local3, 3))  //  Buffer type is 3
                {
                    Return (0x12)
                }
 
                //  validate DEST buffer contents
                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4)
                If (LNotEqual (Local4, 0x67))
                {
                    Return (0x13)
                }
 
                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4)
                If (LNotEqual (Local4, 0x45))
                {
                    Return (0x14)
                }
 
                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4)
                If (LNotEqual (Local4, 0xEF))
                {
                    Return (0x15)
                }
 
                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4)
                If (LNotEqual (Local4, 0xCD))
                {
                    Return (0x16)
                }
 
                Store ("Store(Mem,PkgElement) PASS", Debug)
 
 
                //  validate changing source \_SB.MEM.SMD* does not impact DEST
                Store (0x12345678, \_SB.MEM.SMD0)
 
                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5)
                If (LNotEqual (Local5, 0x67))
                {
                    Return (0x21)
                }
 
                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5)
                If (LNotEqual (Local5, 0x45))
                {
                    Return (0x22)
                }
 
                //  validate changing DEST does not impact source \_SB.MEM.SMD*
                Store (0x30, Index (DerefOf (Index (DEST, 0)), 0))
 
                Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5)
                If (LNotEqual (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
                //
                Store (\_SB.MEM.SMD0, Local5)
 
                If(LNotEqual(Local5, 0x12345678))
                {
                    Return (0x24)
                }
 
                Store ("Mem and Pkg independent PASS", Debug)
 
 
                Return (0)
            }   //  FB2P:   store from Field Buffer into Index'ed Package
 
            Method (TEST)
            {
                Store ("++++++++ IndexOp2 Test", Debug)
 
                //  store _BIF package return value into Local0
 
                Store (\_SB.BAT1._BIF, Local0)
 
                //  save Local0 object type value into Local1
                Store (ObjectType (Local0), Local1)
 
                //  validate Local0 is a Package
                If (LNotEqual (Local1, 4))  //  Package type is 4
                {
                    //  failure
                    Return (2)
                }
 
                //  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)
                Store (B2IB, Local2)    //  Local2 is B2IB return value
 
                //  save Local2 object type value into Local3
                Store (ObjectType (Local2), Local3)
 
                //  validate Local2 is a Number
                If (LNotEqual (Local3, 1))  //  Number type is 1
                {
                    //  failure
                    Return (4)
                }
 
                //  zero indicates pass, non-zero is an error code
                If (LNotEqual (Local2, 0))
                {
                    //  return B2IB error code
                    Return (Local2)
                }
 
                //  call FB2P (store from Field Buffer into Index'ed Package)
                Store (FB2P, Local2)    //  Local2 is FB2P return value
 
                //  save Local2 object type value into Local3
                Store (ObjectType (Local2), Local3)
 
                //  validate Local2 is a Number
                If (LNotEqual (Local3, 1))  //  Number type is 1
                {
                    //  failure
                    Return (5)
                }
 
                //  zero indicates pass, non-zero is an error code
                If (LNotEqual (Local2, 0))
                {
                    //  return FB2P error code
                    Return (Local2)
                }
 
 
                Return (0)
            }   //  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)
        //  Arg0    object to determine size of
        //  Arg1    expected Arg length
        {   //  SAR0:   SizeOf(Arg) test control method
            //  Local0  Arg0 length
            //  Local1  Local0 object type
 
            //  Store first string size (Arg0) into Local7
            Store (SizeOf (Arg0), 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 (0x21)   }
 
            //  If strings are not of equal size, return error code
            If (LNotEqual (Local0, Arg1))
                {   Return (0x22)   }
 
            Return (0)
        }   //  SAR0:   SizeOf(Arg) test control method
 
        Method (SARG)
        {   //  SARG:   SizeOf(Arg) test control method
            Name (BUFR, Buffer (12) {}) //  uninitialized Buffer
            Name (BUF1, Buffer() {0x01, 0x02, 0x03, 0x04, 0x05})
            Name (PKG0, Package (4) {}) //  uninitialized Package
            Name (STR0, "String")
            Name (PKG1, Package (4)
            {
                BUFR,
                "String2",
                STR0,
                PKG0
            })  //  PKG1
 
            Name (PKG2, Package (4)
            {
                Buffer (15) {},
                "String 1",
                Package (2) {}
            })  //  PKG2
 
            //  Namespace entry buffer reference
            Store (SAR0 (BUFR, 12), 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 (0x23)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=BUFR) PASS", Debug)
 
 
            //  Namespace entry package reference
            Store (SAR0 (PKG0, 4), 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 (0x24)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=PKG0) PASS", Debug)
 
 
            //  Namespace entry string reference
            Store (SAR0 (STR0, 6), 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 (0x25)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=STR0) PASS", Debug)
 
 
            //  direct string reference
            Store (SAR0 ("String", 6), 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 (0x26)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=String) PASS", Debug)
 
            Store (0x55, Index (BUF1, 2))
 
            /****************************************************
            //
            // 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
            //
            Store (SAR0 (Index(PKG1, 0), 12), 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 (0x28)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug)
 
 
            //  Namespace StringPackageElement reference
            Store (SAR0 (Index (PKG1, 1, ), 7), 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 (0x29)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=Package String Element) PASS", Debug)
 
 
            //  Namespace StringPackageElement reference
            Store (SAR0 (Index (PKG1, 2, ), 6), 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 (0x2A)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug)
 
 
            //  Namespace PackagePackageElement reference
            Store (SAR0 (Index (PKG1, 3, ), 4), 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 (0x2B)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug)
 
            // Package Buffer Element
            Store (SAR0 (Index (PKG2, 0), 15), 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 (0x2B)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug)
 
            // Package String Element
            Store (SAR0 (Index (PKG2, 1), 8), 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 (0x2B)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=Package String Element) PASS", Debug)
 
            // Package Package Element
            Store (SAR0 (Index (PKG2, 2), 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 (0x2B)
            }
 
            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
            {
                Return (Local0)
            }
 
            Store ("SizeOf(Arg=Package Package Element) PASS", Debug)
 
            Store ("SizeOf(Arg) PASS", Debug)
 
            Return (0)
        }   //  SARG:   SizeOf(Arg) test control method
 
        Method (SBUF)
        {   //  SBUF:   SizeOf(Buffer) test control method
            Name (BUFR, Buffer (12) {})
 
            //  store size of BUFR buffer into Local0
            Store (SizeOf (BUFR), 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 (0x31)
            }
 
            If (LNotEqual (Local0, 12))     //  BUFR size is 12
            {
                Return (0x32)
            }
 
            Store ("SizeOf(BUFR) PASS", Debug)
 
            Return (0)
        }   //  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)
        {   //  SLOC:   SizeOf(Local) test control method
            Name (BUFR, Buffer (12) {}) //  uninitialized Buffer
            Name (STR0, "String")
            Name (PKG0, Package (4) {}) //  uninitialized Package
 
 
            //  store BUFR Buffer into Local2
            Store (BUFR, Local2)
 
            //  store size of BUFR buffer into Local0
            Store (SizeOf (Local2), 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 (0x51)
            }
 
            If (LNotEqual (Local0, 12)) //  BUFR size is 12
            {
                Return (0x52)
            }
 
            Store ("SizeOf(Local2=Buffer) PASS", Debug)
 
 
            //  store STR0 string into Local2
            Store (STR0, Local2)
 
            //  store size of STR0 buffer into Local0
            Store (SizeOf (Local2), 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 (0x53)
            }
 
            If (LNotEqual (Local0, 6))      //  STR0 size is 6
            {
                Return (0x54)
            }
 
            Store ("SizeOf(Local2=String) PASS", Debug)
 
 
            //  store PKG0 Package into Local2
            Store (PKG0, Local2)
 
            //  store size of PKG0 buffer into Local0
            Store (SizeOf (Local2), 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 (0x55)
            }
 
            If (LNotEqual (Local0, 4))      //  PKG0 size is 4
            {
                Return (0x56)
            }
 
            Store ("SizeOf(Local2=Package) PASS", Debug)
 
 
            Return (0)
        }   //  SLOC:   SizeOf(Local) test control method
 
        Method (TEST)
        {
            Store ("++++++++ SizeOf Test", Debug)
 
            //  Store current operating system string into Local0
            Store (_OS, Local0)
 
            Store (SizeOf (_OS), Local3)
 
            //  save Local3 object type value into Local4
            Store (ObjectType (Local3), Local4)
 
            //  validate Local3 is a Number
            If (LNotEqual (Local4, 1))  //  Number type is 1
            {
                //  failure
                Return (0x61)
            }
 
            //  Store current operating system string into Local0
            //  This verifies above SizeOf(_OS) did not corrupt ACPI namespace
            Store (_OS, Local0)
 
            //  Store SARG [Validate SizeOf(Arg)] return value into Local1
            Store (SARG, 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 (0x62)
            }
 
            //  zero indicates pass, non-zero is an error code
            If (LNotEqual (Local1, 0))
            {
                //  return SARG error code
                Return (Local1)
            }
 
 
            //  Store SBUF [Validate SizeOf(Buffer)] return value into Local1
            Store (SBUF, 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 (0x63)
            }
 
            //  zero indicates pass, non-zero is an error code
            If (LNotEqual (Local1, 0))
            {
                //  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
            Store (SLOC, 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 (0x65)
            }
 
            //  zero indicates pass, non-zero is an error code
            If (LNotEqual (Local1, 0))
            {
                //  return SLOC error code
                Return (Local1)
            }
 
 
            //  TBD:    SizeOf (METH) -- where METH control method returns
            //              buffer, BufferField, string, package, package element
 
 
            Return (0)
        }   //  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, 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
        }
 
        Device (MBIT)
        {
            Method (_INI)
            {
                Store (0, BI1T)
                Store (3, BI2T)
                Store (7, BI3T)
                Store (0, LST2)
            }   //  End _INI Method
        }   //  End Device MBIT
 
        Device (MWRD)
        {
            Method (_INI)
            {
                Store (0, WRD)
            }   //  End _INI Method
        }   //  End Device MWRD
 
        Device (MBYT)
        {
            Method (_INI)
            {
                Store (0, BYTE)
                Store (0xC, SMIC)
                Store (0xD, SMID)
            }   //  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)
        {
            Return (BYTE)
        }   //  End SMIX
 
        Method (EVNT)
        {
            Store (SMIX, Local0)
 
            If (And (Local0, 0x01))
            {   Notify (\_SB_.SMIS, 0x21)}
 
            If (And (Local0, 0x02))
            {   Notify (\_SB_.SMIS, 0x22)}
 
            If (And (Local0, 0x04))
            {   Notify (\_SB_.SMIS, 0x24)}
 
            If (And (Local0, 0x08))
            {   Notify (\_SB_.SMIS, 0x28)}
 
        }   //  End Method EVNT
 
        Device (SMIS)
        {
            Method (BINK)
            {
                Store (0, Local0)               //  Zero out Local0
 
                If (LNotEqual (SMID, 0xD))
                {   Or (0x80, Local0, Local0)}
 
                If (LNotEqual (SMIC, 0xC))
                {   Or (0x40, Local0, Local0)}
 
                If (LNotEqual (BYTE, 0))
                {   Or (0x20, Local0, Local0)}
 
                If (LNotEqual (WRD, 0))
                {   Or (0x10, Local0, Local0)}
 
                If (LNotEqual (LST2, 0))
                {   Or (0x8, Local0, Local0)}
 
                If (LNotEqual (BI3T, 0x7))
                {   Or (0x4, Local0, Local0)}
 
                If (LNotEqual (BI2T, 0x3))
                {   Or (0x2, Local0, Local0)}
 
                If (LNotEqual (BI1T, 0))
                {   Or (0x1, Local0, Local0)}
 
                Return (Local0)
            }   //  End Method BINK
 
            Method (TEST)
            {
                Store ("++++++++ SmiShare Test", Debug)
 
                //  Expect EVNT to generate Notify value we just previously
                //  stored in BYTE
                Store (0x20, BYTE)
                EVNT ()
                Store (0x21, BYTE)
                EVNT ()
                Store (0x22, BYTE)
                EVNT ()
                Store (0x23, BYTE)
                EVNT ()
 
                Return (0)  //  pass
            }   //  End Method TEST
        }   //  Device SMIS
 
        Device(CNDT)
        {
            Method(TEST)
            {
                If (ECOK)
                {
                    return("Broken")
                }
                Else
                {
                    return("Works")
                }
            }
 
            Method(ECOK)
            {
                Return(0x0)
            }
        }
 
    }   //  _SB system bus
 
 
/* Test a very big buffer */
 
    Name(WQAB, Buffer(6756)
    {
        0x46,0x4F,0x4D,0x42,0x01,0x00,0x00,0x00,
        0x54,0x1A,0x00,0x00,0xBA,0xAD,0x00,0x00,
        0x44,0x53,0x00,0x01,0x1A,0x7D,0xDA,0x54,
        0x98,0xBD,0x92,0x00,0x01,0x06,0x18,0x42,
        0x10,0x47,0x10,0x92,0x46,0x62,0x02,0x89,
        0x80,0x90,0x18,0x18,0x14,0x81,0x85,0x00,
        0x49,0x02,0x88,0xC4,0x41,0xE1,0x20,0xD4,
        0x9F,0x40,0x7E,0x05,0x20,0x74,0x28,0x40,
        0xA6,0x00,0x83,0x02,0x9C,0x22,0x88,0xA0,
        0x57,0x01,0x36,0x05,0x98,0x14,0x60,0x51,
        0x80,0x76,0x01,0x96,0x05,0xE8,0x16,0x20,
        0x1D,0x96,0x88,0x04,0x47,0x89,0x01,0x47,
        0xE9,0xC4,0x16,0x6E,0xD8,0xE0,0x85,0xA2,
        0x68,0x06,0x51,0x12,0x94,0x8B,0x20,0x5D,
        0x10,0x52,0x2E,0xC0,0x37,0x82,0x06,0x10,
        0xA5,0x77,0x01,0xB6,0x05,0x98,0x86,0x27,
        0xD2,0x20,0xE4,0x60,0x08,0x54,0xCE,0x80,
        0x20,0x69,0x44,0x21,0x1E,0xA7,0x44,0x08,
        0x0A,0x84,0x90,0xD4,0xF1,0xA0,0xA0,0x71,
        0x88,0xAD,0xCE,0x46,0x93,0xA9,0x74,0x7E,
        0x48,0x82,0x70,0xC6,0x2A,0x7E,0x3A,0x9A,
        0xD0,0xD9,0x9C,0x60,0xE7,0x18,0x72,0x3C,
        0x48,0xF4,0x20,0xB8,0x00,0x0F,0x1C,0x2C,
        0x34,0x84,0x22,0x6B,0x80,0xC1,0x8C,0xDD,
        0x63,0xB1,0x0B,0x4E,0x0A,0xEC,0x61,0xB3,
        0x01,0x19,0xA2,0x24,0x38,0xD4,0x11,0xC0,
        0x12,0x05,0x98,0x1F,0x87,0x0C,0x0F,0x95,
        0x8C,0x25,0x24,0x1B,0xAB,0x87,0xC2,0xA5,
        0x40,0x68,0x6C,0x27,0xED,0x19,0x45,0x2C,
        0x79,0x4A,0x82,0x49,0xE0,0x51,0x44,0x36,
        0x1A,0x27,0x28,0x1B,0x1A,0x25,0x03,0x42,
        0x9E,0x05,0x58,0x07,0x26,0x04,0x76,0x2F,
        0xC0,0x9A,0x00,0x73,0xB3,0x90,0xB1,0xB9,
        0xE8,0xFF,0x0F,0x71,0xB0,0x31,0xDA,0x9A,
        0xAE,0x90,0xC2,0xC4,0x88,0x12,0x2C,0x5E,
        0xC5,0xC3,0x10,0xCA,0x93,0x42,0xA8,0x48,
        0x95,0xA1,0x68,0xB4,0x51,0x2A,0x14,0xE0,
        0x4C,0x80,0x30,0x5C,0x1D,0x03,0x82,0x46,
        0x88,0x15,0x29,0x56,0xFB,0x83,0x20,0xF1,
        0x2D,0x40,0x54,0x01,0xA2,0x48,0xA3,0x41,
        0x9D,0x03,0x3C,0x5C,0x0F,0xF5,0xF0,0x3D,
        0xF6,0x93,0x0C,0x72,0x90,0x67,0xF1,0xA8,
        0x70,0x9C,0x06,0x49,0xE0,0x0B,0x80,0x4F,
        0x08,0x1E,0x38,0xDE,0x35,0xA0,0x66,0x7C,
        0xBC,0x4C,0x10,0x1C,0x6A,0x88,0x1E,0x68,
        0xB8,0x13,0x38,0x44,0x06,0xE8,0x49,0x3D,
        0x52,0x60,0x07,0x77,0x32,0xEF,0x01,0xAF,
        0x0A,0xCD,0x5E,0x12,0x08,0xC1,0xF1,0xF8,
        0x7E,0xC0,0x26,0x9C,0xC0,0xF2,0x07,0x81,
        0x1A,0x99,0xA1,0x3D,0xCA,0xD3,0x8A,0x19,
        0xF2,0x31,0xC1,0x04,0x16,0x0B,0x21,0x05,
        0x10,0x1A,0x0F,0xF8,0x6F,0x00,0x8F,0x17,
        0xBE,0x12,0xC4,0xF6,0x80,0x12,0x0C,0x0B,
        0x21,0x23,0xAB,0xF0,0x78,0xE8,0x28,0x7C,
        0x95,0x38,0x9C,0xD3,0x8A,0x67,0x82,0xE1,
        0x20,0xF4,0x05,0x90,0x00,0x51,0xE7,0x0C,
        0xD4,0x61,0xC1,0xE7,0x04,0x76,0x33,0x38,
        0x83,0x47,0x00,0x8F,0xE4,0x84,0xFC,0x2B,
        0xF1,0xC0,0xE0,0x03,0xE2,0xEF,0x1F,0xA7,
        0xEC,0x11,0x9C,0xA9,0x01,0x7D,0x1C,0xF0,
        0xFF,0x7F,0x28,0x7C,0x88,0x1E,0xDF,0x29,
        0x1F,0xAF,0x4F,0x17,0x96,0x35,0x4E,0xE8,
        0x77,0x08,0x9F,0x38,0x7C,0x64,0x71,0x44,
        0x08,0x39,0x39,0x05,0xA0,0x81,0x4F,0xF7,
        0xEC,0x22,0x9C,0xAE,0x27,0xE5,0x40,0xC3,
        0xA0,0xE3,0x04,0xC7,0x79,0x00,0x1C,0xE3,
        0x84,0x7F,0x2E,0x80,0x3F,0x40,0x7E,0xCA,
        0x78,0xC5,0x48,0xE0,0x98,0x23,0x44,0x9F,
        0x6B,0x3C,0x42,0x2C,0xFC,0x53,0x45,0xE1,
        0x03,0x21,0x63,0x04,0x17,0xA0,0xC7,0x08,
        0x7C,0x03,0x8E,0x11,0x7D,0x94,0xE0,0xEA,
        0x0F,0x1A,0x74,0x80,0xB8,0xFF,0xFF,0x00,
        0xE1,0x83,0x7A,0x80,0xC0,0x37,0xFA,0xD1,
        0x03,0x3D,0x2E,0x8B,0x3E,0x0F,0xC8,0xF8,
        0x89,0x46,0xF3,0xE2,0xA7,0x03,0x7E,0xF8,
        0x00,0x0F,0xA8,0x87,0x84,0x03,0xC5,0x4C,
        0x9B,0x83,0x3E,0xBB,0x1C,0x3A,0x76,0xB8,
        0xE0,0x3F,0x81,0x80,0x4B,0xDE,0x21,0x0C,
        0x14,0x23,0xC6,0x9F,0x83,0x7C,0x0A,0x03,
        0xFF,0xFF,0xFF,0x14,0x06,0xFE,0xE1,0xF0,
        0x20,0x4F,0x07,0x9F,0xB6,0xA8,0x74,0x18,
        0xD4,0x81,0x0B,0xB0,0x32,0x89,0x08,0xCF,
        0x12,0xB5,0x41,0xE8,0xD4,0xF0,0x36,0xF1,
        0xB6,0xE5,0x5B,0x40,0x9C,0xD3,0xEC,0xED,
        0xC0,0x45,0x30,0x22,0xD4,0x0C,0x45,0x4E,
        0x5A,0x11,0x63,0x44,0x79,0xDC,0x32,0xCA,
        0xDB,0xD6,0x0B,0x40,0xBC,0x13,0x7B,0xDE,
        0x32,0x46,0xF0,0xC8,0x0F,0x5C,0x2C,0xC6,
        0xEA,0xF5,0x5F,0xF3,0x81,0x0B,0x70,0xF6,
        0xFF,0x3F,0x70,0x01,0x1C,0x0A,0x7A,0x18,
        0x42,0x0F,0xC3,0x53,0x39,0x97,0x87,0xC8,
        0x53,0x89,0x18,0x35,0x4C,0xD4,0x67,0x28,
        0xDF,0x2D,0x7C,0x20,0x02,0xDF,0x99,0x0B,
        0xF8,0xFD,0xFF,0x0F,0x44,0x70,0x8E,0x29,
        0xB8,0x33,0x0D,0x78,0x7C,0xCE,0x40,0x20,
        0xA7,0xE2,0x43,0x0D,0x60,0x41,0xF4,0x13,
        0xC2,0x27,0x1A,0x2A,0x13,0x06,0x75,0xA8,
        0x01,0xAC,0x5C,0x61,0x9E,0x46,0xCF,0xF9,
        0x59,0xC6,0xA7,0x1A,0x1F,0x4A,0x8D,0x63,
        0x88,0x97,0x99,0x87,0x1A,0x1F,0x0B,0x5E,
        0x49,0x7D,0xA8,0x31,0x54,0x9C,0x87,0x1A,
        0x0F,0x37,0x50,0xD4,0x37,0x9B,0x67,0x1B,
        0xA3,0xC7,0xF7,0x0D,0xD5,0x10,0x0F,0x35,
        0x4C,0xF2,0x4A,0x35,0x16,0x1F,0x6A,0xC0,
        0xF1,0xFF,0x3F,0xD4,0x00,0xFC,0xFF,0xFF,
        0x1F,0x6A,0x00,0x47,0x47,0x03,0x38,0x47,
        0x46,0xDC,0xD1,0x00,0x5C,0x87,0x52,0xE0,
        0x70,0x34,0x00,0x1E,0x47,0x21,0x30,0x5F,
        0x68,0x7C,0x14,0x02,0x16,0xFF,0xFF,0xA3,
        0x10,0xF8,0x65,0x9F,0x83,0x50,0x42,0x8F,
        0x42,0x80,0xA0,0xDB,0xCF,0x53,0xC4,0xB3,
        0x8F,0x2F,0x3F,0x0F,0x04,0x11,0x5E,0xF3,
        0x7D,0x0A,0xF2,0x21,0xDF,0x47,0x21,0x06,
        0x63,0x28,0x5F,0x83,0x7C,0x14,0x62,0x50,
        0xAF,0x41,0xBE,0xEF,0x1B,0xE4,0xF1,0x22,
        0x48,0xEC,0x67,0x02,0x1F,0x85,0x98,0xE8,
        0xA3,0x10,0xA0,0xF0,0xFF,0x7F,0x14,0x02,
        0xF8,0xFF,0xFF,0x3F,0x0A,0x01,0xCE,0x02,
        0x1C,0x0D,0x40,0x37,0xAD,0x47,0x21,0xF0,
        0xDE,0x59,0x4E,0xFB,0x04,0x7C,0x16,0x02,
        0xCC,0xFE,0xFF,0xCF,0x42,0xC0,0xEC,0x28,
        0x74,0x14,0x67,0xF9,0x2A,0xF4,0x04,0xF0,
        0x02,0x10,0x23,0xCC,0x3B,0xD0,0x4B,0x26,
        0xBB,0x8B,0x1B,0xE7,0xC9,0xE5,0x2C,0x9E,
        0xC4,0x7D,0x09,0xF2,0x81,0xE2,0x59,0xC8,
        0x50,0xA7,0x1B,0xF4,0x8D,0xDC,0x03,0x8B,
        0x19,0x3F,0xC4,0xF3,0x90,0x21,0x9E,0x85,
        0x00,0x76,0xFD,0xFF,0xCF,0x42,0x00,0xFF,
        0xFF,0xFF,0x47,0x03,0xF8,0x2F,0x00,0x9F,
        0x85,0x80,0xE7,0x09,0xE0,0x41,0xDB,0x67,
        0x21,0x80,0x33,0x87,0xCB,0xF3,0x7F,0x05,
        0x3A,0x96,0xF7,0x08,0xCF,0xFA,0x24,0x5F,
        0x2F,0x3D,0xD3,0x87,0x82,0x67,0x21,0x86,
        0x75,0x18,0x3E,0x0B,0x31,0x88,0x17,0x4D,
        0x43,0xBC,0x70,0xFA,0x30,0xE0,0xFF,0x3F,
        0x5E,0xE0,0x57,0x4E,0x03,0x05,0x09,0xF4,
        0x2C,0x04,0x30,0xFE,0xFF,0x7F,0x16,0x02,
        0xC8,0xB8,0x46,0x9D,0x85,0x80,0xE5,0x6D,
        0xE5,0x19,0xDB,0xA7,0x95,0x04,0xFF,0xFF,
        0x67,0x21,0xC0,0x41,0x2E,0x23,0x07,0x21,
        0x4C,0xC4,0x87,0x83,0x8F,0x99,0x80,0x9E,
        0x29,0xBE,0xB8,0x1B,0xE3,0x09,0xE0,0x45,
        0xE2,0x31,0x93,0x1D,0x35,0x0D,0xF3,0x2C,
        0x64,0xBC,0xB3,0x78,0x0D,0x78,0x82,0xF7,
        0xE4,0x9F,0x85,0x18,0xD8,0x61,0x05,0x7B,
        0x14,0x32,0xA8,0xC1,0x63,0x87,0x08,0x13,
        0xE8,0x59,0x88,0xC5,0x7D,0xAE,0xE8,0x3C,
        0xE1,0xB3,0x10,0xF0,0xFE,0xFF,0x9F,0x25,
        0xE0,0x5E,0x0D,0x9E,0x85,0x00,0x13,0x87,
        0x0D,0x9F,0x35,0xC0,0x33,0x7C,0x8F,0xEA,
        0x1C,0x1E,0x8F,0x81,0x7F,0x56,0x1D,0xE7,
        0x04,0x96,0x7B,0xD1,0xB2,0x71,0xA0,0xA1,
        0x23,0xB2,0x3A,0x20,0x8D,0x0D,0x73,0x29,
        0x89,0x7C,0x72,0x6C,0xD4,0x56,0x04,0xA7,
        0x33,0x93,0x4F,0x00,0xD6,0x42,0x21,0x05,
        0x34,0x1A,0x8B,0xE1,0x9D,0xF9,0xE8,0x44,
        0x41,0x0C,0xE8,0xE3,0x90,0x6D,0x1C,0x0A,
        0x50,0x7B,0xD1,0x14,0xC8,0x39,0x07,0xA3,
        0x7F,0x76,0x74,0x36,0xBE,0x13,0x70,0x0D,
        0x10,0x3A,0x25,0x18,0xDA,0x6A,0x04,0xFC,
        0xFF,0x67,0x89,0x01,0x33,0xFE,0x53,0x8C,
        0x09,0x7C,0x8E,0xC1,0x1F,0x0C,0xF0,0x03,
        0x7F,0x31,0xA8,0xFA,0x5E,0xA0,0xFB,0x82,
        0xD5,0xDD,0x64,0x20,0xCC,0xC8,0x04,0xF5,
        0x9D,0x0E,0x40,0x01,0xE4,0x0B,0x81,0xCF,
        0x51,0x0F,0x05,0x6C,0x22,0x21,0xC2,0x44,
        0x33,0x3A,0x62,0xC2,0xA8,0xE8,0x13,0xA6,
        0x20,0x9E,0xB0,0x63,0x4D,0x18,0x3D,0x13,
        0x5F,0x74,0xD8,0x88,0x31,0x21,0xAE,0x1E,
        0xD0,0x26,0x18,0xD4,0x97,0x22,0x58,0x43,
        0xE6,0x63,0xF1,0x05,0x02,0x37,0x65,0x30,
        0xCE,0x89,0x5D,0x13,0x7C,0xD9,0xC1,0xCD,
        0x19,0x8C,0xF0,0x98,0xBB,0x18,0xBF,0x3A,
        0x79,0x74,0xFC,0xA0,0xE0,0x1B,0x0E,0xC3,
        0x7E,0x32,0xF3,0x8C,0xDE,0xCB,0x7C,0x8D,
        0xC3,0xC0,0x7A,0xBC,0x1C,0xD6,0x68,0x61,
        0x0F,0xED,0x3D,0xC4,0xFF,0xFF,0x43,0x8C,
        0xCF,0x13,0xC6,0x08,0xEB,0xDB,0x0B,0x38,
        0xEE,0x59,0xF0,0xEF,0x1A,0xE0,0xB9,0x84,
        0xF8,0xAE,0x01,0x30,0xF0,0xFF,0x7F,0xD7,
        0x00,0x4E,0xD7,0x04,0xDF,0x35,0x80,0xF7,
        0xD0,0x7D,0xD7,0x00,0xAE,0xD9,0xEF,0x1A,
        0xA8,0x63,0x80,0x15,0xDE,0x35,0xA0,0x5D,
        0xD9,0xDE,0xD7,0x9E,0xB0,0xAC,0xE9,0xB2,
        0x81,0x52,0x73,0xD9,0x00,0x14,0xFC,0xFF,
        0x2F,0x1B,0x80,0x01,0x29,0x13,0x46,0x85,
        0x9F,0x30,0x05,0xF1,0x84,0x1D,0xEC,0xB2,
        0x01,0x8A,0x18,0x97,0x0D,0xD0,0x8F,0xED,
        0x65,0x03,0x18,0xDC,0x13,0xF8,0x6D,0x03,
        0x78,0x43,0xFA,0xB6,0x01,0xD6,0xFF,0xFF,
        0x6D,0x03,0xAC,0xF9,0x6F,0x1B,0x28,0x0E,
        0xAB,0xBC,0x6D,0x40,0x3C,0xC9,0x33,0x02,
        0xAB,0xBA,0x6E,0xA0,0xF4,0x5C,0x37,0x00,
        0x12,0x88,0x99,0x30,0x2A,0xFE,0x84,0x29,
        0x88,0x27,0xEC,0x68,0xD7,0x0D,0x50,0x04,
        0xB9,0x6E,0x80,0x7E,0x5E,0x09,0xFE,0xFF,
        0xAF,0x1B,0xC0,0xE0,0xA2,0x80,0xB9,0x6F,
        0x00,0x6F,0x58,0x7E,0xDF,0x00,0x7C,0xDC,
        0xC4,0x31,0xF7,0x0D,0xC0,0xCC,0xFF,0xFF,
        0xBE,0x01,0xB0,0xE7,0xA2,0x80,0xBB,0x6F,
        0x00,0xEF,0x8B,0xB4,0xEF,0x1B,0x60,0xFE,
        0xFF,0xDF,0x37,0xC0,0x28,0x6D,0xFD,0x1E,
        0x1C,0x3D,0x21,0x78,0x7C,0xB8,0xFB,0xA5,
        0xC7,0xE7,0xBB,0x39,0x38,0x06,0x79,0x8C,
        0x87,0x76,0xC0,0xAF,0xEF,0x9E,0x98,0xEF,
        0xE6,0xC0,0xFF,0x4C,0x70,0x3C,0x18,0x68,
        0x1C,0x62,0xAB,0x97,0x06,0x72,0x34,0x38,
        0x3F,0xDC,0x19,0x81,0x61,0x15,0x7F,0xF2,
        0x47,0x38,0xC7,0xD0,0xD9,0xE1,0x20,0xB1,
        0x83,0xE0,0xC1,0x56,0x6D,0x02,0x85,0x86,
        0x50,0x14,0x18,0x14,0x8B,0x0F,0x18,0xF8,
        0x61,0xB3,0xB3,0x00,0x93,0x04,0x87,0x3A,
        0x02,0xF8,0x3E,0xD1,0xFC,0x38,0x74,0x37,
        0x38,0x54,0x8F,0xE5,0xA1,0x80,0x9E,0x01,
        0x71,0xC7,0x0C,0x32,0x69,0xCF,0x28,0xE2,
        0x53,0xC2,0x29,0x85,0x49,0xE0,0xF3,0x03,
        0x43,0xE3,0x04,0xAF,0x0D,0xA1,0xF9,0xFF,
        0xFF,0xA4,0xC0,0x3C,0xDF,0x31,0x04,0x6C,
        0x02,0xBB,0xBF,0x64,0xC8,0xDA,0xC0,0x75,
        0x4B,0x32,0x44,0x6F,0x38,0xB2,0x85,0xA2,
        0xE9,0x44,0x79,0xDF,0x88,0x62,0x67,0x08,
        0xC2,0x88,0x12,0x2C,0xC8,0xA3,0x42,0xAC,
        0x28,0x2F,0x05,0x46,0x88,0x18,0xE2,0x95,
        0x23,0xD0,0x09,0x87,0x0F,0xF2,0xD8,0x14,
        0xA7,0xFD,0x41,0x90,0x58,0x4F,0x02,0x8D,
        0xC5,0x91,0x46,0x83,0x3A,0x07,0x78,0xB8,
        0x3E,0xC4,0x78,0xF8,0x0F,0x21,0x06,0x39,
        0xC8,0x73,0x7B,0x54,0x38,0x4E,0x5F,0x25,
        0x4C,0xF0,0x02,0xE0,0x83,0x0A,0x1C,0xD7,
        0x80,0x9A,0xF1,0x33,0x06,0x58,0x8E,0xE3,
        0x3E,0xA9,0xC0,0x1D,0x8F,0xEF,0x07,0x6C,
        0xC2,0x09,0x2C,0x7F,0x10,0xA8,0xE3,0x0C,
        0x9F,0xE7,0x0B,0x8B,0x21,0x1F,0x13,0x4C,
        0x60,0xB1,0x27,0x1B,0x3A,0x1E,0xF0,0xDF,
        0x63,0x1E,0x2F,0x7C,0x32,0xF1,0x7C,0x4D,
        0x30,0x22,0x84,0x9C,0x8C,0x07,0x7D,0x87,
        0xC0,0x5C,0x6F,0xD8,0xB9,0x85,0x8B,0x3A,
        0x68,0xA0,0x4E,0x0B,0x3E,0x28,0xB0,0x9B,
        0x11,0xE6,0xB8,0xCE,0xCF,0x2A,0x60,0xF8,
        0xFF,0x9F,0x55,0x60,0x8F,0x10,0xFE,0xED,
        0xC1,0xF3,0xF2,0x95,0xE1,0xD5,0x21,0x81,
        0x43,0x8E,0x10,0x3D,0x2E,0x8F,0x10,0x73,
        0x3E,0xC2,0x0C,0x11,0x5C,0x67,0x01,0x70,
        0x0C,0x11,0xF8,0x1C,0x70,0xC0,0x71,0x69,
        0xE2,0x03,0xF5,0x01,0x07,0x70,0x70,0x4D,
        0xC3,0x1D,0x70,0xC0,0x71,0x16,0x60,0xFF,
        0xFF,0xC3,0x0D,0x2C,0x49,0x26,0x0E,0x23,
        0x18,0x11,0x30,0x28,0x02,0x02,0xA4,0xB3,
        0x80,0x0F,0x29,0x00,0x1F,0xAE,0x0C,0x0F,
        0x29,0xD8,0x93,0x86,0x07,0x8E,0x1B,0x85,
        0x07,0x8D,0x0B,0x30,0x68,0x7A,0xE2,0x80,
        0x7F,0x4C,0xF0,0x19,0x05,0x1C,0xE3,0x06,
        0xDF,0x2A,0x0C,0xFC,0xFF,0x3F,0x30,0xCC,
        0xE1,0xC2,0x63,0x39,0x8A,0xA0,0x07,0x1E,
        0xD4,0xF7,0x8C,0x33,0xF7,0x24,0x8F,0xD1,
        0x51,0x0F,0x27,0xF4,0xE4,0x85,0x3B,0x57,
        0xF9,0x0A,0x71,0x14,0x18,0xB8,0x77,0x29,
        0x8F,0xCF,0x17,0x2B,0xC3,0x63,0x46,0xFB,
        0x1E,0x72,0xD6,0x11,0x02,0xE2,0x2F,0x75,
        0x6C,0xC0,0x60,0x39,0x18,0x00,0x87,0x01,
        0xE3,0x13,0x0D,0x58,0x67,0x1B,0x3C,0xF4,
        0x69,0x31,0xC4,0xE3,0x0B,0xFB,0x56,0x61,
        0x82,0xEA,0x41,0x75,0x12,0xF4,0xD0,0xC0,
        0x01,0xE8,0xA1,0xC1,0x3F,0xB9,0x90,0xFB,
        0x2B,0x1D,0x82,0xB5,0xE2,0x69,0xDE,0x47,
        0x1E,0xF3,0xDC,0xA2,0xBC,0x0D,0x3C,0x07,
        0xF0,0xD3,0x82,0x87,0xE3,0x63,0x81,0xC7,
        0xE9,0x4B,0x58,0x82,0xF7,0x1A,0x9F,0x6C,
        0x1E,0x5C,0x58,0xB2,0x21,0xA0,0x06,0xEB,
        0x21,0x60,0xA6,0x9A,0xC0,0x49,0x46,0x80,
        0xCA,0x00,0xA1,0x1B,0xCB,0xE9,0x3E,0x8B,
        0x84,0x38,0xCD,0x47,0x99,0xC7,0x02,0x8F,
        0xF5,0xC1,0xC0,0xFF,0x7F,0xCD,0x23,0xD4,
        0x7D,0xCD,0x33,0x7B,0x3A,0xC0,0xAC,0x22,
        0xDC,0x7B,0xCE,0x1B,0x86,0xD1,0x9E,0x2D,
        0x7C,0xCD,0x78,0xD6,0x34,0x42,0x38,0x76,
        0x83,0xF3,0x48,0x8C,0xF0,0x82,0xC0,0x4E,
        0x0C,0x0F,0x30,0xC6,0x39,0x79,0xC3,0xFA,
        0xC2,0xCB,0x40,0x83,0x19,0xDB,0x97,0x01,
        0x36,0x2A,0xDF,0x88,0xC0,0x97,0xFC,0x62,
        0x00,0x65,0x16,0xBE,0x9E,0xF8,0xA0,0xC4,
        0x2E,0x06,0x2C,0xE5,0xC5,0x00,0x54,0x37,
        0x0C,0x5F,0x0C,0xE0,0x5F,0x89,0x5E,0x0C,
        0xC0,0x70,0x71,0xF2,0x3D,0xC0,0x1E,0xEE,
        0xA3,0x74,0x9C,0xBE,0xFD,0xBD,0x19,0xF8,
        0x6C,0xC0,0x60,0x3C,0xC3,0x30,0xC6,0x08,
        0xE3,0x51,0x86,0x31,0xC1,0xDC,0xB7,0x03,
        0xE8,0x39,0x87,0x81,0x4A,0x78,0x3B,0x80,
        0x72,0x0E,0xE8,0xF2,0x68,0x42,0x4F,0x01,
        0x4F,0x07,0x3E,0x29,0x1A,0xA2,0xAF,0xB1,
        0x0A,0x26,0x50,0xC4,0x07,0x0D,0x3E,0xB5,
        0x28,0x3E,0x15,0x78,0x2D,0xCF,0x4E,0xE1,
        0xE2,0x9C,0x89,0xA7,0x6A,0x38,0x03,0xBD,
        0xE6,0x86,0x63,0xFF,0x7F,0x38,0xFC,0xA9,
        0xE0,0x35,0x80,0x1D,0x24,0x3D,0x2D,0x23,
        0xC2,0x38,0xA4,0x3C,0x32,0xF8,0xB6,0x18,
        0xC7,0x90,0x0F,0x91,0xBE,0x13,0x18,0xF2,
        0x21,0xEF,0x79,0xC7,0xC0,0xAF,0x08,0x71,
        0x9E,0xB2,0x7C,0x67,0xF0,0x65,0x01,0x7C,
        0x91,0x2E,0x0B,0x68,0x68,0x9F,0x64,0x7C,
        0x41,0x30,0xEC,0x89,0xB3,0x00,0x77,0x05,
        0x50,0x81,0xFA,0xAE,0x00,0xFF,0x42,0xF0,
        0xAE,0x00,0x86,0x79,0xF9,0x56,0xC0,0x35,
        0x1D,0x4A,0xD0,0x67,0x12,0x5F,0x17,0x70,
        0x53,0x64,0xA9,0x8E,0x0A,0xD0,0x53,0x4C,
        0x02,0x75,0x47,0xF7,0x51,0x01,0xC6,0x4D,
        0xD9,0x07,0x54,0x76,0x5A,0x60,0x67,0x21,
        0x76,0x1D,0xC1,0x5D,0x49,0x18,0xCA,0xB3,
        0x81,0x2F,0x59,0xFC,0x70,0x00,0x03,0xDC,
        0xB3,0x38,0xC4,0x08,0xB1,0xD9,0x81,0xEB,
        0x75,0xD2,0x70,0x2F,0x44,0xEC,0xFF,0x7F,
        0x32,0x00,0xE3,0x51,0x1B,0x1C,0x27,0x9D,
        0xF0,0x91,0x9E,0x59,0xF8,0x49,0x19,0x30,
        0x71,0xF2,0x03,0xE3,0xC9,0x1A,0xC6,0x00,
        0xB8,0xBC,0x57,0x95,0x81,0xFC,0x43,0x90,
        0x20,0x18,0xD4,0x29,0x19,0x38,0x1C,0xC5,
        0x70,0xA7,0x64,0x78,0x50,0xF8,0xC3,0x00,
        0xE6,0x46,0xE8,0x7B,0x82,0xA1,0xDE,0x93,
        0x0E,0xE3,0x91,0xD0,0x04,0x3E,0x2D,0xC3,
        0xFA,0xFF,0x9F,0x96,0x81,0xD5,0xB1,0xDD,
        0x43,0xF6,0x59,0x01,0x77,0x76,0x80,0x3B,
        0x3D,0x7E,0x7A,0x00,0x9C,0x00,0x3D,0x3D,
        0x80,0xED,0xBC,0x01,0xF7,0x40,0x80,0x38,
        0xFE,0xA3,0x82,0x5F,0x59,0x28,0x1C,0x3F,
        0xB6,0xF3,0x63,0x09,0xEE,0x70,0xE0,0x23,
        0x83,0x0F,0x90,0xB8,0xA1,0xF8,0x50,0x81,
        0x3C,0x0B,0x80,0x62,0xF4,0x6C,0x04,0xEC,
        0x06,0xF3,0xD2,0x12,0xE5,0xFF,0xFF,0xDE,
        0xC0,0x4E,0x29,0xB8,0x83,0x00,0xF8,0x8E,
        0x01,0xE0,0x1D,0x0C,0x97,0x35,0x66,0x94,
        0x10,0x18,0x8D,0x19,0x77,0x08,0xE1,0x27,
        0x02,0xDC,0x98,0x3D,0x6E,0x8F,0x19,0x77,
        0x9C,0xE5,0xA3,0x7A,0xCA,0x08,0xE5,0x03,
        0x07,0x3B,0x67,0xBC,0x11,0xF0,0xA1,0x03,
        0x8F,0x03,0x0C,0xEE,0x48,0x01,0xC6,0xCB,
        0x01,0x1B,0x3B,0xB8,0x83,0x90,0x53,0x20,
        0x4B,0x87,0xD1,0xD8,0x71,0xB2,0x81,0x74,
        0x8C,0xF1,0x21,0xD7,0x63,0xC7,0x0D,0xD6,
        0x63,0xC7,0x1D,0x5F,0xB0,0xFF,0xFF,0xE3,
        0x0B,0x18,0xC6,0xC0,0xC5,0x0F,0x03,0x7D,
        0xF3,0xF3,0xE8,0x0C,0xEE,0x61,0xFB,0x04,
        0x13,0xE3,0xF9,0x25,0xC4,0x23,0xCC,0x8B,
        0x4B,0x84,0xA3,0x08,0xF2,0xE6,0x12,0xE7,
        0xD5,0x20,0xCC,0x63,0x4B,0x94,0x10,0x11,
        0x0E,0x26,0xCE,0x13,0x8C,0x11,0x0E,0x3C,
        0x8A,0x21,0x22,0x9C,0x40,0x88,0x93,0x3E,
        0xD9,0x20,0xE1,0x63,0x84,0x8D,0xF6,0x04,
        0xC3,0xC7,0xC2,0xCF,0x2B,0x1E,0x3C,0x3F,
        0xAD,0xF9,0x2E,0xE8,0xC9,0x9C,0xE3,0x43,
        0x96,0xA7,0xF6,0x38,0xE9,0xC3,0x2C,0x6E,
        0x50,0x0F,0x8E,0xEC,0xAE,0xE3,0xE3,0x35,
        0xF6,0x14,0xE4,0x21,0xF0,0x13,0x81,0x2F,
        0x88,0x9E,0xAC,0xEF,0x7A,0xEC,0x5E,0x66,
        0x8C,0xEA,0xA7,0x80,0x3A,0xA6,0x9C,0xC1,
        0x2B,0x04,0xBB,0xE7,0xF9,0x90,0xED,0xBB,
        0x24,0x1B,0x05,0xEE,0x90,0xE0,0x33,0x12,
        0x3F,0x55,0x78,0x18,0x1E,0x05,0x8C,0x19,
        0xBC,0x23,0x1C,0x5A,0x88,0x03,0x7E,0xDF,
        0x65,0x43,0x8D,0x71,0x7A,0x3E,0x7F,0xB0,
        0x41,0xC0,0x87,0x3A,0x54,0x0F,0xF3,0xA8,
        0x5E,0x0A,0x19,0xCE,0xD9,0xC1,0x1D,0x04,
        0xF6,0xF8,0xE1,0x41,0xF0,0x9B,0x25,0x1F,
        0x04,0x3B,0xDF,0xBC,0xC1,0x19,0xE4,0xFF,
        0x7F,0x0C,0xB0,0xCF,0x54,0x3E,0x9A,0x20,
        0x8E,0x80,0xE8,0xF3,0x87,0xC7,0xF0,0x26,
        0xC7,0x87,0x83,0x3D,0x7A,0xE0,0x4E,0x22,
        0x70,0x8F,0x5D,0x07,0xED,0x6B,0x9C,0x2F,
        0x5A,0x30,0xEE,0x7B,0xCF,0x22,0xE0,0xC7,
        0x78,0x6C,0x01,0xC7,0xA1,0x04,0xDC,0xC1,
        0x8E,0x6B,0x1C,0x42,0x51,0x60,0x74,0x28,
        0xC1,0xC5,0x00,0x12,0x8C,0x63,0x9C,0xD1,
        0xD0,0x97,0x48,0x1F,0xD2,0xE0,0x0C,0x1A,
        0xF6,0x3C,0x9F,0x50,0xB8,0x3D,0x01,0x8A,
        0x4E,0x28,0x20,0xC3,0x7D,0x06,0xC1,0x9E,
        0x10,0xF8,0x19,0x84,0xFD,0xFF,0x0F,0x8E,
        0x1E,0xF7,0x7B,0xA3,0x4F,0x8D,0x6C,0xEE,
        0x0F,0x01,0x27,0x70,0xEE,0xEC,0xD4,0x8C,
        0x3B,0x33,0x60,0xCF,0x1F,0x1E,0x02,0x3F,
        0x17,0x78,0xF8,0x1E,0x02,0x7E,0xF0,0x0F,
        0xCC,0x06,0x07,0xE3,0x29,0xC2,0xD7,0x0E,
        0x0E,0xCE,0x4F,0x03,0x06,0xE7,0xAF,0x50,
        0x9F,0xE7,0x19,0x38,0xF6,0xD4,0xEB,0x7B,
        0x87,0xE7,0xEB,0x43,0x05,0xFE,0xA6,0xE7,
        0x43,0x05,0x38,0x0E,0x0F,0xFC,0xB0,0xC2,
        0x86,0xF0,0x28,0x80,0x3F,0xB5,0xF8,0xF8,
        0x17,0xE7,0x29,0x82,0xDD,0x46,0xB0,0x87,
        0x0B,0xC0,0x51,0xB4,0xB3,0x18,0x2A,0xCC,
        0x59,0x8C,0xFC,0xFF,0xCF,0x51,0xA8,0xB3,
        0x18,0x3D,0x5C,0x00,0x2E,0x04,0x1F,0x0F,
        0x40,0x73,0x10,0x78,0x5C,0xF0,0x85,0xE0,
        0x48,0x0E,0xE4,0xE9,0x00,0xF0,0x19,0x4A,
        0xC3,0xA1,0x09,0x13,0x03,0x06,0x75,0x3E,
        0xF0,0x09,0xC5,0xC7,0x0E,0x7E,0x36,0xF0,
        0x8D,0xDC,0x43,0xE5,0xA7,0x66,0x5F,0xF2,
        0x11,0xE0,0x02,0x75,0xA0,0x61,0xA0,0x46,
        0xE4,0x23,0xD2,0xFF,0xFF,0xB9,0x0D,0x1B,
        0x60,0x68,0xF4,0x1C,0x0E,0xE3,0x80,0xEB,
        0x73,0x38,0x76,0x40,0x3E,0x87,0xC3,0x3F,
        0x47,0xC3,0x1F,0x1B,0x3B,0xDD,0xF3,0x81,
        0xC1,0xBA,0x7E,0x63,0x06,0x06,0xB6,0x6F,
        0x91,0x07,0x06,0x1C,0x51,0xCF,0xC6,0x57,
        0x08,0x0F,0x0C,0x6C,0x80,0x1E,0x18,0xF0,
        0x89,0x05,0x21,0x27,0x03,0x43,0x9D,0x32,
        0x8C,0x1C,0xF3,0x89,0xC3,0xC3,0xF0,0xA1,
        0x22,0xEA,0x33,0xC0,0x23,0x1E,0x1B,0x1B,
        0xFB,0xFF,0x8F,0x0D,0x2C,0xC7,0x16,0x8F,
        0x0D,0xFC,0x47,0x78,0xFC,0xD8,0xE0,0x8C,
        0xE5,0xD1,0xC4,0x97,0x99,0x23,0x3B,0x8D,
        0x33,0x7B,0x0D,0xF1,0xD1,0xEE,0xF1,0xDB,
        0x63,0x03,0x97,0x85,0xB1,0x01,0xA5,0x90,
        0x63,0x43,0x1F,0x52,0x7C,0x0A,0xB0,0x71,
        0x54,0x32,0x0F,0x1F,0xAF,0x7C,0x62,0x38,
        0xBA,0x20,0x6F,0xE8,0xBE,0x5C,0xF8,0x48,
        0x63,0x30,0x5F,0x5A,0x7C,0x06,0xE5,0x43,
        0x04,0xD7,0x57,0xC5,0x43,0x04,0x3E,0xA1,
        0x86,0x88,0x1E,0xCF,0xFF,0xFF,0x11,0xCC,
        0x43,0x64,0x43,0x03,0xAF,0x87,0xA1,0x01,
        0xA5,0x98,0xC0,0x5E,0x85,0x87,0x46,0x4F,
        0x3F,0x3E,0x04,0x30,0x08,0xDF,0x06,0xD8,
        0x55,0xC0,0x57,0x21,0x83,0x24,0x18,0xE7,
        0x64,0x41,0x07,0x07,0x8E,0x21,0x79,0x70,
        0xF0,0x07,0xE3,0x21,0x70,0x60,0xCF,0xE0,
        0xB9,0xE8,0x31,0xD8,0xA7,0x1D,0x9F,0x4A,
        0xC0,0x77,0xE6,0x04,0xC7,0xE9,0x1D,0x7B,
        0x29,0xF0,0x08,0x1E,0xAD,0x3C,0x02,0x7E,
        0xB4,0x02,0x66,0xFF,0xFF,0xA3,0x15,0x30,
        0x09,0x7A,0xE6,0xA4,0x03,0x77,0x34,0x18,
        0xD4,0xD1,0x0A,0x5C,0x11,0xC0,0x75,0xDC,
        0xF0,0xD1,0x02,0xCE,0x50,0x0F,0xDA,0x07,
        0x65,0xCF,0xDA,0x97,0x21,0x76,0xB4,0x00,
        0x97,0x89,0x43,0x08,0xD0,0x04,0x3E,0x89,
        0x67,0xEF,0x43,0x03,0xB3,0x8A,0xA1,0x01,
        0xA5,0xA3,0x01,0xEE,0x44,0x81,0xFD,0xFF,
        0x9F,0x28,0x60,0xDE,0x30,0x70,0x07,0x0A,
        0xC0,0xCD,0xE9,0xDB,0xE3,0xE2,0xD0,0x38,
        0xC4,0xE7,0xA7,0x73,0xF6,0xD1,0xE8,0x4C,
        0x71,0x67,0x11,0x30,0x9C,0x7D,0x11,0x8F,
        0x18,0x03,0xF9,0x81,0x21,0x59,0x30,0x28,
        0x16,0x0F,0xC5,0x07,0x03,0x0E,0xEC,0x23,
        0x02,0x3B,0x17,0xB0,0x73,0xAD,0xE1,0xF8,
        0x59,0xC0,0xA7,0x84,0xB7,0xA6,0x17,0x7B,
        0x9F,0xD7,0x7D,0xD6,0x08,0xC9,0xCE,0xF4,
        0x3E,0x89,0xE2,0x0E,0xA2,0x70,0x4E,0x9F,
        0xE0,0x22,0xF0,0x65,0xDF,0xA3,0xE0,0xA7,
        0x07,0xCF,0xF1,0x8D,0xC1,0xA7,0x07,0xE6,
        0x7E,0xF8,0x9A,0xF1,0x33,0xC3,0xE3,0x43,
        0x88,0x27,0xE2,0xDA,0xA6,0x20,0x5B,0x18,
        0x42,0x09,0xF4,0xFF,0x8F,0x10,0xE5,0x6D,
        0x20,0xCA,0x29,0x44,0x88,0x12,0xA4,0xB1,
        0xC9,0x0B,0x35,0xCA,0xD9,0x45,0x6E,0x6D,
        0xF6,0x82,0x0B,0x14,0x2A,0x66,0x9C,0x28,
        0xEF,0x10,0xB1,0xDA,0x1F,0x04,0x91,0xF4,
        0x32,0xD0,0x71,0xC9,0x91,0x0E,0x7D,0xE8,
        0x61,0xFB,0x04,0x8C,0x3F,0x48,0xE2,0xAE,
        0x2A,0x3E,0x28,0xF8,0x00,0x80,0x77,0x09,
        0xA8,0x5B,0x9D,0xC7,0xED,0xF3,0x06,0xF8,
        0xAF,0x17,0x58,0x82,0xF2,0x07,0x81,0x1A,
        0x99,0xA1,0x3D,0xCC,0xB7,0x19,0x43,0xBE,
        0x07,0x1C,0x16,0x3B,0x27,0xF9,0xF0,0x08,
        0x1C,0x8E,0x01,0x4F,0x1B,0xBE,0x51,0x7B,
        0xBE,0x3E,0x62,0x01,0x8E,0xFE,0xFF,0x47,
        0x2C,0x30,0x9D,0xDF,0x7D,0x82,0x01,0xC7,
        0xCD,0x82,0x9F,0x61,0x00,0x67,0x40,0xCF,
        0x30,0x60,0x1F,0x2A,0x6E,0x08,0x5C,0xEE,
        0x8A,0x28,0x90,0x05,0xC2,0xA0,0x0E,0xFD,
        0xE4,0x08,0x42,0xCF,0x9C,0x70,0x86,0x72,
        0xB2,0xBD,0x5F,0x1D,0xC8,0x2D,0xC2,0x43,
        0x3D,0x8B,0xC7,0x04,0x76,0xDA,0x02,0x36,
        0xFF,0xFF,0xE3,0x29,0xB0,0x98,0xF7,0xD3,
        0x69,0x84,0x63,0x03,0xFB,0x71,0x0B,0x38,
        0x1D,0xCC,0xE0,0xDC,0x7F,0xD8,0x2D,0x1A,
        0x37,0x34,0xB0,0x0D,0xCC,0x43,0x03,0x3E,
        0x27,0x47,0x30,0x9E,0x98,0xF8,0x55,0xE2,
        0xE1,0x89,0x1F,0x43,0xC0,0xFA,0xFF,0x3F,
        0x99,0x01,0xF6,0x84,0x1E,0xCB,0x50,0xD2,
        0x4E,0x66,0x80,0xC0,0xFB,0xD8,0x3B,0xC3,
        0x4B,0x83,0xE7,0x74,0xD2,0xCF,0x62,0x3E,
        0x99,0x19,0x21,0x0A,0xBB,0x8F,0x19,0xAD,
        0x37,0x14,0xCD,0x3C,0xE8,0x3B,0x99,0x51,
        0x62,0x46,0x6A,0x0E,0x4C,0x48,0x11,0x0F,
        0x27,0x4A,0x88,0x60,0xAF,0x13,0x6F,0x67,
        0x4F,0x66,0x4C,0xD6,0xC9,0x0C,0x24,0xFF,
        0xFF,0x93,0x19,0x98,0x5C,0x9F,0xCC,0x80,
        0xCA,0x39,0x0A,0x7F,0x32,0x03,0x78,0x74,
        0xC0,0xC2,0x9D,0xCC,0xC0,0xF2,0xFF,0x3F,
        0xC4,0x00,0xCE,0xC7,0x0A,0x63,0x0C,0x3C,
        0xDA,0xC1,0x0C,0x15,0xE6,0x6C,0x86,0x0E,
        0x72,0x08,0xA1,0xC1,0x0E,0x21,0x50,0xE6,
        0x72,0xA0,0xA7,0xF0,0x9A,0xE0,0x73,0x14,
        0xD8,0x0F,0x67,0xC0,0xE1,0xD4,0x80,0x0F,
        0x74,0xE2,0x42,0x8F,0xC2,0x23,0x0E,0x58,
        0xFD,0xC0,0xC8,0xFF,0xFF,0x64,0x06,0x18,
        0x78,0x6A,0xF8,0x40,0x82,0x63,0x31,0xEA,
        0x1B,0xC4,0x21,0xBE,0x8D,0xF8,0xE8,0xFE,
        0x6A,0xE2,0x4B,0x00,0xE6,0x42,0xE2,0xD3,
        0x09,0xB3,0x70,0x38,0x03,0x5A,0x43,0x60,
        0x57,0x26,0xCF,0x9C,0x0F,0xE1,0x6C,0x3C,
        0x7A,0xDC,0xE9,0x04,0xDE,0x38,0x7C,0x3A,
        0x01,0x5E,0x07,0x0C,0xCC,0x0C,0xC2,0x3F,
        0x84,0xB0,0x21,0x9C,0xAA,0xC7,0x70,0xEE,
        0xAF,0x38,0x3E,0x9D,0x80,0xF3,0xFF,0x7F,
        0x62,0x03,0x0C,0x0A,0x7E,0x32,0xF8,0xB8,
        0x46,0x25,0xC2,0xA0,0x8E,0xE6,0x80,0x7B,
        0x98,0x27,0x36,0x26,0x6F,0xC5,0x1A,0x8B,
        0x4F,0x6C,0x30,0xFF,0xFF,0x27,0x36,0x80,
        0xD1,0x87,0x20,0xB0,0xFD,0xFF,0x0F,0x41,
        0x60,0x1C,0xA0,0x0F,0x41,0x80,0x9B,0xD3,
        0x09,0xEE,0xC4,0x07,0xB6,0x63,0x10,0x60,
        0x6D,0xE8,0x3E,0x06,0x81,0xF9,0xFF,0x3F,
        0x5A,0x98,0xA3,0xE0,0xC2,0x8E,0x7C,0x28,
        0x29,0xA7,0x3E,0xB4,0x0C,0x20,0x69,0x38,
        0xC9,0x01,0x9D,0xD3,0x3D,0x70,0x92,0x75,
        0xEA,0x40,0x8F,0xC7,0xA0,0xAF,0x1C,0xBE,
        0x12,0xF0,0x23,0x07,0x93,0x00,0xAA,0x41,
        0xFA,0xCC,0x07,0x9C,0x8E,0x1C,0xE0,0x38,
        0x26,0x05,0xC6,0xDE,0x0E,0xDE,0x22,0x3D,
        0x89,0xA7,0xA1,0xE3,0x0C,0x51,0x38,0x26,
        0x39,0x18,0x44,0x7A,0x95,0x62,0x03,0x7C,
        0xAB,0xF1,0xD9,0xC8,0x07,0x10,0x78,0xE3,
        0xF6,0xD8,0x61,0xFF,0xFF,0x0F,0x75,0xC0,
        0x01,0xE2,0xA4,0xF8,0x21,0xC3,0x98,0x67,
        0xC5,0x0F,0x75,0x80,0xF5,0x18,0x27,0x3A,
        0x94,0xF0,0x43,0x1D,0x20,0xE8,0xFF,0x7F,
        0xA8,0x03,0x86,0x38,0x6F,0x24,0xD1,0x1E,
        0xEA,0x98,0xE8,0x43,0x1D,0x40,0xC8,0xFF,
        0xFF,0xA1,0x0E,0x18,0x9E,0x87,0x00,0xAE,
        0x9C,0xEF,0xC0,0x7C,0x22,0x02,0xEF,0xFF,
        0xFF,0x7C,0x07,0xB8,0x1B,0x2D,0xCC,0x51,
        0x70,0x41,0xAF,0x0E,0x03,0x51,0x09,0x30,
        0x28,0x02,0xC7,0x5F,0x9B,0x60,0x1C,0xEA,
        0x7C,0x87,0x3E,0x2F,0x78,0xD8,0x4F,0x05,
        0x9E,0xC4,0xA9,0xFA,0x5A,0x70,0x14,0x4F,
        0x00,0x3E,0xE1,0x01,0xFF,0xA1,0xC1,0x9A,
        0x44,0xF1,0x43,0x03,0xF5,0x11,0xE4,0xFF,
        0x7F,0x68,0xC0,0x28,0xEA,0xF9,0x06,0x7D,
        0xCC,0xF2,0xD9,0x20,0xE6,0x0B,0x48,0x84,
        0x07,0x10,0x5F,0x1F,0xD8,0x71,0xD2,0x67,
        0xA0,0x40,0x51,0xDE,0x37,0xF8,0x09,0x07,
        0x5C,0x83,0xF3,0x09,0x07,0xBC,0x87,0x23,
        0x1F,0x4B,0xC0,0x77,0xD0,0x84,0x73,0x81,
        0xF1,0x8D,0x8D,0x9D,0x06,0xC0,0x76,0x00,
        0x06,0xDF,0x69,0x00,0x1C,0xC7,0x24,0x7E,
        0x3A,0x04,0x13,0xCC,0xC1,0xBC,0x34,0xFB,
        0xFF,0xEF,0xFD,0x94,0x43,0xCF,0x86,0x80,
        0x75,0x49,0x07,0x43,0x94,0x88,0xB3,0x21,
        0x20,0xFD,0xFF,0x7F,0x36,0xC4,0x20,0xC4,
        0x09,0xFC,0x12,0xD1,0xDC,0xD9,0x90,0xAE,
        0xD8,0x67,0x43,0x80,0xE1,0xFF,0xFF,0x23,
        0x00,0xF6,0x7C,0x04,0x38,0x3D,0x64,0x83,
        0xE7,0x14,0x08,0xE3,0xE4,0x03,0x38,0xFE,
        0xFF,0x8F,0x15,0xE6,0x18,0x78,0xEA,0x97,
        0x9B,0x8F,0x03,0x54,0xD4,0x2B,0xC2,0x30,
        0x94,0xC5,0x87,0x05,0x1F,0x11,0xF8,0x61,
        0xC1,0x23,0xA8,0x78,0x9C,0xF4,0x74,0xE3,
        0x33,0x21,0x3B,0x24,0x38,0xFC,0x20,0xE9,
        0x41,0x13,0x3C,0xE7,0x23,0x78,0xB7,0x1E,
        0x38,0xA7,0x02,0xC0,0x4D,0xAE,0x27,0xA3,
        0x4E,0x17,0x0E,0x70,0x8E,0x92,0x8D,0x63,
        0x08,0xE5,0x70,0xCC,0xB7,0x87,0xA6,0xC9,
        0x4E,0x56,0x30,0x63,0x41,0xEA,0x24,0xE0,
        0x01,0x38,0x10,0x8C,0xB4,0x93,0x68,0x34,
        0x86,0xB3,0x5A,0x18,0xC1,0x19,0xC4,0xC7,
        0x11,0xE7,0x3A,0x19,0xA1,0x3F,0x07,0x3E,
        0x15,0x61,0x82,0xDC,0x4B,0xE8,0xBC,0x7D,
        0x37,0xE0,0x57,0x61,0x8F,0xC5,0xFF,0x7F,
        0x60,0xDF,0x4E,0xC0,0x31,0x17,0xAB,0x01,
        0x45,0x0D,0xC0,0x68,0x98,0x53,0xC0,0x53,
        0x09,0xB8,0x82,0xCD,0x0D,0x7D,0x61,0xB1,
        0xD6,0xA9,0xE8,0x14,0xF4,0x3E,0x70,0x70,
        0xC0,0x63,0xF6,0x1E,0x1C,0x2C,0x34,0x0F,
        0x0E,0x6C,0xD9,0x06,0x87,0x56,0x72,0x17,
        0x21,0x87,0x0F,0xFC,0xEC,0x80,0x03,0xA0,
        0x67,0x07,0x0B,0xC9,0xB3,0x03,0x9B,0xBE,
        0xB3,0x08,0x28,0x70,0xFE,0xFF,0x11,0xDE,
        0x3B,0x7C,0x6E,0x79,0xF6,0x60,0x63,0x78,
        0x74,0x31,0x9A,0xD1,0xB9,0xA6,0xDB,0x04,
        0x4A,0xC5,0x6D,0x82,0x82,0xF8,0x06,0xE0,
        0x84,0x34,0xBA,0x75,0xE2,0x66,0x62,0xFC,
        0x47,0x0C,0x1F,0x11,0x0E,0xE9,0x6C,0x4D,
        0x30,0x0F,0xA4,0x9E,0x81,0xBE,0xB3,0xE1,
        0x67,0x1F,0xF2,0xC1,0xC5,0xD3,0xF0,0xF5,
        0x86,0xDC,0x3B,0xE8,0xB4,0x7D,0x66,0xC0,
        0x1C,0x74,0x7D,0x9D,0x7A,0x83,0x27,0x57,
        0x09,0xEA,0xE1,0x02,0x42,0x2F,0x34,0xBE,
        0xDC,0x25,0x78,0xE0,0xF4,0xE9,0xEE,0xBD,
        0x84,0x9D,0xF1,0x12,0xBC,0xE0,0x25,0x98,
        0x77,0x10,0xA8,0x51,0x79,0x10,0x98,0xAB,
        0x3C,0xCB,0x37,0x06,0x54,0xB2,0x8B,0x16,
        0x3D,0xC3,0xBC,0xC3,0xF8,0x92,0xE0,0xEB,
        0x87,0xCF,0x2D,0x5E,0xC0,0xEB,0x16,0x0C,
        0x82,0x67,0xA0,0x57,0x17,0xDF,0xD9,0x0D,
        0xFC,0x2A,0xF0,0x46,0x13,0x22,0x98,0x61,
        0x0F,0xFF,0xDD,0xDD,0xA8,0xBE,0xE9,0x18,
        0xEB,0x75,0xC4,0x23,0xE5,0xC7,0x96,0x03,
        0x8A,0xF4,0xF2,0xE6,0x09,0xF8,0x2C,0xE3,
        0x53,0xDD,0x49,0xF9,0x7A,0x68,0xF4,0x57,
        0x08,0x1F,0x7E,0x8C,0xEC,0x73,0x0E,0x3B,
        0xDF,0xB1,0x41,0x71,0xC4,0x07,0x86,0x97,
        0x1A,0x4F,0x85,0x9D,0xBB,0x60,0x1C,0x1C,
        0xD8,0xB1,0x08,0x73,0x7C,0x05,0xD7,0xC9,
        0xE6,0xFF,0xFF,0xE4,0x00,0x6E,0x78,0xCC,
        0xC1,0xD7,0xE7,0x0D,0xDF,0x0C,0x3C,0x2E,
        0x7E,0xE4,0xF0,0x49,0xE3,0xA5,0xD3,0xD8,
        0xA7,0xE9,0xA3,0xD1,0xCB,0x9B,0x4F,0x2F,
        0x18,0x58,0x5F,0x1A,0x38,0xAC,0xD1,0xC2,
        0x3E,0x06,0x9C,0xB9,0x2F,0x44,0xB8,0xC3,
        0x23,0x58,0x00,0xF1,0xB7,0x92,0x47,0x0E,
        0x4F,0xC0,0x80,0x4C,0xD3,0xBA,0x74,0x20,
        0xE2,0xA7,0x3C,0x2B,0x5F,0x99,0x2E,0x43,
        0x0C,0xE3,0xA9,0xF2,0xF1,0xC3,0xB3,0xF1,
        0x51,0xC0,0xC7,0x28,0xCF,0xFC,0x8C,0x22,
        0xBD,0x32,0x10,0x50,0x9D,0x88,0xB8,0x42,
        0x18,0x89,0xA1,0xD1,0x9D,0x83,0xC7,0x1F,
        0x22,0x05,0x31,0xA0,0x6F,0x2E,0xC0,0xF4,
        0x4C,0x04,0x5C,0xFE,0xFF,0x37,0x17,0x80,
        0xFF,0xFF,0xFF,0x9B,0x0B,0xE0,0xE6,0xFE,
        0xE0,0x9B,0x0B,0x70,0x8D,0xB4,0x2A,0x7A,
        0x61,0x77,0x08,0x18,0xD4,0x9D,0x1D,0x70,
        0x78,0x2B,0x78,0x67,0x87,0xF5,0xFF,0xBF,
        0xB3,0xC3,0xC3,0x8C,0x13,0xE5,0x85,0x21,
        0xC6,0x3B,0x3B,0x0B,0xF0,0x26,0xD0,0x51,
        0xC6,0x77,0x76,0x80,0x1F,0x67,0xD8,0x77,
        0x69,0xF0,0x5E,0x75,0x81,0xF5,0xFF,0xFF,
        0xAA,0x0B,0x3C,0x04,0xDF,0xA7,0x41,0x3E,
        0x5E,0x30,0x8C,0x83,0x2B,0x27,0xA1,0xC7,
        0x02,0x6B,0x85,0x41,0xDD,0xA9,0xC1,0xA5,
        0x09,0x5C,0x17,0x5F,0x1F,0x6A,0x7C,0xA4,
        0xC5,0x9F,0x2F,0x70,0x01,0x86,0x4C,0x4F,
        0x65,0x30,0xAE,0x29,0x3E,0x95,0x61,0xEE,
        0x0E,0x1E,0x90,0x8F,0x18,0xC0,0x67,0x15,
        0x1E,0x18,0xEE,0xB4,0xE0,0x9B,0x92,0x41,
        0xCF,0x31,0xA8,0x8F,0x3C,0x27,0xEF,0x7B,
        0xC2,0xE3,0x84,0xA3,0x9E,0x83,0xE8,0xD8,
        0xC0,0x71,0xDC,0xC0,0xFD,0xFF,0xC7,0x06,
        0xEF,0x70,0x83,0x3B,0xE8,0xF8,0x62,0x70,
        0x5C,0x18,0xB8,0xE7,0x02,0x0F,0xC3,0x37,
        0x1D,0x8F,0x08,0x33,0xFE,0xD7,0x3F,0x23,
        0x04,0xC4,0x5F,0x8C,0xD8,0x80,0xC1,0x78,
        0x6B,0xF3,0xF5,0x0D,0x37,0x60,0x5F,0x1D,
        0x7C,0xC1,0xF0,0x09,0xCC,0xE8,0x2F,0x30,
        0x4F,0x62,0x3E,0x36,0x90,0x0B,0x1C,0x1D,
        0x30,0x38,0x00,0x3D,0x60,0xF8,0x87,0x8B,
        0x77,0x39,0x30,0x5C,0x05,0x7D,0x5C,0xF0,
        0xB1,0xC7,0x8A,0xEE,0x72,0xE8,0x9B,0x9C,
        0x61,0xE2,0x18,0xE2,0x0D,0x8C,0xDD,0x25,
        0xC8,0x61,0x0E,0xEA,0x5D,0xC2,0x73,0xE0,
        0x67,0x0B,0x9F,0xE0,0x7C,0xF3,0x09,0x71,
        0xAA,0x8F,0x56,0xEF,0x01,0x3E,0x7A,0xBC,
        0x77,0xF9,0xEC,0xC4,0x2E,0x02,0x3E,0x72,
        0x19,0xC7,0xD3,0xF4,0x15,0xD0,0x43,0x36,
        0xD8,0xAB,0x86,0x4F,0x60,0x3E,0xBA,0xE1,
        0x8E,0x51,0x9E,0x89,0xA7,0xEF,0x3B,0x08,
        0x3B,0x92,0x1C,0x75,0xA8,0x6B,0x7A,0x44,
        0xF9,0xFF,0x9F,0xD0,0x81,0xF8,0xD6,0x06,
        0xCE,0x68,0xF7,0x0F,0xF4,0x36,0x3D,0x32,
        0xCC,0xD1,0x00,0xD6,0x25,0x04,0x5C,0x77,
        0x0C,0x5F,0x42,0x80,0x4F,0xD0,0x4B,0x04,
        0xFA,0x9A,0xE1,0xD1,0x3D,0x02,0x60,0xAE,
        0x18,0xEC,0x58,0xE0,0xC3,0x86,0xAF,0x01,
        0xEC,0x5E,0xE0,0x30,0xF7,0x08,0x50,0x81,
        0x7A,0x78,0xF0,0xD5,0xDE,0x23,0x40,0x71,
        0xB2,0xF4,0xA1,0xC1,0x03,0xB5,0xAA,0x33,
        0x26,0x94,0x23,0x26,0x3F,0x9B,0xF9,0x26,
        0x81,0xB9,0x5D,0xFA,0x26,0x01,0x37,0xCF,
        0x2C,0x50,0x49,0x20,0xF4,0xFF,0xBF,0x49,
        0xC0,0x85,0xE9,0xF2,0x32,0x43,0xE7,0x7F,
        0xE0,0xBE,0xD5,0x79,0x84,0x3E,0x44,0x30,
        0x94,0xF7,0x3C,0x9F,0xC2,0xF8,0x19,0xC2,
        0x07,0x4C,0x76,0xA6,0xE0,0x67,0x4D,0xDC,
        0x1D,0xC0,0x28,0x6F,0x9E,0x9E,0x00,0x3B,
        0x7F,0x1A,0xF9,0xDD,0xE0,0x5D,0xC0,0xD3,
        0xF7,0xBD,0x88,0x9F,0x28,0xC0,0x17,0xEC,
        0x4E,0x07,0x05,0xFA,0x84,0x3C,0x22,0xA3,
        0xFA,0x88,0xC0,0x2F,0x49,0x60,0x3C,0x92,
        0xF8,0x40,0x01,0x84,0xEE,0x05,0xA8,0xD3,
        0x07,0x47,0x3D,0xE3,0x17,0x54,0x63,0xBE,
        0x5B,0x3D,0xC2,0x79,0x72,0x98,0xCB,0x01,
        0x8B,0x73,0x4D,0x02,0xD5,0x71,0x97,0x8F,
        0x0E,0xEE,0xB5,0x15,0xFB,0xFF,0x27,0x38,
        0xB8,0x77,0x96,0x77,0x3E,0x43,0x79,0x90,
        0xE0,0xBB,0xB6,0x82,0xE3,0xAA,0x06,0xE3,
        0xD8,0xC2,0x2F,0x79,0x80,0x9D,0x61,0x71,
        0xC1,0x7F,0x0F,0x03,0x51,0x89,0x30,0x28,
        0x02,0xCB,0xBB,0xB7,0x52,0xF8,0x43,0x06,
        0xE3,0x4D,0x81,0x4F,0x1A,0x3B,0x6A,0xE0,
        0xFB,0xFF,0x1F,0x35,0xD8,0x86,0x8A,0xBB,
        0x29,0x82,0x75,0xAA,0x98,0x21,0xF0,0x60,
        0x0F,0x00,0x9F,0xAF,0x7C,0x06,0x50,0x14,
        0x18,0xD4,0xA1,0x1D,0xCE,0x6D,0x18,0x70,
        0x30,0x62,0xDC,0xA5,0x10,0xEE,0x94,0xDF,
        0x51,0x62,0x3F,0x97,0xB3,0xE9,0xE2,0xAE,
        0xE6,0x3E,0x9D,0xB0,0x0B,0x32,0x8C,0xB3,
        0xC0,0x23,0xC0,0xAB,0x39,0xBF,0x20,0x3F,
        0x17,0xBF,0x10,0x3C,0x26,0x85,0x78,0x53,
        0x7A,0x25,0x36,0xC6,0x93,0x71,0x73,0xB7,
        0x62,0x72,0xDE,0x79,0x41,0x36,0xC6,0xD1,
        0x44,0x8C,0x72,0x6E,0x0F,0x03,0x91,0x5F,
        0x90,0x7D,0x3F,0x79,0x21,0x88,0x18,0xCD,
        0x10,0x41,0x9F,0x97,0x8D,0x15,0x28,0xDE,
        0x0B,0x32,0x13,0xF8,0x56,0xD0,0xC1,0xC5,
        0x17,0x64,0xEC,0xFF,0xFF,0x82,0x0C,0x30,
        0xE2,0x64,0x04,0xF8,0x3C,0x71,0xE0,0xCE,
        0x35,0x30,0xFE,0xFF,0x97,0x6A,0xD8,0x27,
        0x1B,0xC0,0xD9,0xD0,0x7D,0xB2,0x01,0xF7,
        0x68,0xE1,0x1D,0x4D,0x10,0x27,0x1B,0x0A,
        0xE4,0xE0,0xEB,0xA2,0x70,0x3C,0xF4,0x49,
        0x84,0x1E,0x9D,0x7C,0x94,0xC4,0x9D,0x19,
        0x3C,0x91,0x77,0x16,0x8F,0xE2,0x65,0xD0,
        0xF7,0x82,0x13,0x79,0x7D,0xB0,0x9C,0x63,
        0x24,0xA8,0x46,0xE2,0xE3,0x03,0xFC,0xEB,
        0x8B,0x8F,0x91,0xF0,0xF9,0xFC,0xC3,0xF2,
        0x60,0x0C,0xF9,0xFF,0x7F,0x8A,0xC4,0x80,
        0x3C,0xBB,0x3C,0x86,0xF0,0x0B,0x24,0xDC,
        0xD3,0xCC,0x01,0x60,0x64,0x5D,0x1E,0xD1,
        0x67,0x47,0x8E,0x11,0xD7,0x17,0x45,0x5F,
        0x81,0x7D,0x10,0x38,0x9F,0xE7,0x44,0xB0,
        0x8E,0x9A,0x1F,0x6D,0xF8,0xF8,0x39,0xF8,
        0x5B,0xC1,0x03,0xA5,0x8F,0x45,0x21,0x1E,
        0x91,0xF8,0x39,0x11,0x5C,0x26,0xCE,0x89,
        0x40,0xE2,0xD0,0x0B,0xE3,0xB4,0x80,0x1B,
        0x88,0xCF,0x94,0xD8,0x29,0x9F,0x08,0x3B,
        0x97,0x60,0x46,0x07,0xAE,0xCB,0xBD,0x47,
        0x07,0xFE,0x93,0x00,0x1E,0xEB,0xFF,0xFF,
        0x78,0x07,0xBE,0x93,0xBA,0xEF,0x26,0xBE,
        0xC8,0xF8,0x50,0xF4,0x7C,0x07,0xF8,0x0F,
        0x77,0xB8,0x43,0xC5,0x39,0xDF,0x01,0xD2,
        0xFE,0xFF,0xE7,0x3B,0x60,0x79,0xB6,0x7E,
        0xBE,0x03,0xBB,0xC8,0xF3,0x1D,0x40,0xAC,
        0xFF,0xFF,0xF9,0x0E,0xB0,0x73,0x46,0xC3,
        0x9D,0xEF,0xC0,0x76,0xB4,0x01,0xCC,0x4D,
        0xE3,0xD1,0x06,0xDC,0xC3,0x85,0x3D,0x0C,
        0xAE,0xD0,0xA6,0x4F,0x8D,0x46,0xAD,0x1A,
        0x94,0xA9,0x51,0xE6,0xFF,0xDF,0xA0,0x56,
        0x9F,0x4A,0x8D,0x19,0xCB,0x0E,0xA5,0x80,
        0x8F,0x0A,0x8D,0xCD,0xF2,0x28,0x04,0x62,
        0x31,0xAF,0x06,0x81,0x38,0x2C,0x08,0x8D,
        0xF4,0xCA,0x11,0x88,0x25,0x3F,0xFB,0x05,
        0x62,0xB9,0x6F,0x06,0x81,0x38,0xE0,0x1B,
        0x4C,0xE0,0xE4,0x61,0x25,0x70,0xF2,0x6E,
        0x10,0x88,0x23,0x83,0x50,0xA1,0x3A,0x40,
        0x58,0x4C,0x10,0x1A,0xCA,0x07,0x08,0x93,
        0xFE,0x48,0x10,0x20,0x31,0x02,0xC2,0xC2,
        0xBD,0xBF,0x04,0x62,0x69,0xEF,0x09,0x81,
        0x58,0x88,0x15,0x10,0x16,0x17,0x84,0x86,
        0xD3,0x02,0xC2,0x24,0x99,0x01,0x61,0x81,
        0x40,0xA8,0x7C,0x35,0x20,0x4C,0xA4,0x1B,
        0x40,0xBA,0x7A,0x81,0x38,0x88,0x1E,0x10,
        0x26,0xC3,0x0F,0x08,0x0B,0x0D,0x42,0xA3,
        0x3D,0x30,0x04,0x48,0x0C,0x81,0xB0,0xF8,
        0x8E,0x40,0x98,0xF8,0x57,0x91,0x40,0x9C,
        0xDF,0x12,0xC4,0x4D,0x69,0x88,0x35,0x01,
        0x31,0x0D,0x9E,0x80,0x98,0x22,0x10,0x01,
        0x39,0xF6,0xD3,0x43,0x40,0xD6,0x60,0x0A,
        0x88,0x45,0x07,0x11,0x90,0x85,0xA8,0x02,
        0x62,0x79,0x5D,0x01,0xB1,0xF0,0x20,0x02,
        0x72,0xE6,0x97,0x9F,0x80,0xAC,0xE0,0xA5,
        0xF3,0x10,0xC0,0xDE,0x10,0x81,0x48,0x72,
        0x10,0x01,0x39,0xB0,0x2F,0x20,0x16,0x1F,
        0x44,0x40,0xCE,0xFA,0x28,0x14,0x90,0x83,
        0x83,0x68,0x10,0xE4,0x6B,0x26,0x20,0xA7,
        0x07,0x11,0x10,0xF9,0x04,0x05,0x21,0x6A,
        0xBD,0x81,0x30,0x3D,0x8F,0x42,0x0D,0x85,
        0x80,0x50,0xE5,0xEA,0xCE,0x31,0x2C,0x07,
        0x08,0xCD,0x05,0x22,0x30,0xAB,0x70,0x07,
        0xC4,0x54,0x81,0x08,0xC8,0x09,0x80,0xC8,
        0xFF,0x9F,0x60,0x2A,0x10,0x9A,0x12,0x8C,
        0xEA,0x92,0x07,0xC4,0x12,0x80,0xD0,0x54,
        0x20,0x34,0x25,0x88,0x00,0xAD,0xCA,0x1E,
        0x10,0x53,0x0A,0x42,0x95,0x83,0xD0,0x74,
        0x20,0x54,0xB6,0xBE,0xC3,0x02,0x05,0x11,
        0x90,0xA3,0x83,0x50,0xE1,0xFE,0x40,0x98,
        0xDE,0x97,0x86,0x00,0x9D,0x0E,0x44,0x40,
        0x4E,0x0C,0x42,0x15,0x7C,0x32,0x82,0x10,
        0xB1,0x20,0x54,0xC1,0x27,0x23,0x28,0xD1,
        0xF2,0xB2,0x13,0x90,0xF5,0x81,0x50,0xBD,
        0x20,0x02,0x73,0x36,0x20,0x9A,0x17,0x84,
        0xE6,0x07,0xA3,0x5A,0x8D,0x02,0x31,0xFD,
        0x20,0x34,0x0F,0x88,0xC0,0xAC,0xE0,0xF9,
        0x71,0xC0,0x0C,0x84,0xAA,0x04,0x11,0x98,
        0x73,0x01,0xD1,0xAC,0x20,0x34,0x3B,0x18,
        0xD5,0xFE,0x0F,0xD1,0x00,0x08,0x08,0xCD,
        0x07,0xA2,0xC3,0x00,0x79,0x96,0x09,0xC8,
        0x1A,0x41,0xA8,0x66,0x10,0x81,0x39,0x27,
        0x10,0xCD,0x0E,0x42,0x95,0xFD,0x4D,0x82,
        0x91,0x8C,0x0F,0xD0,0x40,0x24,0x37,0x08,
        0xD5,0xF1,0x0C,0x0A,0x46,0x74,0x83,0x08,
        0xC8,0x59,0x40,0x68,0x36,0x30,0x9A,0x4C,
        0xED,0x91,0x80,0xBA,0x05,0x61,0xE9,0x41,
        0x68,0x3A,0xBB,0x83,0xA7,0x20,0x54,0x81,
        0x5E,0x30,0xA6,0x19,0x44,0x87,0x05,0x02,
        0x42,0x73,0x81,0x51,0x1D,0xAF,0x96,0x40,
        0x44,0x1B,0x08,0xD5,0x0A,0xA2,0x81,0x93,
        0x1F,0x53,0x10,0x92,0x14,0x84,0xFC,0xFF,
        0x07,0xAA,0xC7,0x9C,0x40,0xAC,0xFA,0x5B,
        0x25,0x50,0x27,0x01,0xA1,0xC9,0x40,0x74,
        0x7C,0x20,0x0F,0xB8,0x83,0x64,0x20,0x54,
        0x29,0x88,0xC0,0xAC,0xF4,0x63,0xA4,0x23,
        0x05,0x51,0x7D,0xBC,0xA0,0x20,0x34,0xD1,
        0x3B,0x2C,0x08,0x7B,0xB8,0x69,0xA8,0xE4,
        0x59,0xA5,0xA1,0x12,0x10,0x9A,0x0D,0x44,
        0xC7,0x04,0xF2,0xAA,0x79,0x4C,0x60,0x20,
        0x54,0x2F,0x08,0xCD,0x01,0x42,0x13,0x83,
        0x08,0xD4,0xA9,0xBF,0x37,0x1A,0x2A,0xF9,
        0x5B,0x09,0xC4,0xCA,0x5E,0x69,0x02,0xB1,
        0xDE,0xA7,0x4E,0x20,0xE6,0x1D,0x98,0xA9,
        0x05,0xA1,0xEA,0x41,0x04,0xE6,0xB4,0x40,
        0x54,0x81,0x78,0x10,0xA6,0x08,0x44,0x60,
        0x4E,0x02,0x44,0xD3,0x81,0xD0,0xEC,0x60,
        0x54,0xE7,0xA3,0x4D,0x40,0xD6,0x0E,0x42,
        0xB3,0x80,0x08,0xCC,0x59,0x1E,0x69,0x02,
        0xB1,0x92,0x2F,0x9D,0x0E,0x24,0x04,0x84,
        0x26,0xD3,0x7F,0x68,0xA1,0x05,0x80,0x99,
        0x84,0x04,0x20,0x4C,0x16,0x88,0x0E,0x27,
        0xD6,0x08,0x22,0x40,0xC7,0x01,0xA3,0xD1,
        0x40,0x68,0x5C,0x40,0x9A,0x1D,0x90,0x2A,
        0x6D,0x00,0xC6,0x54,0x83,0xD0,0x24,0x20,
        0x02,0x74,0x2C,0x10,0x01,0x5A,0x74,0x04,
        0x30,0x16,0x01,0x84,0x46,0x05,0xA1,0xC9,
        0x2A,0x80,0xB2,0x9C,0x20,0x1A,0x20,0xC9,
        0x30,0x60,0x0A,0x42,0x33,0x81,0xD0,0x8C,
        0x20,0x54,0x7C,0x07,0x10,0x16,0x04,0x84,
        0x86,0x03,0xD1,0x00,0xFE,0xFF,0x8F,0x0C,
        0x02,0xD1,0x00,0x9C,0x23,0xC4,0x61,0x85,
        0x82,0xD0,0xF4,0x20,0x34,0x6C,0x09,0x50,
        0x16,0x1D,0x44,0xC7,0x23,0x92,0x02,0x8C,
        0x05,0x02,0xA1,0x31,0x41,0x68,0x6C,0x10,
        0x1A,0x29,0x06,0x28,0x13,0x54,0xE3,0x50,
        0x44,0x7B,0x80,0x31,0x99,0x20,0x54,0x36,
        0x88,0xC0,0x1C,0x14,0x88,0x86,0x07,0xA1,
        0x62,0x82,0x00,0x52,0x10,0x01,0x12,0x20,
        0x1A,0x1E,0x84,0x8A,0x29,0x32,0x74,0x0A,
        0x42,0x55,0x24,0x39,0x9A,0x50,0x10,0x1D,
        0x4D,0x08,0x08,0xCD,0x07,0x46,0x75,0x35,
        0x39,0x6E,0x50,0x10,0xAA,0x1D,0x84,0x06,
        0x05,0xA1,0x39,0xA2,0x80,0xB2,0xEC,0x20,
        0x02,0xB2,0x9E,0x2A,0x87,0x0A,0x0A,0x22,
        0x30,0xA7,0x02,0xA2,0x49,0x41,0xA8,0x8E,
        0x2C,0x47,0x0A,0x9A,0x06,0x84,0x25,0x06,
        0xA1,0xC9,0xDA,0x80,0xB0,0x0C,0x75,0x0E,
        0x24,0x14,0x84,0xE6,0x04,0xA1,0x4A,0xF2,
        0x0C,0x8F,0x82,0xE8,0x38,0x42,0x80,0x68,
        0x7A,0x10,0xAA,0xA6,0xCF,0x00,0x28,0x88,
        0x06,0x40,0x40,0x68,0x4E,0x30,0xAA,0xA8,
        0xD1,0xD1,0x84,0x82,0x50,0xDD,0x2F,0x4E,
        0x81,0xF8,0xFF,0x0F,
    })  // END MBUF
 
} //end DefinitionBlock
Rev 1498	Rev 2216
1	/*	1	/*
2	* Some or all of this work - Copyright (c) 2006 - 2010, Intel Corp.	2	* Some or all of this work - Copyright (c) 2006 - 2011, Intel Corp.
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without modification,	5	* Redistribution and use in source and binary forms, with or without modification,
6	* are permitted provided that the following conditions are met:	6	* are permitted provided that the following conditions are met:
7	*	7	*
8	* Redistributions of source code must retain the above copyright notice,	8	* Redistributions of source code must retain the above copyright notice,
9	* this list of conditions and the following disclaimer.	9	* this list of conditions and the following disclaimer.
10	* Redistributions in binary form must reproduce the above copyright notice,	10	* Redistributions in binary form must reproduce the above copyright notice,
11	* this list of conditions and the following disclaimer in the documentation	11	* this list of conditions and the following disclaimer in the documentation
12	* and/or other materials provided with the distribution.	12	* and/or other materials provided with the distribution.
13	* Neither the name of Intel Corporation nor the names of its contributors	13	* Neither the name of Intel Corporation nor the names of its contributors
14	* may be used to endorse or promote products derived from this software	14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.	15	* without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"	17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	18	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	20	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL	21	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;	22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,	25	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
26	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	//	29	//
30	//	30	//
31	// Grammar.asl - Minimally excercises most ASL constructs	31	// Grammar.asl - Minimally excercises most ASL constructs
32	//	32	//
33	// NOTE -- use: iasl -f -of grammar.asl to compile	33	// NOTE -- use: iasl -f -of grammar.asl to compile
34	//	34	//
35	// This 1) Ignores errors (checks compiler error handling)	35	// This 1) Ignores errors (checks compiler error handling)
36	// 2) Disables constant folding	36	// 2) Disables constant folding
37	//	37	//
38	//	38	//
39		39
40	/*******************************************************************************	40	/*******************************************************************************
41	Compilation should look like this:	41	Compilation should look like this:
42		42
43	C:\acpica\tests\misc>iasl -f -of grammar.asl	43	C:\acpica\tests\misc>iasl -f -of grammar.asl
44		44
45	Intel ACPI Component Architecture	45	Intel ACPI Component Architecture
46	ASL Optimizing Compiler version 20090422 [Apr 22 2009]	46	ASL Optimizing Compiler version 20090422 [Apr 22 2009]
47	Copyright (C) 2000 - 2009 Intel Corporation	47	Copyright (C) 2000 - 2009 Intel Corporation
48	Supports ACPI Specification Revision 3.0a	48	Supports ACPI Specification Revision 3.0a
49		49
50	grammar.asl 187: Name (_NPK, Package (8)	50	grammar.asl 187: Name (_NPK, Package (8)
51	Warning 1098 - ^ Unknown reserved name (_NPK)	51	Warning 1098 - ^ Unknown reserved name (_NPK)
52		52
53	grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn")	53	grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn")
54	Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL	54	Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
55		55
56	grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn")	56	grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn")
57	Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL	57	Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
58		58
59	grammar.asl 601: Method (RCIV, 1)	59	grammar.asl 601: Method (RCIV, 1)
60	Warning 1087 - ^ Not all control paths return a value (RCIV)	60	Warning 1087 - ^ Not all control paths return a value (RCIV)
61		61
62	grammar.asl 608: RCIV (Subtract (Arg0, 1))	62	grammar.asl 608: RCIV (Subtract (Arg0, 1))
63	Remark 5073 - ^ Recursive method call (RCIV)	63	Remark 5073 - ^ Recursive method call (RCIV)
64		64
65	grammar.asl 937: Method (_ERR, 2)	65	grammar.asl 937: Method (_ERR, 2)
66	Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3)	66	Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3)
67		67
68	grammar.asl 1377: Store (0x1234567887654321, QWD2)	68	grammar.asl 1377: Store (0x1234567887654321, QWD2)
69	Warning 1032 - ^ 64-bit integer in 32-bit table, truncating	69	Warning 1032 - ^ 64-bit integer in 32-bit table, truncating
70		70
71	grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321))	71	grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321))
72	Warning 1032 - 64-bit integer in 32-bit table, truncating ^	72	Warning 1032 - 64-bit integer in 32-bit table, truncating ^
73		73
74	grammar.asl 1459: SizeOf (BUFO)	74	grammar.asl 1459: SizeOf (BUFO)
75	Warning 1105 - ^ Result is not used, operator has no effect	75	Warning 1105 - ^ Result is not used, operator has no effect
76		76
77	grammar.asl 1485: Acquire (MTX2, 1)	77	grammar.asl 1485: Acquire (MTX2, 1)
78	Warning 1104 - ^ Possible operator timeout is ignored	78	Warning 1104 - ^ Possible operator timeout is ignored
79		79
80	grammar.asl 1633: Add (Local0, Local1)	80	grammar.asl 1633: Add (Local0, Local1)
81	Warning 1105 - ^ Result is not used, operator has no effect	81	Warning 1105 - ^ Result is not used, operator has no effect
82		82
83	grammar.asl 1804: Method (COND)	83	grammar.asl 1804: Method (COND)
84	Warning 1087 - ^ Not all control paths return a value (COND)	84	Warning 1087 - ^ Not all control paths return a value (COND)
85		85
86	grammar.asl 6010: Name (_HID, "*PNP0A06")	86	grammar.asl 6010: Name (_HID, "*PNP0A06")
87	Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06)	87	Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06)
88		88
89	grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})	89	grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
90	Warning 1038 - Invalid or unknown escape sequence ^	90	Warning 1038 - Invalid or unknown escape sequence ^
91		91
92	grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1	92	grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1
93	Error 4050 - ^ Method local variable is not initialized (Local0)	93	Error 4050 - ^ Method local variable is not initialized (Local0)
94		94
95	grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID	95	grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID
96	Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A)	96	Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A)
97		97
98	ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords	98	ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
99	AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes	99	AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
100		100
101	Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations	101	Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
102		102
103	***************************************************************************************************/	103	***************************************************************************************************/
104		104
105	DefinitionBlock (	105	DefinitionBlock (
106	"grammar.aml", //Output filename	106	"grammar.aml", //Output filename
107	"DSDT", //Signature	107	"DSDT", //Signature
108	0x01, //DSDT Revision ---> 32-bit table	108	0x01, //DSDT Revision ---> 32-bit table
109	"Intel", //OEMID	109	"Intel", //OEMID
110	"GRMTEST", //TABLE ID	110	"GRMTEST", //TABLE ID
111	0x20090511 //OEM Revision	111	0x20090511 //OEM Revision
112	)	112	)
113	{	113	{
114		114
115	External (\ABCD, UnknownObj)	115	External (\ABCD, UnknownObj)
116		116
117		117
118	/* Device with _STA and _INI */	118	/* Device with _STA and _INI */
119		119
120	Device (A1)	120	Device (A1)
121	{	121	{
122	Method (_STA)	122	Method (_STA)
123	{	123	{
124	Return (0x0F)	124	Return (0x0F)
125	}	125	}
126		126
127	Method (_INI)	127	Method (_INI)
128	{	128	{
129	Return	129	Return
130	}	130	}
131	}	131	}
132		132
133	/* Device with no _STA, has _INI */	133	/* Device with no _STA, has _INI */
134		134
135	Device (A2)	135	Device (A2)
136	{	136	{
137	Method (_INI)	137	Method (_INI)
138	{	138	{
139	Return	139	Return
140	}	140	}
141	}	141	}
142		142
143	/* Device with _STA, no _INI */	143	/* Device with _STA, no _INI */
144		144
145	Device (A3)	145	Device (A3)
146	{	146	{
147	Method (_STA)	147	Method (_STA)
148	{	148	{
149	Return (0x0F)	149	Return (0x0F)
150	}	150	}
151	}	151	}
152		152
153	/* Device with _STA and _INI, but not present */	153	/* Device with _STA and _INI, but not present */
154		154
155	Device (A4)	155	Device (A4)
156	{	156	{
157	Method (_STA)	157	Method (_STA)
158	{	158	{
159	Return (Zero)	159	Return (Zero)
160	}	160	}
161		161
162	Method (_INI)	162	Method (_INI)
163	{	163	{
164	Return	164	Return
165	}	165	}
166	}	166	}
167		167
168		168
169	/* Resource descriptors */	169	/* Resource descriptors */
170		170
171	Device (IRES)	171	Device (IRES)
172	{	172	{
173	Name (PRT0, ResourceTemplate ()	173	Name (PRT0, ResourceTemplate ()
174	{	174	{
175	IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}	175	IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
176		176
177	StartDependentFn (1,1)	177	StartDependentFn (1,1)
178	{	178	{
179	IRQNoFlags () {0,1,2}	179	IRQNoFlags () {0,1,2}
180	}	180	}
181	EndDependentFn ()	181	EndDependentFn ()
182	})	182	})
183		183
184	Method (_CRS, 0, NotSerialized)	184	Method (_CRS, 0, NotSerialized)
185	{	185	{
186	Store ("_CRS:", Debug)	186	Store ("_CRS:", Debug)
187	Store (PRT0, Debug)	187	Store (PRT0, Debug)
188	Return (PRT0)	188	Return (PRT0)
189	}	189	}
190		190
191	Method (_SRS, 1, Serialized)	191	Method (_SRS, 1, Serialized)
192	{	192	{
193	Store ("_SRS:", Debug)	193	Store ("_SRS:", Debug)
194	Store (Arg0, Debug)	194	Store (Arg0, Debug)
195	Return (Zero)	195	Return (Zero)
196	}	196	}
197	}	197	}
198		198
199	Name (_NPK, Package ()	199	Name (_NPK, Package ()
200	{	200	{
201	0x1111,	201	0x1111,
202	0x2222,	202	0x2222,
203	0x3333,	203	0x3333,
204	0x4444	204	0x4444
205	})	205	})
206		206
207		207
208	Device (RES)	208	Device (RES)
209	{	209	{
210	Name (_PRT, Package (0x04)	210	Name (_PRT, Package (0x04)
211	{	211	{
212	Package (0x04)	212	Package (0x04)
213	{	213	{
214	0x0002FFFF,	214	0x0002FFFF,
215	Zero,	215	Zero,
216	Zero,	216	Zero,
217	Zero	217	Zero
218	},	218	},
219		219
220	Package (0x04)	220	Package (0x04)
221	{	221	{
222	0x0002FFFF,	222	0x0002FFFF,
223	One,	223	One,
224	Zero,	224	Zero,
225	Zero	225	Zero
226	},	226	},
227		227
228	Package (0x04)	228	Package (0x04)
229	{	229	{
230	0x000AFFFF,	230	0x000AFFFF,
231	Zero,	231	Zero,
232	Zero,	232	Zero,
233	Zero	233	Zero
234	},	234	},
235		235
236	Package (0x04)	236	Package (0x04)
237	{	237	{
238	0x000BFFFF,	238	0x000BFFFF,
239	Zero,	239	Zero,
240	Zero,	240	Zero,
241	Zero	241	Zero
242	}	242	}
243	})	243	})
244		244
245	Method (_CRS, 0, NotSerialized)	245	Method (_CRS, 0, NotSerialized)
246	{	246	{
247	Name (PRT0, ResourceTemplate ()	247	Name (PRT0, ResourceTemplate ()
248	{	248	{
249	WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,	249	WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
250	0x0000, // Address Space Granularity	250	0x0000, // Address Space Granularity
251	0xFFF2, // Address Range Minimum	251	0xFFF2, // Address Range Minimum
252	0xFFF3, // Address Range Maximum	252	0xFFF3, // Address Range Maximum
253	0x0032, // Address Translation Offset	253	0x0032, // Address Translation Offset
254	0x0002,,,)	254	0x0002,,,)
255	WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,	255	WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
256	0x0000, // Address Space Granularity	256	0x0000, // Address Space Granularity
257	0x0000, // Address Range Minimum	257	0x0000, // Address Range Minimum
258	0x00FF, // Address Range Maximum	258	0x00FF, // Address Range Maximum
259	0x0000, // Address Translation Offset	259	0x0000, // Address Translation Offset
260	0x0100,,,)	260	0x0100,,,)
261	WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,	261	WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
262	0x0000, // Address Space Granularity	262	0x0000, // Address Space Granularity
263	0xA000, // Address Range Minimum	263	0xA000, // Address Range Minimum
264	0xBFFF, // Address Range Maximum	264	0xBFFF, // Address Range Maximum
265	0x0000, // Address Translation Offset	265	0x0000, // Address Translation Offset
266	0x2000,,,)	266	0x2000,,,)
267	IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)	267	IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)
268	WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,	268	WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
269	0x0000, // Address Space Granularity	269	0x0000, // Address Space Granularity
270	0x0000, // Address Range Minimum	270	0x0000, // Address Range Minimum
271	0x0CF7, // Address Range Maximum	271	0x0CF7, // Address Range Maximum
272	0x0000, // Address Translation Offset	272	0x0000, // Address Translation Offset
273	0x0CF8,,,	273	0x0CF8,,,
274	, TypeStatic)	274	, TypeStatic)
275	WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,	275	WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
276	0x0000, // Address Space Granularity	276	0x0000, // Address Space Granularity
277	0x0D00, // Address Range Minimum	277	0x0D00, // Address Range Minimum
278	0xFFFF, // Address Range Maximum	278	0xFFFF, // Address Range Maximum
279	0x0000, // Address Translation Offset	279	0x0000, // Address Translation Offset
280	0xF300,,,	280	0xF300,,,
281	, TypeStatic)	281	, TypeStatic)
282	DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,	282	DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
283	0x00000000, // Address Space Granularity	283	0x00000000, // Address Space Granularity
284	0x00000000, // Address Range Minimum	284	0x00000000, // Address Range Minimum
285	0x00000CF7, // Address Range Maximum	285	0x00000CF7, // Address Range Maximum
286	0x00000000, // Address Translation Offset	286	0x00000000, // Address Translation Offset
287	0x00000CF8,,,	287	0x00000CF8,,,
288	, TypeStatic)	288	, TypeStatic)
289	DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,	289	DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
290	0x00000000, // Address Space Granularity	290	0x00000000, // Address Space Granularity
291	0x000C8000, // Address Range Minimum	291	0x000C8000, // Address Range Minimum
292	0x000EFFFF, // Address Range Maximum	292	0x000EFFFF, // Address Range Maximum
293	0x00000000, // Address Translation Offset	293	0x00000000, // Address Translation Offset
294	0x00028000,,,	294	0x00028000,,,
295	, AddressRangeMemory, TypeStatic)	295	, AddressRangeMemory, TypeStatic)
296	DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,	296	DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
297	0x00000000, // Address Space Granularity	297	0x00000000, // Address Space Granularity
298	0x000C8000, // Address Range Minimum	298	0x000C8000, // Address Range Minimum
299	0x000EFFFF, // Address Range Maximum	299	0x000EFFFF, // Address Range Maximum
300	0x00000000, // Address Translation Offset	300	0x00000000, // Address Translation Offset
301	0x00028000,,,)	301	0x00028000,,,)
302	QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,	302	QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
303	0x0000000000000000, // Address Space Granularity	303	0x0000000000000000, // Address Space Granularity
304	0x0000000000000000, // Address Range Minimum	304	0x0000000000000000, // Address Range Minimum
305	0x0000000000000CF7, // Address Range Maximum	305	0x0000000000000CF7, // Address Range Maximum
306	0x0000000000000000, // Address Translation Offset	306	0x0000000000000000, // Address Translation Offset
307	0x0000000000000CF8, 0x44, "This is a ResouceSource string",	307	0x0000000000000CF8, 0x44, "This is a ResouceSource string",
308	, TypeStatic)	308	, TypeStatic)
309	QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,	309	QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
310	0x0000000000000000, // Address Space Granularity	310	0x0000000000000000, // Address Space Granularity
311	0x0000000000000000, // Address Range Minimum	311	0x0000000000000000, // Address Range Minimum
312	0x0000000000000CF7, // Address Range Maximum	312	0x0000000000000CF7, // Address Range Maximum
313	0x0000000000000000, // Address Translation Offset	313	0x0000000000000000, // Address Translation Offset
314	0x0000000000000CF8,,,	314	0x0000000000000CF8,,,
315	, TypeStatic)	315	, TypeStatic)
316	QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,	316	QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
317	0x0000000000000000, // Address Space Granularity	317	0x0000000000000000, // Address Space Granularity
318	0x0000000000100000, // Address Range Minimum	318	0x0000000000100000, // Address Range Minimum
319	0x00000000FFDFFFFF, // Address Range Maximum	319	0x00000000FFDFFFFF, // Address Range Maximum
320	0x0000000000000000, // Address Translation Offset	320	0x0000000000000000, // Address Translation Offset
321	0x00000000FFD00000,,,	321	0x00000000FFD00000,,,
322	, AddressRangeMemory, TypeStatic)	322	, AddressRangeMemory, TypeStatic)
323	QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,	323	QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
324	0x0000000000000000, // Address Space Granularity	324	0x0000000000000000, // Address Space Granularity
325	0x0000000000000000, // Address Range Minimum	325	0x0000000000000000, // Address Range Minimum
326	0x0000000000000CF7, // Address Range Maximum	326	0x0000000000000CF7, // Address Range Maximum
327	0x0000000000000000, // Address Translation Offset	327	0x0000000000000000, // Address Translation Offset
328	0x0000000000000CF8,,,)	328	0x0000000000000CF8,,,)
329	ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,	329	ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
330	0x0000000000000000, // Address Space Granularity	330	0x0000000000000000, // Address Space Granularity
331	0x0000000000000000, // Address Range Minimum	331	0x0000000000000000, // Address Range Minimum
332	0x0000000000000CF7, // Address Range Maximum	332	0x0000000000000CF7, // Address Range Maximum
333	0x0000000000000000, // Address Translation Offset	333	0x0000000000000000, // Address Translation Offset
334	0x0000000000000CF8, // Address Length	334	0x0000000000000CF8, // Address Length
335	0x0000000000000000, // Type Specific Attributes	335	0x0000000000000000, // Type Specific Attributes
336	, TypeStatic)	336	, TypeStatic)
337	ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,	337	ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
338	0x0000000000000000, // Address Space Granularity	338	0x0000000000000000, // Address Space Granularity
339	0x0000000000100000, // Address Range Minimum	339	0x0000000000100000, // Address Range Minimum
340	0x00000000FFDFFFFF, // Address Range Maximum	340	0x00000000FFDFFFFF, // Address Range Maximum
341	0x0000000000000000, // Address Translation Offset	341	0x0000000000000000, // Address Translation Offset
342	0x00000000FFD00000, // Address Length	342	0x00000000FFD00000, // Address Length
343	0x0000000000000000, // Type Specific Attributes	343	0x0000000000000000, // Type Specific Attributes
344	, AddressRangeMemory, TypeStatic)	344	, AddressRangeMemory, TypeStatic)
345	ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,	345	ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
346	0x0000000000000000, // Address Space Granularity	346	0x0000000000000000, // Address Space Granularity
347	0x0000000000100000, // Address Range Minimum	347	0x0000000000100000, // Address Range Minimum
348	0x00000000FFDFFFFF, // Address Range Maximum	348	0x00000000FFDFFFFF, // Address Range Maximum
349	0x0000000000000000, // Address Translation Offset	349	0x0000000000000000, // Address Translation Offset
350	0x00000000FFD00000, // Address Length	350	0x00000000FFD00000, // Address Length
351	0x0000000000000000) // Type Specific Attributes	351	0x0000000000000000) // Type Specific Attributes
352	IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)	352	IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)
353	IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)	353	IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)
354	FixedIO (0x0061, 0x01)	354	FixedIO (0x0061, 0x01)
355	IRQNoFlags () {2}	355	IRQNoFlags () {2}
356	DMA (Compatibility, BusMaster, Transfer8_16) {4}	356	DMA (Compatibility, BusMaster, Transfer8_16) {4}
357	DMA (Compatibility, BusMaster, Transfer8) {2,5,7}	357	DMA (Compatibility, BusMaster, Transfer8) {2,5,7}
358	Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)	358	Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
359	Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)	359	Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
360	Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)	360	Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)
361	Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)	361	Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)
362	Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")	362	Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")
363	{	363	{
364	0x00000E01,	364	0x00000E01,
365	}	365	}
366	Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")	366	Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
367	{	367	{
368	0x00000601,	368	0x00000601,
369	0x00000003,	369	0x00000003,
370	0x00000002,	370	0x00000002,
371	0x00000001,	371	0x00000001,
372	}	372	}
373	Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)	373	Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
374	{	374	{
375	0xFFFF0000,	375	0xFFFF0000,
376	0x00000003,	376	0x00000003,
377	0x00000002,	377	0x00000002,
378	0x00000001,	378	0x00000001,
379	0x00000005,	379	0x00000005,
380	0x00000007,	380	0x00000007,
381	0x00000009,	381	0x00000009,
382	}	382	}
383	VendorShort () {0x01, 0x02, 0x03}	383	VendorShort () {0x01, 0x02, 0x03}
384	VendorLong ()	384	VendorLong ()
385	{	385	{
386	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,	386	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
387	0x09	387	0x09
388	}	388	}
389	Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)	389	Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
390	Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)	390	Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
391	StartDependentFnNoPri ()	391	StartDependentFnNoPri ()
392	{	392	{
393	IRQNoFlags () {0,1,2}	393	IRQNoFlags () {0,1,2}
394	IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}	394	IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
395	}	395	}
396	EndDependentFn ()	396	EndDependentFn ()
397	})	397	})
398	CreateWordField (PRT0, 0x08, BMIN)	398	CreateWordField (PRT0, 0x08, BMIN)
399	CreateByteField (PRT0, R000._ASZ, RSIZ)	399	CreateByteField (PRT0, R000._ASZ, RSIZ)
400	Store (0x03, BMIN)	400	Store (0x03, BMIN)
401	Return (PRT0)	401	Return (PRT0)
402	}	402	}
403		403
404	Method (_PRS, 0, NotSerialized)	404	Method (_PRS, 0, NotSerialized)
405	{	405	{
406	Name (BUF0, ResourceTemplate ()	406	Name (BUF0, ResourceTemplate ()
407	{	407	{
408	StartDependentFn (0x01, 0x02)	408	StartDependentFn (0x01, 0x02)
409	{	409	{
410	IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)	410	IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
411	IRQNoFlags () {4}	411	IRQNoFlags () {4}
412	}	412	}
413	StartDependentFn (0x02, 0x01)	413	StartDependentFn (0x02, 0x01)
414	{	414	{
415	IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)	415	IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
416	IRQNoFlags () {4}	416	IRQNoFlags () {4}
417	}	417	}
418	StartDependentFn (0x00, 0x02)	418	StartDependentFn (0x00, 0x02)
419	{	419	{
420	IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)	420	IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
421	IRQNoFlags () {3}	421	IRQNoFlags () {3}
422	}	422	}
423	StartDependentFn (0x00, 0x02)	423	StartDependentFn (0x00, 0x02)
424	{	424	{
425	IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)	425	IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
426	IRQNoFlags () {3}	426	IRQNoFlags () {3}
427	}	427	}
428	StartDependentFn (0x02, 0x00)	428	StartDependentFn (0x02, 0x00)
429	{	429	{
430	IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)	430	IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
431	IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}	431	IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
432	}	432	}
433	EndDependentFn ()	433	EndDependentFn ()
434	})	434	})
435	Return (BUF0)	435	Return (BUF0)
436	}	436	}
437		437
438	Method (_SRS, 1, Serialized)	438	Method (_SRS, 1, Serialized)
439	{	439	{
440	Return (Zero)	440	Return (Zero)
441	}	441	}
442	}	442	}
443		443
444		444
445	Name(\_S0,Package(0x04){	445	Name(\_S0,Package(0x04){
446	0x00,	446	0x00,
447	0x00,	447	0x00,
448	0x00,	448	0x00,
449	0x00	449	0x00
450	})	450	})
451	Name(\_S3,Package(0x04){	451	Name(\_S3,Package(0x04){
452	0x05,	452	0x05,
453	0x05,	453	0x05,
454	0x00,	454	0x00,
455	0x00	455	0x00
456	})	456	})
457	Name(\_S4,Package(0x04){	457	Name(\_S4,Package(0x04){
458	0x06,	458	0x06,
459	0x06,	459	0x06,
460	0x00,	460	0x00,
461	0x00	461	0x00
462	})	462	})
463	Name(\_S5,Package(0x04){	463	Name(\_S5,Package(0x04){
464	0x07,	464	0x07,
465	0x07,	465	0x07,
466	0x00,	466	0x00,
467	0x00	467	0x00
468	})	468	})
469		469
470	/* Examine this table header (DSDT) */	470	/* Examine this table header (DSDT) */
471		471
472	/*	472	/*
473	DataTableRegion (HDR, "DSDT", "", "")	473	DataTableRegion (HDR, "DSDT", "", "")
474	Field (HDR, AnyAcc, NoLock, Preserve)	474	Field (HDR, AnyAcc, NoLock, Preserve)
475	{	475	{
476	SIG, 32,	476	SIG, 32,
477	LENG, 32,	477	LENG, 32,
478	REV, 8,	478	REV, 8,
479	SUM, 8,	479	SUM, 8,
480	OID, 48,	480	OID, 48,
481	OTID, 64,	481	OTID, 64,
482	OREV, 32,	482	OREV, 32,
483	CID, 32,	483	CID, 32,
484	CREV, 32	484	CREV, 32
485	}	485	}
486		486
487	Method (SIZE)	487	Method (SIZE)
488	{	488	{
489	If (LLess (REV, 2))	489	If (LLess (REV, 2))
490	{	490	{
491	Store ("32-bit table", Debug)	491	Store ("32-bit table", Debug)
492	}	492	}
493	else	493	else
494	{	494	{
495	Store ("64-bit table", Debug)	495	Store ("64-bit table", Debug)
496	}	496	}
497	Return (0)	497	Return (0)
498	}	498	}
499		499
500	*/	500	*/
Subversion Repositories Kolibri OS

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