xref: /src/sys/external/bsd/acpica/dist/tests/misc/grammar.asl

/*
 * Some or all of this work - Copyright (c) 2006 - 2014, 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, Serialized)
        {
            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, Serialized)
        {
            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,, Serialized)
    {
        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,, Serialized)
            {
                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,, Serialized) {

                _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,, Serialized)
    {
        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,, Serialized)
    {
        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, Serialized)
    {
        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,, Serialized)
    {
        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, Serialized)
    {
        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,, Serialized)
        {
            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,, Serialized)
        {   //  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,, Serialized)
        {
            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,, Serialized)
        {
            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,, Serialized)
        {
            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,, Serialized)
        {
            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,, Serialized)
        {
            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, Serialized)    //  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, Serialized)    //  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,, Serialized)
            {
                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,, Serialized)
            {
                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,, Serialized)
            {

                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, Serialized)
        {   //  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,, Serialized)
            {   //  LCLB control method: test Index(Local#) where Local# is buffer
                //  Local0 is index counter
                //  Local1 is buffer
                //  Local2 receives BUFR[Local0] via Deref(Index(Local1...))
                //  Local3 is Local1 or Local2 object type
                //  Local4 is return error code

                Name (BUFR, Buffer ()   {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,, Serialized)
            {   //  LCLP control method: test Index(Local#) where Local# is package
                //  Local0 is index counter
                //  Local1 is package
                //  Local2 receives PKG[Local0] via Deref(Index(Local1...))
                //  Local3 is Local1 or Local2 object type
                //  Local4 is return error code

                Name (PKG, Package ()   {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,, Serialized)
        {
            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,, Serialized)
        {
            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,, Serialized)
        {
            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,, Serialized)
        {
            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,, Serialized)
        {

            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,, Serialized)
        {
            // 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,, Serialized)
        {
            // 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,, Serialized)
        {
            // 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,, Serialized)
        {
            // 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,, Serialized)
        {
            // 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,, Serialized)
        {
            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,, Serialized)
            {   //  _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,, Serialized)
            {   //  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,, Serialized)
            {   //  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,, Serialized)
        {   //  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,, Serialized)
        {   //  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,, Serialized)
        {   //  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)

            Notify (\_SB_, 0x29)
            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

        Method (NTFY)
        {
            Notify (\_SB_, 1)
            Notify (\_TZ_.TZ1, 2)
            Notify (\_PR_.CPU0, 3)

            Notify (\_SB_, 0x81)
            Notify (\_TZ_.TZ1, 0x82)
            Notify (\_PR_.CPU0, 0x83)
        }

        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 ()

                NTFY ()
                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