vendor/acpica/20100428

2 files changed, 10561 insertions, 0 deletions

diff --git a/tests/misc/badcode.asl b/tests/misc/badcode.asl
new file mode 100644
index 000000000000..36ca0d582f27
--- /dev/null
+++ b/tests/misc/badcode.asl
@@ -0,0 +1,295 @@
+/*
+ * badcode.asl
+ *
+ * This file contains examples of the extended error checking and
+ * typechecking capabilities of the iASL compiler. Other ASL compilers
+ * may ignore these errors completely. Note - this is not an exhaustive
+ * list of errors detected by iASL, it shows many of the errors that
+ * are not detected by other ASL compilers.
+ *
+ * To compile, use:
+ * iasl badcode.asl
+ */
+DefinitionBlock ("badcode.aml", "DSDT", 1, "Intel", "Example", 0x00000001)
+{
+    Name (INT1, 0)
+    Name (BUF1, Buffer() {0,1,2,3})
+    Event (EVT1)
+
+    // Invalid SyncLevel in Mutex declaration
+
+    Mutex (MTX1, 32)
+
+    // Integer beyond the table integer size (32 bits)
+
+    Name (BIG, 0x1234567887654321)
+
+    // CPackage length does not match initializer list length
+
+    Name (PKG1, Package(5) {0,1})
+
+    // Inadvertent use of single backslash in a string
+
+    Name (PATH, Buffer() {"\_SB_.PCI2._CRS"})
+
+    // Invalid hex escape sequence
+
+    Name (ESC1, "abcdefg\x00hijklmn")
+    
+    // Field access beyond region bounds
+
+    OperationRegion (OPR1, SystemMemory, 0x2000, 6)
+    Field (OPR1, DWordAcc, NoLock, Preserve)
+    {
+        Offset (4),
+        FLD1, 8
+    }
+
+    // Some address spaces support only ByteAcc or BufferAcc
+
+    OperationRegion (OPR2, EmbeddedControl, 0x4000, 8)
+    Field (OPR2, DWordAcc, NoLock, Preserve)
+    {
+        FLD2, 8
+    }
+    OperationRegion (OPR3, SMBus, 0x8000, 16)
+    Field (OPR3, WordAcc, NoLock, Preserve)
+    {
+        FLD3, 8
+    }
+
+    // Invalid SyncLevel in method declaration
+
+    Method (MTH1, 0, NotSerialized, 32)
+    {
+        // Invalid arguments and uninitialized locals
+
+        Store (Arg3, Local0)
+        Store (Local1, Local2)
+
+        // Parameter typechecking (MTX1 is invalid type)
+
+        Subtract (MTX1, 4, Local3)
+
+        // Various invalid parameters
+
+        CreateField (BUF1, 0, Subtract (4, 4), FLD1)
+
+        // Unchecked mutex and event timeouts
+
+        Acquire (MTX1, 100)
+        Wait (EVT1, 1)
+
+        // Result from operation is not used - statement has no effect
+
+        Add (INT1, 8)
+
+        // Unreachable code
+
+        Return (0)
+        Store (5, INT1)
+    }
+
+    Method (MTH2)
+    {
+        // Switch with no Case statements
+
+        Switch (ToInteger (INT1))
+        {
+            Default
+            {
+            }
+        }
+
+        if (LEqual (INT1, 0))
+        {
+            Return (INT1)
+        }
+
+        // Fallthrough exit path does not return a value
+    }
+
+    Method (MTH3)
+    {
+        // Method MTH2 above does not always return a value
+
+        Store (MTH2 (), Local0)
+    }
+
+    // Invalid _HID value
+
+    Name (_HID, "*PNP0C0A")
+
+    // Predefined Name typechecking
+
+    Name (_PRW, 4)
+    Name (_FDI, Buffer () {0})
+
+    // Predefined Name argument count validation
+    // and return value validation
+
+    Method (_OSC, 5)
+    {
+    }
+
+    // Predefined Names that must be implemented as control methods
+
+    Name (_L01, 1)
+    Name (_E02, 2)
+    Name (_Q03, 3)
+    Name (_ON,  0)
+    Name (_INI, 1)
+    Name (_PTP, 2)
+
+    /*
+     * Resource Descriptor error checking
+     */
+    Name (RSC1, ResourceTemplate ()
+    {
+        // Illegal nested StartDependent macros
+
+		StartDependentFn (0, 0)
+		{
+		    StartDependentFn (0, 0)
+		    {
+            }
+        }
+
+        // Missing EndDependentFn macro 
+    })
+
+    Name (RSC2, ResourceTemplate ()
+    {
+        // AddressMin is larger than AddressMax
+        IO (Decode16,
+            0x07D0,             // Range Minimum
+            0x03E8,             // Range Maximum
+            0x01,               // Alignment
+            0x20,               // Length
+            )
+
+        // Length larger than Min/Max window size
+        Memory32 (ReadOnly,
+            0x00001000,         // Range Minimum
+            0x00002000,         // Range Maximum
+            0x00000004,         // Alignment
+            0x00002000,         // Length
+            )
+
+        // Min and Max not multiples of alignment value
+        Memory32 (ReadOnly,
+            0x00001001,         // Range Minimum
+            0x00002002,         // Range Maximum
+            0x00000004,         // Alignment
+            0x00000200,         // Length
+            )
+
+        // 10-bit ISA I/O address has a max of 0x3FF
+        FixedIO (
+            0xFFFF,             // Address
+            0x20,               // Length
+            )
+
+        // Invalid AccessSize parameter
+        Register (SystemIO, 
+            0x08,               // Bit Width
+            0x00,               // Bit Offset
+            0x0000000000000100, // Address
+            0x05                // Access Size
+            )
+
+        // Invalid ResourceType (0xB0)
+        QWordSpace (0xB0, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+            0x0000,             // Granularity
+            0xA000,             // Range Minimum
+            0xBFFF,             // Range Maximum
+            0x0000,             // Translation Offset
+            0x2000,             // Length
+            ,, )
+
+        // AddressMin is larger than AddressMax
+        WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+            0x0000,             // Granularity
+            0x0200,             // Range Minimum
+            0x0100,             // Range Maximum
+            0x0000,             // Translation Offset
+            0x0100,             // Length
+            ,, , TypeStatic)
+
+        // Length larger than Min/Max window size
+        DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+            0x00000000,         // Granularity
+            0x000C8000,         // Range Minimum
+            0x000C9000,         // Range Maximum
+            0x00000000,         // Translation Offset
+            0x00001002,         // Length
+            ,, )
+
+        // Granularity must be (power-of-two -1)
+        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxNotFixed, NonCacheable, ReadWrite,
+            0x00000010,
+            0x40000000,
+            0xFED9FFFF,
+            0x00000000,
+            0xBECA0000)
+
+        // Address Min (with zero length) not on granularity boundary
+        QWordIO (ResourceProducer, MinFixed, MaxNotFixed, PosDecode, EntireRange,
+            0x0000000000000003, // Granularity
+            0x0000000000000B02, // Range Minimum
+            0x0000000000000C00, // Range Maximum
+            0x0000000000000000, // Translation Offset
+            0x0000000000000000, // Length
+            ,, , TypeStatic)
+
+        // Address Max (with zero length) not on (granularity boundary -1)
+        QWordMemory (ResourceProducer, PosDecode, MinNotFixed, MaxFixed, Cacheable, ReadWrite,
+            0x0000000000000001, // Granularity
+            0x0000000000100000, // Range Minimum
+            0x00000000002FFFFE, // Range Maximum
+            0x0000000000000000, // Translation Offset
+            0x0000000000000000, // Length
+            ,, , AddressRangeMemory, TypeStatic)
+
+        // Invalid combination: zero length, both Min and Max are fixed
+        DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+            0x00000000,         // Granularity
+            0x000C8000,         // Range Minimum
+            0x000C8FFF,         // Range Maximum
+            0x00000000,         // Translation Offset
+            0x00000000,         // Length
+            ,, )
+
+        // Invalid combination: non-zero length, Min Fixed, Max not fixed
+        DWordIO (ResourceProducer, MinFixed, MaxNotFixed, PosDecode, EntireRange,
+            0x00000001,         // Granularity
+            0x000C8000,         // Range Minimum
+            0x000C8FFF,         // Range Maximum
+            0x00000000,         // Translation Offset
+            0x00000100,         // Length
+            ,, )
+
+        // Invalid combination: non-zero length, Min not Fixed, Max fixed
+        DWordIO (ResourceProducer, MinNotFixed, MaxFixed, PosDecode, EntireRange,
+            0x00000001,         // Granularity
+            0x000C8000,         // Range Minimum
+            0x000C8FFF,         // Range Maximum
+            0x00000000,         // Translation Offset
+            0x00000200,         // Length
+            ,, )
+
+        // Granularity must be zero if non-zero length, min/max fixed
+        DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+            0x0000000F,         // Granularity
+            0x000C8000,         // Range Minimum
+            0x000C8FFF,         // Range Maximum
+            0x00000000,         // Translation Offset
+            0x00001000,         // Length
+            ,, )
+
+        // Missing StartDependentFn macro
+
+        EndDependentFn ()
+    })
+}
+
diff --git a/tests/misc/grammar.asl b/tests/misc/grammar.asl
new file mode 100644
index 000000000000..8a13fd1a20cf
--- /dev/null
+++ b/tests/misc/grammar.asl
@@ -0,0 +1,10266 @@
+/*
+ * Some or all of this work - Copyright (c) 2006 - 2010, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//
+//
+// Grammar.asl - Minimally excercises most ASL constructs
+//
+// NOTE -- use: iasl -f -of grammar.asl to compile
+//
+//         This 1) Ignores errors (checks compiler error handling)
+//              2) Disables constant folding
+//
+//
+
+/*******************************************************************************
+Compilation should look like this:
+
+C:\acpica\tests\misc>iasl -f -of grammar.asl
+
+Intel ACPI Component Architecture
+ASL Optimizing Compiler version 20090422 [Apr 22 2009]
+Copyright (C) 2000 - 2009 Intel Corporation
+Supports ACPI Specification Revision 3.0a
+
+grammar.asl   187:     Name (_NPK, Package (8)
+Warning  1098 -                 ^ Unknown reserved name (_NPK)
+
+grammar.asl   510:     NAME (ESC1, "abcdefg\x00hijklmn")
+Warning  1042 -                                ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
+
+grammar.asl   511:     NAME (ESC2, "abcdefg\000hijklmn")
+Warning  1042 -                                ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
+
+grammar.asl   601:     Method (RCIV, 1)
+Warning  1087 -                   ^ Not all control paths return a value (RCIV)
+
+grammar.asl   608:         RCIV (Subtract (Arg0, 1))
+Remark   5073 -               ^ Recursive method call (RCIV)
+
+grammar.asl   937:     Method (_ERR, 2)
+Warning  1077 -                   ^ Reserved method has too few arguments (_ERR requires 3)
+
+grammar.asl  1377:         Store (0x1234567887654321, QWD2)
+Warning  1032 -                                    ^ 64-bit integer in 32-bit table, truncating
+
+grammar.asl  1379:         if (LNotEqual (Local0, 0x1234567887654321))
+Warning  1032 -         64-bit integer in 32-bit table, truncating ^
+
+grammar.asl  1459:         SizeOf (BUFO)
+Warning  1105 -                       ^ Result is not used, operator has no effect
+
+grammar.asl  1485:         Acquire (MTX2, 1)
+Warning  1104 -                           ^ Possible operator timeout is ignored
+
+grammar.asl  1633:         Add (Local0, Local1)
+Warning  1105 -                      ^ Result is not used, operator has no effect
+
+grammar.asl  1804:     Method (COND)
+Warning  1087 -                   ^ Not all control paths return a value (COND)
+
+grammar.asl  6010:             Name (_HID, "*PNP0A06")
+Error    4001 -                                     ^ String must be entirely alphanumeric (*PNP0A06)
+
+grammar.asl  6461:             Name (_CRS, Buffer(26)  {"\_SB_.PCI2._CRS..........."})
+Warning  1038 -        Invalid or unknown escape sequence ^
+
+grammar.asl  6800:                 And (Local0, 1, Local0) //  Local0 &= 1
+Error    4050 -                              ^ Method local variable is not initialized (Local0)
+
+grammar.asl  6886:             Name (_HID, "*PNP0C0A")     //  Control Method Battey ID
+Error    4001 -                                     ^ String must be entirely alphanumeric (*PNP0C0A)
+
+ASL Input:  grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
+AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
+
+Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
+
+***************************************************************************************************/
+
+DefinitionBlock (
+    "grammar.aml",      //Output filename
+    "DSDT",             //Signature
+    0x01,               //DSDT Revision ---> 32-bit table
+    "Intel",            //OEMID
+    "GRMTEST",          //TABLE ID
+    0x20090511          //OEM Revision
+    )
+{
+
+    External (\ABCD, UnknownObj)
+
+
+    /* Device with _STA and _INI */
+
+    Device (A1)
+    {
+        Method (_STA)
+        {
+            Return (0x0F)
+        }
+
+        Method (_INI)
+        {
+            Return
+        }
+    }
+
+    /* Device with no _STA, has _INI */
+
+    Device (A2)
+    {
+        Method (_INI)
+        {
+            Return
+        }
+    }
+
+    /* Device with _STA, no _INI */
+
+    Device (A3)
+    {
+        Method (_STA)
+        {
+            Return (0x0F)
+        }
+    }
+
+    /* Device with _STA and _INI, but not present */
+
+    Device (A4)
+    {
+        Method (_STA)
+        {
+            Return (Zero)
+        }
+
+        Method (_INI)
+        {
+            Return
+        }
+    }
+
+
+    /* Resource descriptors */
+
+    Device (IRES)
+    {
+        Name (PRT0, ResourceTemplate ()
+        {
+            IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
+
+            StartDependentFn (1,1)
+            {
+                IRQNoFlags () {0,1,2}
+            }
+            EndDependentFn ()
+        })
+
+        Method (_CRS, 0, NotSerialized)
+        {
+            Store ("_CRS:", Debug)
+            Store (PRT0, Debug)
+            Return (PRT0)
+        }
+
+        Method (_SRS, 1, Serialized)
+        {
+            Store ("_SRS:", Debug)
+            Store (Arg0, Debug)
+            Return (Zero)
+        }
+    }
+
+    Name (_NPK, Package ()
+    {
+        0x1111,
+        0x2222,
+        0x3333,
+        0x4444
+    })
+
+
+    Device (RES)
+    {
+        Name (_PRT, Package (0x04)
+        {
+            Package (0x04)
+            {
+                0x0002FFFF,
+                Zero,
+                Zero,
+                Zero
+            },
+
+            Package (0x04)
+            {
+                0x0002FFFF,
+                One,
+                Zero,
+                Zero
+            },
+
+            Package (0x04)
+            {
+                0x000AFFFF,
+                Zero,
+                Zero,
+                Zero
+            },
+
+            Package (0x04)
+            {
+                0x000BFFFF,
+                Zero,
+                Zero,
+                Zero
+            }
+        })
+
+        Method (_CRS, 0, NotSerialized)
+        {
+            Name (PRT0, ResourceTemplate ()
+            {
+                WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
+                    0x0000, // Address Space Granularity
+                    0xFFF2, // Address Range Minimum
+                    0xFFF3, // Address Range Maximum
+                    0x0032, // Address Translation Offset
+                    0x0002,,,)
+                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
+                    0x0000, // Address Space Granularity
+                    0x0000, // Address Range Minimum
+                    0x00FF, // Address Range Maximum
+                    0x0000, // Address Translation Offset
+                    0x0100,,,)
+                WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+                    0x0000, // Address Space Granularity
+                    0xA000, // Address Range Minimum
+                    0xBFFF, // Address Range Maximum
+                    0x0000, // Address Translation Offset
+                    0x2000,,,)
+                IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)
+                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                    0x0000, // Address Space Granularity
+                    0x0000, // Address Range Minimum
+                    0x0CF7, // Address Range Maximum
+                    0x0000, // Address Translation Offset
+                    0x0CF8,,,
+                    , TypeStatic)
+                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                    0x0000, // Address Space Granularity
+                    0x0D00, // Address Range Minimum
+                    0xFFFF, // Address Range Maximum
+                    0x0000, // Address Translation Offset
+                    0xF300,,,
+                    , TypeStatic)
+                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                    0x00000000, // Address Space Granularity
+                    0x00000000, // Address Range Minimum
+                    0x00000CF7, // Address Range Maximum
+                    0x00000000, // Address Translation Offset
+                    0x00000CF8,,,
+                    , TypeStatic)
+                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                    0x00000000, // Address Space Granularity
+                    0x000C8000, // Address Range Minimum
+                    0x000EFFFF, // Address Range Maximum
+                    0x00000000, // Address Translation Offset
+                    0x00028000,,,
+                    , AddressRangeMemory, TypeStatic)
+                DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+                    0x00000000, // Address Space Granularity
+                    0x000C8000, // Address Range Minimum
+                    0x000EFFFF, // Address Range Maximum
+                    0x00000000, // Address Translation Offset
+                    0x00028000,,,)
+                QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                    0x0000000000000000, // Address Space Granularity
+                    0x0000000000000000, // Address Range Minimum
+                    0x0000000000000CF7, // Address Range Maximum
+                    0x0000000000000000, // Address Translation Offset
+                    0x0000000000000CF8, 0x44, "This is a ResouceSource string",
+                    , TypeStatic)
+                QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                    0x0000000000000000, // Address Space Granularity
+                    0x0000000000000000, // Address Range Minimum
+                    0x0000000000000CF7, // Address Range Maximum
+                    0x0000000000000000, // Address Translation Offset
+                    0x0000000000000CF8,,,
+                    , TypeStatic)
+                QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                    0x0000000000000000, // Address Space Granularity
+                    0x0000000000100000, // Address Range Minimum
+                    0x00000000FFDFFFFF, // Address Range Maximum
+                    0x0000000000000000, // Address Translation Offset
+                    0x00000000FFD00000,,,
+                    , AddressRangeMemory, TypeStatic)
+                QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+                    0x0000000000000000, // Address Space Granularity
+                    0x0000000000000000, // Address Range Minimum
+                    0x0000000000000CF7, // Address Range Maximum
+                    0x0000000000000000, // Address Translation Offset
+                    0x0000000000000CF8,,,)
+                ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                    0x0000000000000000, // Address Space Granularity
+                    0x0000000000000000, // Address Range Minimum
+                    0x0000000000000CF7, // Address Range Maximum
+                    0x0000000000000000, // Address Translation Offset
+                    0x0000000000000CF8, // Address Length
+                    0x0000000000000000, // Type Specific Attributes
+                    , TypeStatic)
+                ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                    0x0000000000000000, // Address Space Granularity
+                    0x0000000000100000, // Address Range Minimum
+                    0x00000000FFDFFFFF, // Address Range Maximum
+                    0x0000000000000000, // Address Translation Offset
+                    0x00000000FFD00000, // Address Length
+                    0x0000000000000000, // Type Specific Attributes
+                    , AddressRangeMemory, TypeStatic)
+                ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
+                    0x0000000000000000, // Address Space Granularity
+                    0x0000000000100000, // Address Range Minimum
+                    0x00000000FFDFFFFF, // Address Range Maximum
+                    0x0000000000000000, // Address Translation Offset
+                    0x00000000FFD00000, // Address Length
+                    0x0000000000000000) // Type Specific Attributes
+                IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)
+                IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)
+                FixedIO (0x0061, 0x01)
+                IRQNoFlags () {2}
+                DMA (Compatibility, BusMaster, Transfer8_16) {4}
+                DMA (Compatibility, BusMaster, Transfer8) {2,5,7}
+                Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
+                Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
+                Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)
+                Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)
+                Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")
+                {
+                    0x00000E01,
+                }
+                Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
+                {
+                    0x00000601,
+                    0x00000003,
+                    0x00000002,
+                    0x00000001,
+                }
+                Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
+                {
+                    0xFFFF0000,
+                    0x00000003,
+                    0x00000002,
+                    0x00000001,
+                    0x00000005,
+                    0x00000007,
+                    0x00000009,
+                }
+                VendorShort () {0x01, 0x02, 0x03}
+                VendorLong ()
+                {
+                    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                    0x09
+                }
+                Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
+                Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
+                StartDependentFnNoPri ()
+                {
+                    IRQNoFlags () {0,1,2}
+                    IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
+                }
+                EndDependentFn ()
+            })
+            CreateWordField (PRT0, 0x08, BMIN)
+            CreateByteField (PRT0, R000._ASZ, RSIZ)
+            Store (0x03, BMIN)
+            Return (PRT0)
+        }
+
+        Method (_PRS, 0, NotSerialized)
+        {
+            Name (BUF0, ResourceTemplate ()
+            {
+                StartDependentFn (0x01, 0x02)
+                {
+                    IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
+                    IRQNoFlags () {4}
+                }
+                StartDependentFn (0x02, 0x01)
+                {
+                    IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
+                    IRQNoFlags () {4}
+                }
+                StartDependentFn (0x00, 0x02)
+                {
+                    IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
+                    IRQNoFlags () {3}
+                }
+                StartDependentFn (0x00, 0x02)
+                {
+                    IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
+                    IRQNoFlags () {3}
+                }
+                StartDependentFn (0x02, 0x00)
+                {
+                    IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
+                    IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
+                }
+                EndDependentFn ()
+            })
+            Return (BUF0)
+        }
+
+        Method (_SRS, 1, Serialized)
+        {
+            Return (Zero)
+        }
+    }
+
+
+    Name(\_S0,Package(0x04){
+        0x00,
+        0x00,
+        0x00,
+        0x00
+    })
+    Name(\_S3,Package(0x04){
+        0x05,
+        0x05,
+        0x00,
+        0x00
+    })
+    Name(\_S4,Package(0x04){
+        0x06,
+        0x06,
+        0x00,
+        0x00
+    })
+    Name(\_S5,Package(0x04){
+        0x07,
+        0x07,
+        0x00,
+        0x00
+    })
+
+/* Examine this table header (DSDT) */
+
+/*
+    DataTableRegion (HDR, "DSDT", "", "")
+    Field (HDR, AnyAcc, NoLock, Preserve)
+    {
+        SIG,  32,
+        LENG, 32,
+        REV,  8,
+        SUM,  8,
+        OID,  48,
+        OTID, 64,
+        OREV, 32,
+        CID,  32,
+        CREV, 32
+    }
+
+    Method (SIZE)
+    {
+        If (LLess (REV, 2))
+        {
+            Store ("32-bit table", Debug)
+        }
+        else
+        {
+            Store ("64-bit table", Debug)
+        }
+        Return (0)
+    }
+
+*/
+    Name (SIZE, 0)
+
+    /* Custom operation region */
+
+    OperationRegion(MYOP,0x80,0xFD60,0x6)
+    Field(MYOP,ByteAcc,NoLock,Preserve)
+    {
+        MFLD,8
+    }
+
+    Method (TCOP)
+    {
+        Name (_STR, Unicode ("test"))
+        Store (4, MFLD)
+        Store (MFLD, Local0)
+    }
+
+    Name (ERRS, 0x0)
+
+    /* Warning should be issued for premature string termination */
+
+    NAME (ESC1, "abcdefg\x00hijklmn")
+    NAME (ESC2, "abcdefg\000hijklmn")
+    Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432")
+
+
+    Name(CRSA,ResourceTemplate()
+    {
+        WORDBusNumber(ResourceProducer,MinFixed,MaxFixed,PosDecode,0x0000,0x0019,0x001D,0x0000,0x0005)
+        WORDIO(ResourceProducer,MinFixed,MaxFixed,PosDecode,NonISAOnlyRanges,0x0000,0xC000,0xCFFF,0x0000,0x1000)
+        DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
+
+    })
+    Name(CRSB,ResourceTemplate()
+    {
+        DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
+
+    })
+
+    Name(CRSC,ResourceTemplate()
+    {
+        VendorShort () {0x1, 0x2, 0x3}
+    })
+    Name(CRSD,ResourceTemplate()
+    {
+        VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
+    })
+
+    Name(CRSE,ResourceTemplate()
+    {
+        IRQNoFlags(){3,4,10,11}
+        IRQNoFlags(xxxt){3,4,10,11}
+    })
+    Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){})
+    Method(_CRS,0,NotSerialized)
+    {
+        Return(CRSR)
+    }
+
+
+    //
+    // Unnamed scope
+    //
+    Scope (\)
+    {
+        Name(Bxxx,0xFFFFFFFF)
+    }
+
+    Name (LANS, 0x0)
+
+    PowerResource(LANP,1,0)
+    {
+        Method(_STA){
+            If(LEqual(And(LANS,0x30),0x30)){
+                Return(One)
+            } Else {
+                Return(Zero)
+            }
+        }
+        Method(_ON){
+            If(LNot(_STA())){
+                Store (0x30, LANS)
+            }
+        }
+        Method(_OFF){
+            If(_STA()){
+                Store (0, LANS)
+            }
+        }
+    }
+
+
+    /* Can a method define another method? */
+
+    /**********************************
+    Method (TASK, 2, SERIALIZED)
+    {
+        Sleep (100)
+
+        Method (TAS2)
+        {
+            Sleep (100)
+        }
+
+        TAS2()
+        Return
+
+    }
+    ************************************/
+
+    /* A recursive method */
+
+    Method (RCIV, 1)
+    {
+        Store (Arg0, Debug)
+        If (Lequal (Arg0, 0))
+        {
+            Return ()
+        }
+        RCIV (Subtract (Arg0, 1))
+    }
+
+    Method (RTOP)
+    {
+        RCIV (100)
+    }
+
+
+    Scope(\_PR)
+    {
+        Processor(CPU0,0x0,0xFFFFFFFF,0x0) {}
+    }
+
+    Name(B1TP,0xFFFFFFFF)
+
+    Name(B2TP,0xFFFFFFFF)
+    Name(ADPS,0xFFFFFFFF)
+    Name(B1PS,0xFFFFFFFF)
+    Name(B1RS,0xFFFFFFFF)
+    Name(B1CS,0xFFFFFFFF)
+    Name(B2PS,0xFFFFFFFF)
+    Name(B2RS,0xFFFFFFFF)
+    Name(B2CS,0xFFFFFFFF)
+    Name(B1DC,3000)
+    Name(B2DC,2600)
+    Name(B1LF,3000)
+    Name(B2LF,2600)
+    Name(BPIF,0)
+    Name(PBLL,0)
+
+    Name(RBIF,Package()
+    {
+        0x1,
+        2200,
+        2200,
+        0x1,
+        10800,
+        0,
+        0,
+        1,
+        1,
+        "CA54200-5003/5",
+        "1",
+        "LION",
+        "Fujitsu"
+    })
+
+    Method(SMWE, 4)
+    {
+       return(ONES)
+    }
+
+    Method(SMRE, 4)
+    {
+       return(ONES)
+    }
+
+/*
+    Method(RDBT,0,Serialized){
+        If(LNot(SMWE(0x09,0x15,1,1))){
+                    Store(0x18,Local2)
+            }
+    }
+*/
+    Scope(_SB)
+    {
+
+        Name (SBUF, Buffer (128) {})
+
+        CreateBitField (SBUF, 3, BITY)
+        CreateByteField (SBUF, 1, BYTY)
+        CreateWordField (SBUF, 2, WRDZ)
+        CreateDwordField (SBUF, 4, DWDZ)
+        CreateQwordField (SBUF, 8, QWDZ)
+        CreateField (SBUF, 128, 12, FLDZ)
+        CreateField (SBUF, 148, 96, FLDY)
+        CreateField (SBUF, 148, 96, \_SB_.FLDW)
+
+        Method (_INI)
+        {
+            CreateField (\_SB_.SBUF, 148, 96, FLDV)
+        }
+
+
+        Device(PCI0)
+        {
+            Name(_HID,EISAID("PNP0A03"))
+            Name(_ADR,0x0)
+
+            Method(_CRS)
+            {
+                Name(PRT0, ResourceTemplate() {
+                    WORDBusNumber(                          // Bus number resource(0)
+                            ResourceConsumer,               // bit 0 of general flags is 1
+                            MinFixed,                       // Range is notfixed
+                            MaxFixed,                       // Range is not fixed
+                            SubDecode,                      // SubDecode
+                            0x0000,                           // Granularity
+                            0xfff1,                           // Min
+                            0xfff2,                           // Max
+                            0x0032,                           // Translation
+                            0x0002,,,                         // Range Length
+                            BUS0
+                    ) } )// PRT0
+
+                CreateWordField(PRT0, BUS0._MIN, BMIN)          //Minimum bus number suported under this bridge.
+
+                Store(3, BMIN)
+                Return(PRT0)
+
+            } // _CRS
+
+            Method(_SRS)
+            {
+                Return ()
+            }
+
+            Device(EIO)
+            {
+                OperationRegion(FJIO,SystemIO,0xFD60,0x6)
+                    Field(FJIO,ByteAcc,NoLock,Preserve)
+                    {
+                        GIDX,8,
+
+                        GDTA,8,
+
+                        PIDX,8,
+
+                        PDTA,8,
+
+                        SIDX,8,
+
+                        SDTA,8
+                    }
+                    IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve)
+                    {
+                        Offset(0x2),
+                         ,5,
+                        VGAS,2,
+                        Offset(0x4),
+                         ,4,
+                        DCKE,1,
+                        Offset(0x5),
+                         ,6,
+                        ACPW,1,
+
+                        Offset(0xA),
+                        B1P,1,
+
+                        B2P,1,
+
+                        B1C,1,
+
+                        B2C,1,
+
+                        B1ER,1,
+
+                        B2ER,1,
+
+                        Offset(0xB),
+                        B1CP,8,
+
+                        B2CP,8,
+
+                        BCP,8,
+
+                        B1VH,8,
+
+                        B1VL,8,
+
+                        B2VH,8,
+
+                        B2VL,8,
+
+                        B1TM,8,
+
+                        B2TM,8,
+
+                        B1CH,8,
+
+                        B1CL,8,
+
+                        B2CH,8,
+
+                        B2CL,8
+                    }
+                }
+            }
+        }
+
+        Method(RDBT,3,Serialized){
+            Store(0x1FFF,Local1)
+            If( Arg0 ){
+                Store(0x2FFF,Local1)
+            }
+            Store(0x18,Local2)
+            If( Arg1 ){
+                Store(0x10,Local2)
+            }
+            If(LNot(SMRE(0x09,0x15,1,RefOf(Local0)))){
+                If(LNot(SMWE(0x08,0x14,1,Local1))){
+                    If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){
+                        Store(Local1,Arg2)
+                    }
+                }
+                Or(Local0,0xFFF,Local0)
+                SMWE(0x08,0x14,1,Local0)
+            }
+        }
+        Method(MKWD,2)
+        {
+            If(And(Arg1,0x80)) {
+                Or(0xFFFF0000,Arg0,Local0)
+                Or(Local0,ShiftLeft(Arg1,8),Local0)
+                Subtract(Zero,Local0,Local0)
+            } else {
+                Store(Arg0,Local0)
+                Or(Local0,ShiftLeft(Arg1,8),Local0)
+            }
+            Return(Local0)
+        }
+
+        Device(CMB1)
+        {
+            Name(_HID,EISAID("PNP0C0A"))
+            Name(_UID,0x1)
+            Alias(\_SB.PCI0.EIO.B1P,\_SB_.PCI0.XXXX)
+            Alias(\_SB.PCI0.EIO.B1P,B1P)
+            Alias(\_SB.PCI0.EIO.B1C,B1C)
+            Alias(\_SB.PCI0.EIO.B1CH,B1CH)
+            Alias(\_SB.PCI0.EIO.B1CL,B1CL)
+            Alias(\_SB.PCI0.EIO.B1VH,B1VH)
+            Alias(\_SB.PCI0.EIO.B1VL,B1VL)
+            Alias(\_SB.PCI0.EIO.B1CP,B1CP)
+
+            Method(_INI)
+                        {
+                Store(B1P, B1PS)
+                Store(B1CP,B1RS)
+                Store(B1C, B1CS)
+            }
+
+            Method(_BIF){
+                RDBT(Zero,Zero,RefOf(B1DC))
+                RDBT(Zero,One,RefOf(B1LF))
+                Store(B1DC,Index(RBIF,1))
+                Store(B1LF,Index(RBIF,2))
+                Store("CA54200-5003/5",Index(RBIF,9))
+                Store("1",Index(RBIF,10))
+                Return(RBIF)
+            }
+
+            Method(_BST) {
+
+                _INI()
+
+                Store(Zero,Local0)
+
+                if (LAnd(B1P,LNot(B1C))){
+                    Or(Local0,1,Local0)
+                }
+
+                if (LAnd(B1P,B1C)) {
+                    Or(Local0,2,Local0)
+                }
+
+                if (LLessEqual(B1CP,1)) {
+                    Or(Local0,4,Local0)
+                }
+
+                Store(MKWD(B1CL,B1CH),Local1)
+
+                Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2)
+
+                Store(MKWD(B1VL,B1VH),Local3)
+
+                Name(STAT,Package(4){})
+                Store(Local0,Index(STAT,0))
+                Store(Local1,Index(STAT,1))
+                Store(Local2,Index(STAT,2))
+                Store(Local3,Index(STAT,3))
+
+                If(LNot(BPIF)){
+//                    \_SB.PCI0.EIO.EC0.IECT()
+//                    \_SB.PCI0.EIO.EC0.SECT()
+                    Store(One,BPIF)
+                }
+                return(STAT)
+            }
+
+        }
+
+    Device (DEV1)
+    {
+    }
+
+    Scope(\_TZ)
+    {
+        ThermalZone(TZ1)
+        {
+            Name(_PSL,Package()
+            {
+                \_PR.CPU0
+            })
+        }
+    }
+
+    Method (TZ2, 0, SERIALIZED)
+    {
+        Name(_PSL,Package()
+        {
+            \_PR.CPU0
+        })
+
+        Return (_PSL)
+    }
+
+    ThermalZone (THM1)
+    {
+    }
+
+    Method (NOTI)
+    {
+        Notify (\DEV1, 0)
+        Notify (\THM1, 0)
+        Notify (\_PR.CPU0, 0)
+    }
+
+    Method (_ERR, 2)
+    {
+        Increment (ERRS)
+        Store ("Run-time exception:", Debug)
+        Store (Arg0, Debug)
+        Store (Arg1, Debug)
+
+        Return (0)          // Map error to AE_OK
+    }
+
+    Method (DIV0)
+    {
+        Store (1, Local0)
+        Store (0, Local1)
+        Divide (Local0, Local1, Local3)
+
+        Store ("DIV0 - noabort", Debug)
+    }
+
+    Method (ERR_, 1)
+    {
+        if (LEqual (Arg0, 0))
+        {
+            Store ("+*+*+*+* MTHD_ERROR: Results not equal!", Debug)
+        }
+        if (LEqual (Arg0, 1))
+        {
+            Store ("+*+*+*+* MTHD_ERROR: Numeric result is incorrect!", Debug)
+        }
+        if (LEqual (Arg0, 2))
+        {
+            Store ("+*+*+*+* MTHD_ERROR: Operand was clobbered!", Debug)
+        }
+
+        Notify (DEV1, Arg0)
+        Increment (ERRS)
+    }
+
+    Method (R226, 2)
+    {
+    }
+    Method (R225, 2)
+    {
+        R226 (Arg0, Arg1)
+    }
+    Method (R224, 2)
+    {
+        R225 (Arg1, Arg0)
+    }
+    Method (R223, 2)
+    {
+        R224 (Arg0, Arg1)
+    }
+    Method (R222, 2)
+    {
+        R223 (Arg1, Arg0)
+    }
+    Method (R111)
+    {
+        Store (0x01010101, Local0)
+        R222 (0xABAB, Local0)
+        Store (Local0, Local1)
+    }
+
+    Method (MAIN)
+    {
+
+//      SIZE()
+        Store (NUM1(), Local0)
+        \CMB1._BST()
+        RDBT(1,2,3)
+        OBJ1(1)
+        OBJ2(2)
+        CHEK()
+        RETZ()
+        BITZ()
+        LOGS()
+        REFS()
+        COND()
+        TZ2()
+
+        //
+        // iPCO tests added
+        //
+        Store (\IFEL.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\NOSV.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\IDXF.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.NSTL.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\RTBF.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.RTLV.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.RETP.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\WHLR.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\ANDO.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\BRKP.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\ADSU.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\INDC.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\LOPS.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\FDSO.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\MLDV.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\NBIT.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\SHFT.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\XORD.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\CRBF.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\IDX4.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\EVNT.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\SZLV.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.BYTF.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\DWDF.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\DVAX.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\IDX6.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\IDX5.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.IDX0.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.IDX3.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\IDX7.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\MTCH.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\WHLB.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.IDX2.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\SIZO.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        Store (\_SB_.SMIS.TEST(), Local0)
+        if (LGreater (Local0, 0))
+        {
+            ERR_ (1)
+            Return(Local0)
+        }
+
+        if (LGreater (ERRS, 0))
+        {
+            Store ("****** There were errors during the execution of the test ******", Debug)
+        }
+
+        //
+        // Last Test
+        //
+
+        Return(0) // Success
+    }
+
+
+    Method (OBJ1, 1, SERIALIZED)
+    {
+
+        Store (3, Local0)
+        Name(BUFR, Buffer (Local0) {})
+        Name(BUF1, Buffer (4) {1,2,3,4})
+        Name(BUF2, Buffer (4) {})
+
+        Store (BUF1, BUF2)
+        Mutex (MTX1, 4)
+
+        Alias (MTX1, MTX2)
+    }
+
+
+    Mutex (MTXT, 0)
+    Mutex (MTXX, 0)
+
+    /*
+     * Field Creation
+     */
+
+    Method (FLDS)
+    {
+        Store ("++++++++ Creating BufferFields", Debug)
+        Name (BUF2, Buffer (128) {})
+
+        CreateBitField (BUF2, 3, BIT2)
+        CreateByteField (BUF2, 1, BYT2)
+        CreateWordField (BUF2, 2, WRD2)
+        CreateDwordField (BUF2, 4, DWD2)
+        CreateQwordField (BUF2, 8, QWD2)
+        CreateField (BUF2, 128, 12, FLD2)
+        CreateField (BUF2, 148, 96, FLD3)
+
+        Store (0x1, BIT2)
+        Store (BIT2, Local0)
+        if (LNotEqual (Local0, 0x1))
+        {
+            ERR_ (1)
+        }
+        else
+        {
+            Store (DerefOf (Index (BUF2, 0)), Local0)
+            if (LNotEqual (Local0, 0x08))
+            {
+                ERR_ (1)
+            }
+            else
+            {
+                Store ("++++++++ Bit BufferField I/O PASS", Debug)
+            }
+        }
+
+        Store (0x1A, BYT2)
+        Store (BYT2, Local0)
+        if (LNotEqual (Local0, 0x1A))
+        {
+            ERR_ (1)
+        }
+        else
+        {
+            Store ("++++++++ Byte BufferField I/O PASS", Debug)
+        }
+
+        Store (0x1234, WRD2)
+        Store (WRD2, Local0)
+        if (LNotEqual (Local0, 0x1234))
+        {
+            ERR_ (1)
+        }
+        else
+        {
+            Store ("++++++++ Word BufferField I/O PASS", Debug)
+        }
+
+        Store (0x123, FLD2)
+        Store (FLD2, Local0)
+        if (LNotEqual (Local0, 0x123))
+        {
+            ERR_ (1)
+        }
+        else
+        {
+            Store ("++++++++ 12-bit BufferField I/O PASS", Debug)
+        }
+
+        Store (0x12345678, DWD2)
+        Store (DWD2, Local0)
+        if (LNotEqual (Local0, 0x12345678))
+        {
+            ERR_ (1)
+        }
+        else
+        {
+            Store ("++++++++ Dword BufferField I/O PASS", Debug)
+        }
+
+        Store (0x1234567887654321, QWD2)
+        Store (QWD2, Local0)
+        if (LNotEqual (Local0, 0x1234567887654321))
+        {
+            ERR_ (1)
+        }
+        else
+        {
+            Store ("++++++++ Qword BufferField I/O PASS", Debug)
+        }
+    }
+
+
+    /* Field execution */
+
+    Method (FLDX)
+    {
+        Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
+        {   //  Field:  SMEM overlay using 32-bit field elements
+            SMD0,   32, //  32-bits
+            SMD1,   32,     //  32-bits
+            SMD2,   32,     //  32-bits
+            SMD3,   32  //  32-bits
+        }   //  Field:  SMEM overlay using 32-bit field elements
+        Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
+        {   //  Field:  SMEM overlay using greater than 32-bit field elements
+            SME0,   69, //  larger than an integer (32 or 64)
+            SME1,   97  //  larger than an integer
+        }   //  Field:  SMEM overlay using greater than 32-bit field elements
+    }
+
+
+    Method (MTX_, )
+    {
+        /* Test "Force release" of mutex on method exit */
+
+        Acquire (MTXT, 0xFFFF)
+        Acquire (MTXX, 0xFFFF)
+
+        Store ("++++++++ Acquiring Mutex MTX2", Debug)
+        Acquire (_GL_, 0xFFFF)
+
+
+        Store ("++++++++ Releasing Mutex MTX2", Debug)
+        Release (_GL_)
+    }
+
+
+    Method (OBJ2, 1)
+    {
+        Store ("++++++++ Creating Buffer BUFO", Debug)
+        Name (BUFO, Buffer (32) {})
+
+        Store ("++++++++ Creating OpRegion OPR2", Debug)
+        OperationRegion (OPR2, SystemMemory, Arg0, 256)
+
+        Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug)
+        Field (OPR2, ByteAcc, NoLock, Preserve)
+        {
+            IDX2, 8,
+            DAT2, 8,
+            BNK2, 4
+        }
+
+        Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug)
+        //
+        // mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1
+        //
+        BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve)
+        {
+            FET0, 4,
+            FET1, 3
+        }
+
+        Store ("++++++++ Creating IndexField", Debug)
+        IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
+        {
+            FET2, 4,
+            FET3, 3
+        }
+
+        Store ("++++++++ SizeOf (BUFO)", Debug)
+        SizeOf (BUFO)
+
+        Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug)
+        Store (SizeOf (BUFO), Local0)
+
+        Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug)
+        Concatenate ("abd", "def", Local0)
+        Store (Local0, Debug)
+
+        Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug)
+        Concatenate ("abd", 0x7B, Local0)
+        Store (Local0, Debug)
+
+        Store ("++++++++ Creating Event EVT2", Debug)
+        Event (EVT2)
+
+        Store ("++++++++ Creating Mutex MTX2", Debug)
+        Mutex (MTX2, 0)
+
+        Store ("++++++++ Creating Alias MTXA to MTX2", Debug)
+        Alias (MTX2, MTXA)
+
+        Store ("++++++++ Acquiring Mutex MTX2", Debug)
+        Acquire (MTX2, 0xFFFF)
+
+        Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug)
+        Acquire (MTX2, 1)
+
+        Store ("++++++++ Releasing Mutex MTX2", Debug)
+        Release (MTX2)
+
+        // Type 1 opcodes
+
+        Store ("++++++++ Signalling Event EVT2", Debug)
+        Signal (EVT2)
+
+        Store ("++++++++ Resetting Event EVT2", Debug)
+        Reset (EVT2)
+
+        Store ("++++++++ Signalling Event EVT2", Debug)
+        Signal (EVT2)
+
+        Store ("++++++++ Waiting Event EVT2", Debug)
+        Wait (EVT2, 0xFFFF)
+
+        Store ("++++++++ Sleep", Debug)
+        Sleep (100)
+
+        Store ("++++++++ Stall", Debug)
+        Stall (254)
+
+        Store ("++++++++ NoOperation", Debug)
+        Noop
+
+        // Type 2 Opcodes
+
+        Store ("++++++++ Return from Method OBJ2", Debug)
+        return (4)
+    }
+
+
+    Method (NUM1, 0)
+    {
+        /* ADD */
+
+        Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug)
+        Add (0x12345678, 0x11111111, Local0)
+
+        Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug)
+        Store (Add (0x12345678, 0x11111111), Local1)
+
+        Store ("++++++++ Checking result from ADD", Debug)
+        if (LNotEqual (Local0, Local1))
+        {
+            ERR_ (0)
+        }
+
+
+        /* SUBTRACT */
+
+        Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug)
+        Subtract (0x87654321, 0x11111111, Local4)
+
+        Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug)
+        Store (Subtract (0x87654321, 0x11111111), Local5)
+
+        Store ("++++++++ Checking result from SUBTRACT", Debug)
+        if (LNotEqual (Local4, Local5))
+        {
+            ERR_ (0)
+        }
+
+
+        /* MULTIPLY */
+
+        Store ("++++++++ Multiply (33, 10, Local6)", Debug)
+        Multiply (33, 10, Local6)
+
+        Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug)
+        Store (Multiply (33, 10), Local7)
+
+
+        Store ("++++++++ Checking result from MULTIPLY", Debug)
+        if (LNotEqual (Local6, Local7))
+        {
+            ERR_ (0)
+        }
+
+
+        /* DIVIDE */
+
+        Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug)
+        Divide (100, 9, Local1, Local2)
+
+        Store ("++++++++ Store (Divide (100, 9), Local3)", Debug)
+        Store (Divide (100, 9), Local3)
+
+        Store ("++++++++ Checking (quotient) result from DIVIDE", Debug)
+        if (LNotEqual (Local2, Local3))
+        {
+            ERR_ (0)
+        }
+
+
+        /* INCREMENT */
+
+        Store ("++++++++ Increment (Local0)", Debug)
+        Store (1, Local0)
+        Store (2, Local1)
+        Increment (Local0)
+
+        Store ("++++++++ Checking result from INCREMENT", Debug)
+        if (LNotEqual (Local0, Local1))
+        {
+            ERR_ (0)
+        }
+
+
+        /* DECREMENT */
+
+        Store ("++++++++ Decrement (Local0)", Debug)
+        Store (2, Local0)
+        Store (1, Local1)
+        Decrement (Local0)
+
+        Store ("++++++++ Checking result from DECREMENT", Debug)
+        if (LNotEqual (Local0, Local1))
+        {
+            ERR_ (0)
+        }
+
+
+        /* TOBCD */
+        /* FROMBCD */
+
+        Store ("++++++++ ToBCD (0x1234, Local5)", Debug)
+        ToBCD (0x1234, Local5)
+
+        Store ("++++++++ FromBCD (Local5, Local6)", Debug)
+        FromBCD (Local5, Local6)
+
+        Store ("++++++++ Return (Local6)", Debug)
+        Return (Local6)
+    }
+
+
+    Method (CHEK)
+    {
+
+        Store (3, Local0)
+        Store (3, Debug)
+        Store (Local0, Debug)
+        Store (7, Local1)
+
+        Add (Local0, Local1)
+        if (LNotEqual (Local0, 3))
+        {
+            ERR_ (2)
+        }
+        if (LNotEqual (Local1, 7))
+        {
+            ERR_ (2)
+        }
+
+
+        Add (Local0, Local1, Local2)
+        if (LNotEqual (Local0, 3))
+        {
+            ERR_ (2)
+        }
+        if (LNotEqual (Local1, 7))
+        {
+            ERR_ (2)
+        }
+    }
+
+
+    Method (RET1)
+    {
+        Store (3, Local0)
+        Return (Local0)
+    }
+
+    Method (RET2)
+    {
+        Return (RET1())
+    }
+
+    Method (RETZ)
+    {
+        RET2 ()
+    }
+
+
+    Method (BITZ)
+    {
+        Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug)
+        FindSetLeftBit (0x00100100, Local0)
+        if (LNotEqual (Local0, 21))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug)
+        FindSetRightBit (0x00100100, Local1)
+        if (LNotEqual (Local1, 9))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug)
+        And (0xF0F0F0F0, 0x11111111, Local2)
+        if (LNotEqual (Local2, 0x10101010))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug)
+        NAnd (0xF0F0F0F0, 0x11111111, Local3)
+        if (LNotEqual (Local3, 0xEFEFEFEF))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug)
+        Or (0x11111111, 0x22222222, Local4)
+        if (LNotEqual (Local4, 0x33333333))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug)
+        NOr (0x11111111, 0x22222222, Local5)
+        if (LNotEqual (Local5, 0xCCCCCCCC))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug)
+        XOr (0x11113333, 0x22222222, Local6)
+        if (LNotEqual (Local6, 0x33331111))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug)
+        ShiftLeft (0x11112222, 2, Local7)
+        if (LNotEqual (Local7, 0x44448888))
+        {
+            ERR_ (1)
+        }
+
+        Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug)
+        ShiftRight (Local7, 2, Local7)
+        if (LNotEqual (Local7, 0x11112222))
+        {
+            ERR_ (1)
+        }
+
+
+        Store ("++++++++ Not (Local0, Local1)", Debug)
+        Store (0x22224444, Local0)
+        Not (Local0, Local1)
+        if (LNotEqual (Local0, 0x22224444))
+        {
+            ERR_ (2)
+        }
+
+        if (LNotEqual (Local1, 0xDDDDBBBB))
+        {
+            ERR_ (1)
+        }
+
+        Return (Local7)
+    }
+
+
+    Method (LOGS)
+    {
+
+        Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug)
+        Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)
+
+        Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug)
+        Store (LEqual (0xFFFFFFFF, 0x11111111), Local1)
+
+        Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug)
+        Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)
+
+        Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug)
+        Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)
+
+        Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug)
+        Store (LLess (0xFFFFFFFF, 0x11111111), Local4)
+
+        Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug)
+        Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)
+
+        Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug)
+        Store (0x00001111, Local6)
+        Store (LNot (Local6), Local7)
+        if (LNotEqual (Local6, 0x00001111))
+        {
+            ERR_ (2)
+        }
+
+        if (LNotEqual (Local7, 0x0))
+        {
+            ERR_ (1)
+        }
+
+
+        Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug)
+        Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)
+
+        Store ("++++++++ Lor (0x0, 0x1)", Debug)
+        if (Lor (0x0, 0x1))
+        {
+            Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug)
+        }
+
+        return (Local7)
+    }
+
+
+    Method (COND)
+    {
+        Store ("++++++++ Store (0x4, Local0)", Debug)
+        Store (0x4, Local0)
+
+        Store ("++++++++ While (Local0)", Debug)
+        While (Local0)
+        {
+            Store ("++++++++ Decrement (Local0)", Debug)
+            Decrement (Local0)
+        }
+
+
+        Store ("++++++++ Store (0x3, Local6)", Debug)
+        Store (0x3, Local6)
+
+        Store ("++++++++ While (Subtract (Local6, 1))", Debug)
+        While (Subtract (Local6, 1))
+        {
+            Store ("++++++++ Decrement (Local6)", Debug)
+            Decrement (Local6)
+        }
+
+
+        Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
+        If (LGreater (0x2, 0x1))
+        {
+            Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
+            If (LEqual (0x11111111, 0x22222222))
+            {
+                Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
+            }
+
+            else
+            {
+                Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
+                If (LNot (0x0))
+                {
+                    Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
+                    If (LAnd (0xEEEEEEEE, 0x2))
+                    {
+                        Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
+                        If (LLess (0x44444444, 0x3))
+                        {
+                            Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
+                        }
+
+                        else
+                        {
+                            Store ("++++++++ Exiting from nested IF/ELSE statements", Debug)
+                        }
+                    }
+                }
+            }
+        }
+
+
+        Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
+        If (LGreater (0x2, 0x1))
+        {
+            Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
+            If (LEqual (0x11111111, 0x22222222))
+            {
+                Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
+            }
+
+            else
+            {
+                Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
+                If (LNot (0x0))
+                {
+                    Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
+                    If (LAnd (0xEEEEEEEE, 0x2))
+                    {
+                        Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
+                        If (LLess (0x44444444, 0x3))
+                        {
+                            Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
+                        }
+
+                        else
+                        {
+                            Store ("++++++++ Returning from nested IF/ELSE statements", Debug)
+                            Return (Local6)
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+
+
+    Method (REFS)
+    {
+        Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7})
+
+        Name (NEST, Package ()
+        {
+            Package ()
+            {
+                0x01, 0x02, 0x03, 0x04, 0x05, 0x06
+            },
+            Package ()
+            {
+                0x11, 0x12, 0x12, 0x14, 0x15, 0x16
+            }
+        })
+
+    /* Parser thinks this is a method invocation!! */
+
+        Store (RefOf (MAIN), Local5)
+
+        // For this to work, ABCD must NOT exist.
+
+        Store (CondRefOf (ABCD, Local0), Local1)
+        if (LNotEqual (Local1, 0))
+        {
+            ERR_ (2)
+        }
+
+        Store (CondRefOf (BBUF, Local0), Local1)
+        if (LNotEqual (Local1, Ones))
+        {
+            ERR_ (2)
+        }
+
+        Store (DeRefOf (Index (BBUF, 3)), Local6)
+        if (LNotEqual (Local6, 0xB3))
+        {
+            ERR_ (2)
+        }
+
+        Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0)
+        if (LNotEqual (Local0, 0x14))
+        {
+            ERR_ (2)
+        }
+
+
+        Store (0x11223344, Local0)
+        Store (RefOf (Local0), Local1)
+
+        Store (DerefOf (Local1), Local2)
+        If (LNotEqual (Local2, 0x11223344))
+        {
+            ERR_ (2)
+        }
+
+
+    /* Parser thinks this is a method invocation!! */
+
+    //  RefOf (MAIN)
+
+
+    //  RefOf (R___)
+    //  RefOf (BBUF)
+
+    //  Store (RefOf (Local0), Local1)
+
+    //  CondRefOf (BBUF, Local2)
+    //  CondRefOf (R___, Local3)
+
+    //  Store (DerefOf (Local1), Local4)
+
+    //  Return (Local4)
+    }
+
+
+    Method (INDX, 0)
+    {
+        Name(STAT,Package(4){})
+        Store(0x44443333,Index(STAT,0))
+    }
+
+//=================================================================
+//=================================================================
+//===================== iPCO TESTS ================================
+//=================================================================
+//=================================================================
+//
+//
+// test IfElseOp.asl
+//
+//  test for IfOp and ElseOp, including validation of object stack cleanup
+//
+    Device (IFEL)
+    {
+        Name (DWRD, 1)
+        Name (RSLT, 0)
+
+        //  IFNR control method executes IfOp branch with NO nested Return
+        //  and no Else branch
+        Method (IFNR)
+        {
+            Store (DWRD, RSLT)
+            If (LEqual (DWRD, 1))
+            {
+                Store (0, RSLT)
+            }
+        }   //  IFNR
+
+        //  NINR control method does not execute If branch and has no Else branch
+        Method (NINR)
+        {
+            Store (0, RSLT)
+            If (LNotEqual (DWRD, 1))
+            {
+                Store (DWRD, RSLT)
+            }
+        }   //  NINR
+
+        //  IENR control method executes IfOp branch with NO nested Return
+        Method (IENR)
+        {
+            If (LEqual (DWRD, 1))
+            {
+                Store (0, RSLT)
+            }
+            Else
+            {
+                Store (DWRD, RSLT)
+            }
+        }   //  IENR
+
+        //  ELNR control method executes ElseOp branch with NO nested Return
+        Method (ELNR)
+        {
+            If (LNotEqual (DWRD, 1))
+            {
+                Store (DWRD, RSLT)
+            }
+            Else
+            {
+                Store (0, RSLT)
+            }
+        }   //  ELNR
+
+        //  IFRT control method executes IfOp branch with nested Return with
+        //  no Else branch
+        Method (IFRT)
+
+        {
+            If (LEqual (DWRD, 1))
+            {
+                Return (0)
+            }
+            Return (DWRD)
+        }   //  IFRT
+
+        //  IERT control method executes IfOp branch with nested Return with
+        //  Else branch
+        Method (IERT)
+        {
+            If (LEqual (DWRD, 1))
+            {
+                Return (0)
+            }
+            Else
+            {
+                Return (DWRD)
+            }
+        }   //  IERT
+
+        //  ELRT control method executes ElseOp branch with nested Return
+        Method (ELRT)
+        {
+            If (LNotEqual (DWRD, 1))
+            {
+                Return (DWRD)
+            }
+            Else
+            {
+                Return (0)
+            }
+        }   //  ELRT
+
+        Method (TEST)
+        {
+            Store ("++++++++ IfElseOp Test", Debug)
+
+            //  IfOp with NO return value
+            IFNR()
+            If (LNotEqual (RSLT, 0))
+            {
+                Return (RSLT)
+            }
+
+            //  IfOp with NO return value
+            NINR()
+            If (LNotEqual (RSLT, 0))
+            {
+                Return (RSLT)
+            }
+
+            //  IfOp with NO return value
+            IENR()
+            If (LNotEqual (RSLT, 0))
+            {
+                Return (RSLT)
+            }
+
+            //  ElseOp with NO return value
+            ELNR()
+            If (LNotEqual (RSLT, 0))
+            {
+                Return (RSLT)
+            }
+
+            //  IfOp with return value
+            Store (IFRT, RSLT)
+            If (LNotEqual (RSLT, 0))
+            {
+                Return (RSLT)
+            }
+
+            //  IfOp with return value
+            Store (IERT, RSLT)
+            If (LNotEqual (RSLT, 0))
+            {
+                Return (RSLT)
+            }
+
+            //  ElseOp with return value
+            Store (ELRT, RSLT)
+            If (LNotEqual (RSLT, 0))
+            {
+                Return (RSLT)
+            }
+
+            Return (0)
+        }   //  TEST
+    }   //  IFEL
+
+//
+// test NoSave.asl
+//
+//
+//  Internal test cases to validate IfOp (Operator (,,)) where Operator
+//  target is ZeroOp to throw away the results.
+//  Includes internal test cases for logical operators with no destination
+//  operands.
+//
+    Device (NOSV)
+    {
+        Method (TEST)
+        {
+            Store ("++++++++ NoSave Test", Debug)
+
+            Name (WRD, 0x1234)
+
+            //
+            //  Begin test of nested operators without saving results
+            //
+
+            //  Test If (And ()) with no save of And result
+            If (And (3, 1, ))
+            {
+                Store (1, WRD)  //  pass -- just do something
+            }
+            else
+            {
+                Return (1)      //  fail
+            }
+
+            //  Test If (And ()) with no save of And result
+            If (And (4, 1, ))
+            {
+                Return (2)      //  fail
+            }
+            else
+            {
+                Store (2, WRD)  //  pass -- just do something
+            }
+
+
+            //  Test If (NAnd ()) with no save of NAnd result
+            If (NAnd (3, 1, ))
+            {
+                Store (3, WRD)  //  pass -- just do something
+            }
+            else
+            {
+                Return (3)      //  fail
+            }
+
+            //  Test If (NAnd ()) with no save of NAnd result
+            If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, ))
+            {
+                Return (4)      // fail
+            }
+            else
+            {
+                Store (4, WRD)  //  pass -- just do something
+            }
+
+
+            //  Test If (NOr ()) with no save of NOr result
+            If (NOr (0, 1, ))
+            {
+                Store (5, WRD)  //  pass -- just do something
+            }
+            else
+            {
+                Return (5)      //  fail
+            }
+
+            //  Test If (NOr ()) with no save of NOr result
+            If (NOr (0xFFFFFFFE, 1, ))
+            {
+                Return (6)      // fail
+            }
+            else
+            {
+                Store (6, WRD)  //  pass -- just do something
+            }
+
+
+            //  Test If (Not ()) with no save of Not result
+            If (Not (1, ))
+            {
+                Store (7, WRD)  //  pass -- just do something
+            }
+            else
+            {
+                Return (7)      //  fail
+            }
+
+            //  Test If (Not ()) with no save of Not result
+            If (Not (0xFFFFFFFF, ))
+            {
+                Return (8)      // fail
+            }
+            else
+            {
+                Store (8, WRD)  //  pass -- just do something
+            }
+
+
+            //  Test If (Or ()) with no save of Or result
+            If (Or (3, 1, ))
+            {
+                Store (9, WRD)  //  pass -- just do something
+            }
+            else
+            {
+                Return (9)      //  fail
+            }
+
+            //  Test If (Or ()) with no save of Or result
+            If (Or (0, 0, ))
+            {
+                Return (10)     //  fail
+            }
+            else
+            {
+                Store (10, WRD) //  pass -- just do something
+            }
+
+
+            //  Test If (XOr ()) with no save of XOr result
+            If (XOr (3, 1, ))
+            {
+                Store (11, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (11)     // fail
+            }
+
+            //  Test If (XOr ()) with no save of XOr result
+            If (XOr (3, 3, ))
+            {
+                Return (12)     // fail
+            }
+            else
+            {
+                Store (12, WRD) //  pass -- just do something
+            }
+
+
+            //
+            //  Begin test of logical operators with no destination operands
+            //
+
+            //  Test If (LAnd ()) with no save of LAnd result
+            If (LAnd (3, 3))
+            {
+                Store (21, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (21)     // fail
+            }
+
+            //  Test If (LAnd ()) with no save of LAnd result
+            If (LAnd (3, 0))
+            {
+                Return (22)     // fail
+            }
+            else
+            {
+                Store (22, WRD) //  pass -- just do something
+            }
+
+            //  Test If (LAnd ()) with no save of LAnd result
+            If (LAnd (0, 3))
+            {
+                Return (23)     //  fail
+            }
+            else
+            {
+                Store (23, WRD) //  pass -- just do something
+            }
+
+            //  Test If (LAnd ()) with no save of LAnd result
+            If (LAnd (0, 0))
+            {
+                Return (24)     //  fail
+            }
+            else
+            {
+                Store (24, WRD) //  pass -- just do something
+            }
+
+
+            //  Test If (LEqual ()) with no save of LEqual result
+            If (LEqual (3, 3))
+            {
+                Store (31, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (31)     //  fail
+            }
+
+            //  Test If (LEqual ()) with no save of LEqual result
+            If (LEqual (1, 3))
+            {
+                Return (32)     //  fail
+            }
+            else
+            {
+                Store (32, WRD) //  pass -- just do something
+            }
+
+
+            //  Test If (LGreater ()) with no save of LGreater result
+            If (LGreater (3, 1))
+            {
+                Store (41, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (41)     //  fail
+            }
+
+            //  Test If (LGreater ()) with no save of LGreater result
+            If (LGreater (4, 4))
+            {
+                Return (42)     //  fail
+            }
+            else
+            {
+                Store (42, WRD) //  pass -- just do something
+            }
+
+            //  Test If (LGreater ()) with no save of LGreater result
+            If (LGreater (1, 4))
+            {
+                Return (43)     //  fail
+            }
+            else
+            {
+                Store (43, WRD) //  pass -- just do something
+            }
+
+            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
+            If (LGreaterEqual (3, 1))
+            {
+                Store (44, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (44)     //  fail
+            }
+
+            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
+            If (LGreaterEqual (3, 3))
+            {
+                Store (45, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (45)     //  fail
+            }
+
+            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
+            If (LGreaterEqual (3, 4))
+            {
+                Return (46)     //  fail
+            }
+            else
+            {
+                Store (46, WRD) //  pass -- just do something
+            }
+
+
+            //  Test If (LLess ()) with no save of LLess result
+            If (LLess (1, 3))
+            {
+                Store (51, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (51)     //  fail
+            }
+
+            //  Test If (LLess ()) with no save of LLess result
+            If (LLess (2, 2))
+            {
+                Return (52)     //  fail
+            }
+            else
+            {
+                Store (52, WRD) //  pass -- just do something
+            }
+
+            //  Test If (LLess ()) with no save of LLess result
+            If (LLess (4, 2))
+            {
+                Return (53)     //  fail
+            }
+            else
+            {
+                Store (53, WRD) //  pass -- just do something
+            }
+
+
+            //  Test If (LLessEqual ()) with no save of LLessEqual result
+            If (LLessEqual (1, 3))
+            {
+                Store (54, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (54)     //  fail
+            }
+
+            //  Test If (LLessEqual ()) with no save of LLessEqual result
+            If (LLessEqual (2, 2))
+            {
+                Store (55, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (55)     //  fail
+            }
+
+            //  Test If (LLessEqual ()) with no save of LLessEqual result
+            If (LLessEqual (4, 2))
+            {
+                Return (56)     //  fail
+            }
+            else
+            {
+                Store (56, WRD) //  pass -- just do something
+            }
+
+
+            //  Test If (LNot ()) with no save of LNot result
+            If (LNot (0))
+            {
+                Store (61, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (61)     //  fail
+            }
+
+            //  Test If (LNot ()) with no save of LNot result
+            If (LNot (1))
+            {
+                Return (62)     //  fail
+            }
+            else
+            {
+                Store (62, WRD) //  pass -- just do something
+            }
+
+
+            //  Test If (LNotEqual ()) with no save of LNotEqual result
+            If (LNotEqual (3, 3))
+            {
+                Return (63)     //  fail
+            }
+            else
+            {
+                Store (63, WRD) //  pass -- just do something
+            }
+
+            //  Test If (LNotEqual ()) with no save of LNotEqual result
+            If (LNotEqual (1, 3))
+            {
+                Store (64, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (64)     //  fail
+            }
+
+
+            //  Test If (LOr ()) with no save of LOr result
+            If (LOr (3, 1))
+            {
+                Store (71, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (71)     //  fail
+            }
+
+            //  Test If (LOr ()) with no save of LOr result
+            If (LOr (0, 1))
+            {
+                Store (72, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (72)     //  fail
+            }
+
+            //  Test If (LOr ()) with no save of LOr result
+            If (LOr (3, 0))
+            {
+                Store (73, WRD) //  pass -- just do something
+            }
+            else
+            {
+                Return (73)     //  fail
+            }
+
+            //  Test If (LOr ()) with no save of LOr result
+            If (LOr (0, 0))
+            {
+                Return (74)     //  fail
+            }
+            else
+            {
+                Store (74, WRD) //  pass -- just do something
+            }
+
+            Return (0)
+        }   //  TEST
+    }   //  NOSV
+
+
+//
+// test IndxFld.asl
+//
+//  IndexFld test
+//      This is just a subset of the many RegionOp/Index Field test cases.
+//      Tests index field element AccessAs macro.
+//
+    Device (IDXF)
+    {   //  Test device name
+
+        OperationRegion (SIO, SystemIO, 0x100, 2)
+        Field (SIO, ByteAcc, NoLock, Preserve)
+        {
+            INDX,   8,
+            DATA,   8
+        }
+        IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
+        {
+            AccessAs (ByteAcc, 0),
+            IFE0,   8,
+            IFE1,   8,
+            IFE2,   8,
+            IFE3,   8,
+            IFE4,   8,
+            IFE5,   8,
+            IFE6,   8,
+            IFE7,   8,
+            IFE8,   8,
+            IFE9,   8,
+        }
+
+        Method (TEST)
+        {
+            Store ("++++++++ IndxFld Test", Debug)
+
+            Store (IFE0, Local0)
+            Store (IFE1, Local1)
+            Store (IFE2, Local2)
+
+            Return (0)
+        }   //  TEST
+    }   //  IDXF
+
+//
+// test NestdLor.asl
+//
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+
+        Name (ZER0, 0)
+        Name (ZER1, 0)
+        Name (ZER2, 0)
+        Name (ONE0, 1)
+
+        Device (NSTL)
+        {
+            Method (TEST)
+            {
+                Store ("++++++++ NestdLor Test", Debug)
+
+                If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0))))
+                {   //  Indicate Pass
+                    Store (0x00, Local0)
+                }
+
+                Else
+                {   //  Indicate Fail
+                    Store (0x01, Local0)
+                }
+
+                Return (Local0)
+            }   //  End Method TEST
+        }   //  Device NSTL
+    }   //  _SB system bus
+
+//
+// test RetBuf.asl
+//
+//  Test ReturnOp(Buffer)
+//      This is required to support Control Method Batteries on
+//          Dell Latitude Laptops (e.g., CP1-A)
+//
+    Device (RTBF)
+    {
+        Method (SUBR, 1)
+        {
+            Return (Arg0)
+        }
+
+        Method (RBUF)
+        {   //  RBUF: Return Buffer from local variable
+            Name (ABUF, Buffer() {"ARBITRARY_BUFFER"})
+
+            //  store local buffer ABUF into Local0
+            Store (ABUF, Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Buffer
+            If (LNotEqual (Local1, 3))  //  Buffer type is 3
+            {
+                Return (1)      //  failure
+            }
+
+            //  store value returned by control method SUBR into Local0
+            Store (SUBR (ABUF), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Buffer
+            If (LNotEqual (Local1, 3))  //  Buffer type is 3
+            {
+                Return (2)      //  failure
+            }
+
+            //  allocate buffer using Local1 as buffer size (run-time evaluation)
+            Store (5, Local1)
+            Name (BUFR, Buffer(Local1) {})
+
+            //  store value returned by control method SUBR into Local0
+            Store (SUBR (BUFR), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Buffer
+            If (LNotEqual (Local1, 3))  //  Buffer type is 3
+            {
+                Return (3)      //  failure
+            }
+
+            //  store BUFR Buffer into Local0
+            Store (BUFR, Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Buffer
+            If (LNotEqual (Local1, 3))  //  Buffer type is 3
+            {
+                Return (4)      //  failure
+            }
+
+
+            //  return Local0 Buffer
+            Return (Local0)
+        }   //  RBUF
+
+        Method (TEST)
+        {
+            Store ("++++++++ RetBuf Test", Debug)
+
+            //  store RBUF Buffer return value into Local0
+            Store (RBUF, Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Buffer
+            If (LNotEqual (Local1, 3))  //  Buffer type is 3
+            {
+                Return (10)     //  failure
+            }
+            Else
+            {
+                Return (0)      //  success
+            }
+        }   //  TEST
+    }   //  RTBF
+
+//
+// test RetLVal.asl
+//
+//  Test ReturnOp(Lvalue)
+//      This is required to support _PSR on IBM ThinkPad 560D and
+//      _DCK on Toshiba Tecra 8000.
+//
+
+    Device (GPE2)
+    {
+        Method (_L03)
+        {
+            Store ("Method GPE2._L03 invoked", Debug)
+            Return ()
+        }
+
+        Method (_E05)
+        {
+            Store ("Method GPE2._E05 invoked", Debug)
+            Return ()
+        }
+    }
+
+    Device (PRW2)
+    {
+        Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3})
+    }
+
+
+    Scope (\_GPE)
+    {
+        Name (ACST, 0xFF)
+
+        Method (_L08)
+        {
+            Store ("Method _GPE._L08 invoked", Debug)
+            Return ()
+        }
+
+        Method (_E09)
+        {
+            Store ("Method _GPE._E09 invoked", Debug)
+            Return ()
+        }
+
+        Method (_E11)
+        {
+            Store ("Method _GPE._E11 invoked", Debug)
+            Notify (\PRW1, 2)
+        }
+
+        Method (_L22)
+        {
+            Store ("Method _GPE._L22 invoked", Debug)
+            Return ()
+        }
+
+        Method (_L33)
+        {
+            Store ("Method _GPE._L33 invoked", Debug)
+            Return ()
+        }
+
+        Method (_E64)
+        {
+            Store ("Method _GPE._E64 invoked", Debug)
+            Return ()
+        }
+
+    }   //  _GPE
+
+    Device (PRW1)
+    {
+        Name (_PRW, Package(2) {0x11, 3})
+    }
+
+    Device (PWRB)
+    {
+        Name (_HID, EISAID("PNP0C0C"))
+        Name (_PRW, Package(2) {0x33, 3})
+    }
+
+
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+
+        Device (ACAD)
+        {   //  ACAD:   AC adapter device
+            Name (_HID, "ACPI0003") //  AC adapter device
+
+            Name (_PCL, Package () {\_SB})
+
+            OperationRegion (AREG, SystemIO, 0x0372, 2)
+            Field (AREG, ByteAcc, NoLock, Preserve)
+            {
+                AIDX,   8,
+                ADAT,   8
+            }
+            IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
+            {
+                     ,  1,  //  skips
+                ACIN,   1,
+                     ,  2,  //  skips
+                CHAG,   1,
+                     ,  3,  //  skips
+                     ,  7,  //  skips
+                ABAT,   1,
+            }   //  IndexField
+
+            Method (_PSR)
+            {
+                Store (\_GPE.ACST, Local0)
+                Store (ACIN, Local1)
+                If (LNotEqual (\_GPE.ACST, Local1))
+                {
+                    Store (Local1, \_GPE.ACST)
+                    // This Notify is commented because it causes a
+                    //  method error when running on a system without the
+                    //  specific device.
+                    // Notify (\_SB_.ACAD, 0)
+                }
+                Return (Local0)
+            }   //  _PSR
+
+            Method (_STA)
+            {
+                Return (0x0F)
+            }
+
+            Method (_INI)
+            {
+                Store (ACIN, \_GPE.ACST)
+            }
+        }   //  ACAD:   AC adapter device
+
+        //  test implicit return from control method
+        Method (DIS_, 1)
+        {
+            Store (Arg0, Local0)
+        }
+
+        Device (RTLV)
+        {
+            //  test implicit return inside nested if with explicit return of Lvalue
+            Method (_DCK, 1)
+            //  Arg0:   1 == dock, 0 == undock
+            {
+                If (Arg0)
+                {   //  dock
+                    Store (0x87, Local0)
+
+                    If (Local0)
+                    {
+                        DIS_ (0x23)
+                        Return (1)
+                    }
+
+                    Return (0)
+                }   //  dock
+                Else
+                {   //  undock
+                    Store (Arg0, Local0)
+
+                    If (Local0)
+                    {
+                        DIS_ (0x23)
+                        Return (1)
+                    }
+
+                    Return (0)
+                }   //  undock
+            }   //  _DCK control method
+
+            Method (TEST)
+            {
+                Store ("++++++++ RetLVal Test", Debug)
+
+                //  store _PSR return value into Local0
+                Store (\_SB_.ACAD._PSR, Local0)
+
+                //  save Local0 object type value into Local1
+                Store (ObjectType (Local0), Local1)
+
+                //  validate Local0 is a Number
+                If (LNotEqual (Local1, 1))  //  Number/Integer type is 1
+                {
+                    Return (1)      //  failure
+                }
+
+                //  test implicit return inside nested if with explicit return of Lvalue
+                Store (_DCK (1), Local2)
+
+                //  save Local2 object type value into Local3
+                Store (ObjectType (Local2), Local3)
+
+                //  validate Local2 is a Number
+                If (LNotEqual (Local3, 1))  //  Number/Integer type is 1
+                {
+                    Return (2)      //  failure
+                }
+
+                If (LNotEqual (Local2, 1))
+                {
+                    Return (3)      //  failure
+                }
+
+                Return (0)  //  success
+            }   //  TEST
+        }   //  RTLV
+    }   //  _SB system bus
+
+//
+// test RetPkg.asl
+//
+//  Test ReturnOp(Package)
+//      This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1)
+//
+
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+        Device(LNKA)
+        {
+            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
+            Name (_UID, 1)
+        }
+        Device(LNKB)
+        {
+            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
+            Name (_UID, 2)
+        }
+        Device(LNKC)
+        {
+            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
+            Name (_UID, 3)
+        }
+        Device(LNKD)
+        {
+            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
+            Name (_UID, 4)
+        }
+
+        Device (PCI1)
+        {   //  PCI1:   Root PCI Bus
+            Name (_HID, "PNP0A03")  //  Need _HID for root device (String format)
+            Name (_ADR,0x00000000)
+            Name (_CRS,0)
+
+            Name (_PRT, Package ()
+            {
+                Package () {0x0004ffff, 0, LNKA, 0},            //  Slot 1, INTA
+                Package () {0x0004ffff, 1, LNKB, 0},            //  Slot 1, INTB
+                Package () {0x0004ffff, 2, LNKC, 0},            //  Slot 1, INTC
+                Package () {0x0004ffff, 3, LNKD, 0},            //  Slot 1, INTD
+                Package () {0x0005ffff, 0, \_SB_.LNKB, 0},  //  Slot 2, INTA
+                Package () {0x0005ffff, 1, \_SB_.LNKC, 0},  //  Slot 2, INTB
+                Package () {0x0005ffff, 2, \_SB_.LNKD, 0},  //  Slot 2, INTC
+                Package () {0x0006ffff, 3, \_SB_.LNKA, 0},  //  Slot 2, INTD
+                Package () {0x0006ffff, 0, LNKC, 0},            //  Slot 3, INTA
+                Package () {0x0006ffff, 1, LNKD, 0},            //  Slot 3, INTB
+                Package () {0x0006ffff, 2, LNKA, 0},            //  Slot 3, INTC
+                Package () {0x0006ffff, 3, LNKB, 0},            //  Slot 3, INTD
+            })
+
+            Device (PX40)
+            {   // Map f0 space, Start PX40
+                Name (_ADR,0x00070000)  //  Address+function.
+            }
+        }   //  PCI0:   Root PCI Bus
+
+        Device (RETP)
+        {
+            Method (RPKG)
+            {   //  RPKG: Return Package from local variable
+
+                //  store _PRT package into Local0
+                Store (\_SB_.PCI1._PRT, Local0)
+
+                //  return Local0 Package
+                Return (Local0)
+            }   //  RPKG
+
+            Method (TEST)
+            {
+                Store ("++++++++ RetPkg Test", Debug)
+
+                //  store RPKG package return value into Local0
+                Store (RPKG, Local0)
+
+                //  save Local0 object type value into Local1
+                Store (ObjectType (Local0), Local1)
+
+                //  validate Local0 is a Package
+                If (LNotEqual (Local1, 4))  //  Package type is 4
+                    {   Return (1)  }   //  failure
+                Else
+                    {   Return (0)  }   //  success
+            }   //  TEST
+        }   //  RETP
+    } // _SB_
+
+//
+// test WhileRet.asl
+//
+//  WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp.
+//
+    Device (WHLR)
+    {
+        Name (LCNT, 0)
+        Method (WIR)
+        {   //  WIR:    control method that returns inside of IfOp inside of WhileOp
+            While (LLess (LCNT, 4))
+            {
+                    If (LEqual (LCNT, 2))
+                    {
+                        Return (0)
+                    }
+
+                Increment (LCNT)
+            }
+
+            Return (LCNT)
+        }   //  WIR:    control method that returns inside of IfOp inside of WhileOp
+
+        Method (TEST)
+        {
+            Store ("++++++++ WhileRet Test", Debug)
+
+            Store (WIR, Local0)
+
+            Return (Local0)
+        }   //  TEST
+    }   //  WHLR
+
+//
+// test AndOrOp.asl
+//
+//This code tests the bitwise AndOp and OrOp Operator terms
+//
+//Syntax of Andop term
+//And - Bitwise And
+//AndTerm   := And(
+//  Source1,    //TermArg=>Integer
+//  Source2,    //TermArg=>Integer
+//  Result  //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types,
+// a bit-wise AND is performed, and the result is optionally
+//stored into Result.
+//
+//
+//Syntax of OrOp
+//Or - Bit-wise Or
+//OrTerm    := Or(
+//  Source1,    //TermArg=>Integer
+//  Source2 //TermArg=>Integer
+//  Result  //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types,
+// a bit-wide OR is performed, and the result is optionally
+//stored in Result
+//
+    Device (ANDO)
+    {
+        OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
+        Field (TMEM, ByteAcc, NoLock, Preserve)
+        {
+                ,   3,
+            TOUD,   13
+        }
+
+        //Create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,  //  8-bit BYTE
+        }// Field(RAM)
+
+
+        //And with Byte Data
+        Name (BYT1, 0xff)
+        Name (BYT2, 0xff)
+        Name (BRSL, 0x00)
+
+        //And with Word Data
+        Name (WRD1, 0xffff)
+        Name (WRD2, 0xffff)
+        Name (WRSL, 0x0000)
+
+        //And with DWord Data
+        Name (DWD1, 0xffffffff)
+        Name (DWD2, 0xffffffff)
+        Name (DRSL, 0x00000000)
+
+        Method (ANDP)
+        {
+            //Check with 1 And 1 on byte data
+            And(BYT1, BYT2, BRSL)
+            if(LNotEqual(BRSL,0xff))
+            {Return(1)}
+
+            //Check with 1 And 1 on Word data
+            And(WRD1, WRD2, WRSL)
+            if(LNotEqual(WRSL,0xffff))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 1 And 1 Dword
+            And(DWD1, DWD2, DRSL)
+            if(LNotEqual(DRSL,0xffffffff))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 0 And 0 on byte data
+            Store(0x00,BYT1)
+            Store(0x00,BYT2)
+            Store(0x00,BRSL)
+            And(BYT1, BYT2, BRSL)
+            if(LNotEqual(BRSL,0x00))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 0 And 0 on Word data
+            Store (0x0000,WRD1)
+            Store (0x0000,WRD2)
+            Store (0x0000,WRSL)
+            And(WRD1, WRD2, WRSL)
+            if(LNotEqual(WRSL,0x0000))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 0 And 0 Dword
+            Store (0x00000000,DWD1)
+            Store (0x00000000,DWD2)
+            Store (0x00000000,DRSL)
+            And(DWD1, DWD2, DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+            {
+                Return (1)      //  failure
+            }
+
+
+            //Check with 1 And 0 on byte data
+            Store(0x55,BYT1)
+            Store(0xAA,BYT2)
+            Store(0x00,BRSL)
+            And(BYT1, BYT2, BRSL)
+            if(LNotEqual(BRSL,0x00))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 1 And 0 on Word data
+            Store (0x5555,WRD1)
+            Store (0xAAAA,WRD2)
+            Store (0x0000,WRSL)
+            And(WRD1, WRD2, WRSL)
+            if(LNotEqual(WRSL,0x0000))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 1 And 0 on Dword
+            Store (0x55555555,DWD1)
+            Store (0xAAAAAAAA,DWD2)
+            Store (0x00000000,DRSL)
+            And(DWD1, DWD2, DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+            {
+                Return (1)      //  failure
+            }
+
+            Store (0x1FFF, TOUD)
+            Store (TOUD, Local0)
+            if(LNotEqual(Local0,0x1FFF))
+            {
+                Return (1)      //  failure
+            }
+
+            //TBD- Do We need to check for system memory data also for each test case ??
+
+            Return(0)
+
+        }//ANDP
+
+        Method (OROP)
+        {
+
+            //Check with 1 Ored with 1 on byte data
+            Store(0xff,BYT1)
+            Store(0xff,BYT2)
+            Store(0x00,BRSL)
+            Or(BYT1, BYT2, BRSL)
+            if(LNotEqual(BRSL,0xff))
+            {
+                Return (1)      //  failure
+            }
+
+
+            //Check with 1 Ored with 1 on Word data
+            Store(0xffff,WRD1)
+            Store(0xffff,WRD2)
+            Store(0x0000,WRSL)
+            Or(WRD1, WRD2, WRSL)
+            if(LNotEqual(WRSL,0xffff))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 1 Ored with 1 on Dword data
+            Store(0xffffffff,DWD1)
+            Store(0xffffffff,DWD2)
+            Store(0x00000000,DRSL)
+            Or(DWD1, DWD2, DRSL)
+            if(LNotEqual(DRSL,0xffffffff))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 0 Ored with 0 on byte data
+            Store(0x00,BYT1)
+            Store(0x00,BYT2)
+            Store(0x00,BRSL)
+            Or(BYT1, BYT2, BRSL)
+            if(LNotEqual(BRSL,0x00))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 0 Ored with 0 on Word data
+            Store (0x0000,WRD1)
+            Store (0x0000,WRD2)
+            Store (0x0000,WRSL)
+            Or(WRD1, WRD2, WRSL)
+            if(LNotEqual(WRSL,0x0000))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 0 Ored with  0 Dword data
+            Store (0x00000000,DWD1)
+            Store (0x00000000,DWD2)
+            Store (0x00000000,DRSL)
+            Or(DWD1, DWD2, DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+            {
+                Return (1)      //  failure
+            }
+
+
+            //Check with 1 Ored with 0 on byte data
+            Store(0x55,BYT1)
+            Store(0xAA,BYT2)
+            Store(0x00,BRSL)
+            Or(BYT1, BYT2, BRSL)
+            if(LNotEqual(BRSL,0xff))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 1 Ored with 0 on Word data
+            Store (0x5555,WRD1)
+            Store (0xAAAA,WRD2)
+            Store (0x0000,WRSL)
+            Or(WRD1, WRD2, WRSL)
+            if(LNotEqual(WRSL,0xffff))
+            {
+                Return (1)      //  failure
+            }
+
+            //Check with 1 Ored with 0 on Dword data
+            Store (0x55555555,DWD1)
+            Store (0xAAAAAAAA,DWD2)
+            Store (0x00000000,DRSL)
+            Or(DWD1, DWD2, DRSL)
+            if(LNotEqual(DRSL,0xffffffff))
+            {
+                Return (1)      //  failure
+            }
+
+            //TBD - Do We need to check for system memory data also for each test case ??
+
+            Return(0)
+
+        }//OROP
+
+        Method(TEST)
+        {
+            Store ("++++++++ AndOrOp Test", Debug)
+
+            Name(RSLT,1)
+            //Call Andop method
+            Store(ANDP,RSLT)
+            if(LEqual(RSLT,1))
+            {
+                Return (RSLT)
+            }
+
+            //Call OrOp Method
+            Store(OROP,RSLT)
+            if(LEqual(RSLT,1))
+            {
+                Return(RSLT)
+            }
+
+            //
+            // Return original conditions to allow iterative execution
+            //
+            Store(0xff,BYT1)
+            Store(0xff,BYT2)
+            Store(0x00,BRSL)
+            Store (0xffff,WRD1)
+            Store (0xffff,WRD2)
+            Store (0x0000,WRSL)
+            Store (0xffffffff,DWD1)
+            Store (0xffffffff,DWD2)
+            Store (0x00000000,DRSL)
+
+            Return(0)
+        }   //TEST
+    }   //ANDO
+
+//
+// test BreakPnt.asl
+//
+// This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is
+// BreakPointTerm    := BreakPoint
+// Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger.
+// In the non-debug version of the interpreter, BreakPoint is equivalent to Noop.
+//
+    Device (BRKP)
+    {
+        Name(CNT0,0)
+
+        Method (BK1)
+        {
+            BreakPoint
+            Return(0)
+        }
+
+        Method (TEST)
+        {
+            Store ("++++++++ BreakPnt Test", Debug)
+
+            Store(0,CNT0)
+
+            //Check BreakPoint statement
+            While(LLess(CNT0,10))
+            {
+                Increment(CNT0)
+            }
+
+            //Check the BreakPoint statement
+            If(LEqual(CNT0,10))
+            {
+    //            BreakPoint
+                Return(0)
+            }
+
+            //failed
+            Return(1)
+        }
+    }
+
+//
+// test AddSubOp.asl
+//
+    Device (ADSU)
+    {
+        //  create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,  //  8-bit BYTE
+        }   //  Field(RAM)
+
+        Method (TEST)
+        {
+            Store ("++++++++ AddSubOp Test", Debug)
+
+            Name (DWRD, 0x12345678)
+            Name (WRD, 0x1234)
+            Name (BYT, 0x12)
+
+            //  Test AddOp with DWORD data
+            Store (0x12345678, DWRD)
+            Add (DWRD, 7, DWRD)
+            If (LNotEqual (DWRD, 0x1234567F))
+                {   Return (DWRD)   }
+
+            //  Test AddOp with WORD data
+            Add (WRD, 5, WRD)
+            If (LNotEqual (WRD, 0x1239))
+                {   Return (WRD)    }
+
+            //  Test AddOp with BYTE data
+            Add (BYT, 3, BYT)
+            If (LNotEqual (BYT, 0x15))
+                {   Return (BYT)    }
+
+            //  Test SubtractOp with DWORD data
+            Subtract (DWRD, 7, DWRD)
+            If (LNotEqual (DWRD, 0x12345678))
+                {   Return (DWRD)   }
+
+            //  Test SubtractOp with WORD data
+            Subtract (WRD, 3, WRD)
+            If (LNotEqual (WRD, 0x1236))
+                {   Return (WRD)    }
+
+            //  Test SubtractOp with BYTE data
+            Subtract (BYT, 3, BYT)
+            If (LNotEqual (BYT, 0x12))
+                {   Return (BYT)    }
+
+
+            //  test AddOp with DWORD SystemMemory OpRegion
+            Store (0x01234567, SMDW)
+            Add (SMDW, 8, SMDW)
+            If (LNotEqual (SMDW, 0x0123456F))
+                {   Return (SMDW)   }
+
+            //  test SubtractOp with DWORD SystemMemory OpRegion
+            Subtract (SMDW, 7, SMDW)
+            If (LNotEqual (SMDW, 0x01234568))
+                {   Return (SMDW)   }
+
+
+            //  test AddOp with WORD SystemMemory OpRegion
+            Store (0x0123, SMWD)
+            Add (SMWD, 6, SMWD)
+            If (LNotEqual (SMWD, 0x0129))
+                {   Return (SMWD)   }
+
+            //  test SubtractOp with WORD SystemMemory OpRegion
+            Subtract (SMWD, 5, SMWD)
+            If (LNotEqual (SMWD, 0x0124))
+                {   Return (SMWD)   }
+
+
+            //  test AddOp with BYTE SystemMemory OpRegion
+            Store (0x01, SMBY)
+            Add (SMBY, 4, SMBY)
+            If (LNotEqual (SMBY, 0x05))
+                {   Return (SMBY)   }
+
+            //  test SubtractOp with BYTE SystemMemory OpRegion
+            Subtract (SMBY, 3, SMBY)
+            If (LNotEqual (SMBY, 0x02))
+                {   Return (SMBY)   }
+
+            Return (0)
+        }   //  TEST
+    }   //  ADSU
+
+//
+// test IncDecOp.asl
+//
+    Device (INDC)
+    {
+        //  create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,  //  8-bit BYTE
+        }   //  Field(RAM)
+
+        Method (TEST)
+        {
+            Store ("++++++++ IncDecOp Test", Debug)
+
+            Name (DWRD, 0x12345678)
+            Name (WRD, 0x1234)
+            Name (BYT, 0x12)
+
+            //  Test IncrementOp with DWORD data
+            Store (0x12345678, DWRD)
+            Increment (DWRD)
+            If (LNotEqual (DWRD, 0x12345679))
+                {   Return (DWRD)   }
+
+            //  Test IncrementOp with WORD data
+            Increment (WRD)
+            If (LNotEqual (WRD, 0x1235))
+                {   Return (WRD)    }
+
+            //  Test IncrementOp with BYTE data
+            Increment (BYT)
+            If (LNotEqual (BYT, 0x13))
+                {   Return (BYT)    }
+
+            //  Test DecrementOp with DWORD data
+            Decrement (DWRD)
+            If (LNotEqual (DWRD, 0x12345678))
+                {   Return (DWRD)   }
+
+            //  Test DecrementOp with WORD data
+            Decrement (WRD)
+            If (LNotEqual (WRD, 0x1234))
+                {   Return (WRD)    }
+
+            //  Test DecrementOp with BYTE data
+            Decrement (BYT)
+            If (LNotEqual (BYT, 0x12))
+                {   Return (BYT)    }
+
+
+            //  test IncrementOp with DWORD SystemMemory OpRegion
+            Store (0x01234567, SMDW)
+            Increment (SMDW)
+            If (LNotEqual (SMDW, 0x01234568))
+                {   Return (SMDW)   }
+
+            //  test DecrementOp with DWORD SystemMemory OpRegion
+            Decrement (SMDW)
+            If (LNotEqual (SMDW, 0x01234567))
+                {   Return (SMDW)   }
+
+
+            //  test IncrementOp with WORD SystemMemory OpRegion
+            Store (0x0123, SMWD)
+            Increment (SMWD)
+            If (LNotEqual (SMWD, 0x0124))
+                {   Return (SMWD)   }
+
+            //  test DecrementOp with WORD SystemMemory OpRegion
+            Decrement (SMWD)
+            If (LNotEqual (SMWD, 0x0123))
+                {   Return (SMWD)   }
+
+
+            //  test IncrementOp with BYTE SystemMemory OpRegion
+            Store (0x01, SMBY)
+            Increment (SMBY)
+            If (LNotEqual (SMBY, 0x02))
+                {   Return (SMBY)   }
+
+            //  test DecrementOp with BYTE SystemMemory OpRegion
+            Decrement (SMBY)
+            If (LNotEqual (SMBY, 0x01))
+                {   Return (SMBY)   }
+
+            Return (0)
+        }   //  TEST
+    }   //  INDC
+
+//
+// test LOps.asl
+//
+//This source tests all the logical operators. Logical operators in ASL are as follows.
+//LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr.
+// Success will return 0 and failure will return a non zero number. Check the source code for
+// non zero number to find where the test failed
+
+    Device (LOPS)
+    {
+        //Create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,  //  8-bit BYTE
+        }// Field(RAM)
+
+        //And with Byte Data
+        Name (BYT1, 0xff)
+        Name (BYT2, 0xff)
+        Name (BRSL, 0x00)
+
+        //And with Word Data
+        Name (WRD1, 0xffff)
+        Name (WRD2, 0xffff)
+        Name (WRSL, 0x0000)
+
+        //And with DWord Data
+        Name (DWD1, 0xffffffff)
+        Name (DWD2, 0xffffffff)
+        Name (DRSL, 0x00000000)
+
+        Name(RSLT,1)
+
+        Method (ANDL,2) // Test Logical And
+        {
+            //test with the arguments passed
+            if(LEqual(Arg0,Arg1))
+            { Store(LAnd(Arg0,Arg1),RSLT)
+                if(LNotEqual(Ones,RSLT))
+                {Return(11)}
+            }
+
+            //test with he locals
+            Store(Arg0,Local0)
+            Store(Arg1,Local1)
+
+            if(LEqual(Local0,Local1))
+            {
+                Store(LAnd(Local0,Local1),RSLT)
+                if(LNotEqual(Ones,RSLT))
+                    {Return(12)}
+            }
+
+            //test with BYTE data
+            if(LEqual(BYT1,BYT2))
+            { Store(LAnd(BYT1,BYT2),BRSL)
+                if(LNotEqual(Ones,BRSL))
+                {Return(13)}
+            }
+
+            //test with WORD data
+            if(LEqual(WRD1,WRD2))
+            { Store(LAnd(WRD1,WRD2),WRSL)
+                if(LNotEqual(Ones,WRSL))
+                {Return(14)}
+            }
+
+            //test with DWORD data
+            if(LEqual(DWD1,DWD2))
+            { Store(LAnd(DWD1,DWD2),DRSL)
+                if(LNotEqual(Ones,DRSL))
+                {Return(15)}
+            }
+
+            //Test for system memory data for each test case.
+
+                Store(0xff,BYT1)
+                Store(0xff,SMBY)
+                Store(0x00,BRSL)
+
+            //test with BYTE system memory data
+            if(LEqual(BYT1,SMBY))
+            { Store(LAnd(BYT1,SMBY),BRSL)
+                if(LNotEqual(Ones,BRSL))
+                {Return(16)}
+            }
+
+            Store (0xffff,WRD1)
+            Store(0xffff,SMWD)
+            Store(0x0000,WRSL)
+            //test with WORD system memory data
+            if(LEqual(WRD1,SMWD))
+            { Store(LAnd(WRD1,SMWD),WRSL)
+                if(LNotEqual(Ones,WRSL))
+                {Return(17)}
+            }
+
+            Store(0x000000,DRSL)
+            Store (0xffffff,DWD1)
+            Store(0xffffff,SMDW)
+
+            //test with DWORD system memory data
+            if(LEqual(DWD1,SMDW))
+            { Store(LAnd(DWD1,SMDW),DRSL)
+                if(LNotEqual(Ones,DRSL))
+                {Return(18)}
+            }
+
+            Return(0)
+
+        }//ANDL
+
+        //Test the LOr Operator
+
+        Method (ORL_,2)
+        {//ORL_
+
+            //test with the arguments passed
+            if(LEqual(Arg0,Arg1))
+            {
+                Store(LOr(Arg0,Arg1),RSLT)
+                if(LNotEqual(Ones,RSLT))
+                {
+                    Return(21)
+                }
+            }
+
+            //test with he locals
+            Store(Arg0,Local0)
+            Store(Arg1,Local1)
+
+            if(LEqual(Local0,Local1))
+            {
+                Store(LOr(Local0,Local1),RSLT)
+                if(LNotEqual(Ones,RSLT))
+                    {Return(22)}
+            }
+
+            //Check with 1 LOred with 0 on byte data
+            Store(0xff,BYT1)
+            Store(0x00,BYT2)
+            Store(0x00,BRSL)
+
+            if(LNotEqual(BYT1, BYT2))
+            {
+                Store(LOr(BYT1, BYT2), BRSL)
+                if(LNotEqual(Ones,BRSL))
+                {Return(23)}
+            }
+
+            //Check with 1 LOred with 0 on WORD data
+            Store(0xffff,WRD1)
+            Store(0x0000,WRD2)
+            Store(0x0000,WRSL)
+
+            if(LNotEqual(WRD1, WRD2))
+            {
+                Store(LOr(WRD1, WRD2), WRSL)
+                if(LNotEqual(Ones,WRSL))
+                {Return(24)}
+            }
+
+            //Check with 1 LOred with 0 on DWORD data
+            Store(0xffffffff,DWD1)
+            Store(0x00000000,DWD2)
+            Store(0x00000000,DRSL)
+
+            if(LNotEqual(DWD1, DWD2))
+            {
+                Store(LOr(DWD1, DWD2), DRSL)
+                if(LNotEqual(Ones,DRSL))
+                {Return(25)}
+            }
+
+            Store(0x00,BYT1)
+            Store(0xff,SMBY)
+            Store(0x00,BRSL)
+
+            //test with BYTE system memory data
+            if(LEqual(BYT1,SMBY))
+            { Store(LOr(BYT1,SMBY),BRSL)
+                if(LNotEqual(Ones,BRSL))
+                {Return(26)}
+            }
+
+            Store (0x0000,WRD1)
+            Store(0xffff,SMWD)
+            Store(0x0000,WRSL)
+
+            //test with WORD system memory data
+            if(LEqual(WRD1,SMWD))
+            { Store(LOr(WRD1,SMWD),WRSL)
+                if(LNotEqual(Ones,WRSL))
+                {Return(27)}
+            }
+
+
+            Store(0x00000000,DWD1)
+            Store(0xffffffff,SMDW)
+            Store(0x00000000,DRSL)
+
+            //test with DWORD system memory data
+            if(LEqual(DWD1,SMDW))
+            { Store(LAnd(DWD1,SMDW),DRSL)
+                if(LNotEqual(Ones,DRSL))
+                {Return(28)}
+            }
+            Return(0)
+
+        }//ORL_
+
+        //This method tests LGreater and LNot operator
+        Method(LSGR,2)
+        {//LSGR
+
+            //Test on arguements passed
+
+            //in test data, Arg1 > Arg0
+            if(LEqual(Ones,LNot(LGreater(Arg1,Arg0))))
+            {Return(31)}
+
+            //test LLessEqual
+            if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0))))
+            {Return(32)}
+
+            if(LEqual(Ones,LLess(Arg1,Arg0)))
+            {Return(33)}
+
+            //test LLessEqual
+            if(LEqual(Ones,LLessEqual(Arg1,Arg0)))
+            {Return(34)}
+
+            Store(Arg0,Local0)
+            Store(Arg1,Local1)
+
+            //test with the locals
+            if(LNot(LGreater(Local1,Local0)))
+                {Return(35)}
+
+            //test on Byte data
+            Store(0x12,BYT1)
+            Store(0x21,BYT2)
+
+            if(LNot(LGreater(BYT2,BYT1)))
+                {Return(36)}
+
+            if(LNot(LLess(BYT1,BYT2)))
+                {Return(37)}
+
+            //test LGreaterEqual with byte data
+            if(LNot(LGreaterEqual(BYT2,BYT1)))
+                {Return(38)}
+
+            //test LLessEqual byte data
+            if(LNot(LLessEqual(BYT1,BYT2)))
+                {Return(39)}
+
+
+            //test on Word data
+            Store(0x1212,WRD1)
+            Store(0x2121,WRD2)
+
+            if(LNot(LGreater(WRD2,WRD1)))
+                {Return(310)}
+
+            if(LNot(LLess(WRD1,WRD2)))
+                {Return(311)}
+
+            //Test LGreaterEqual with Word Data
+            if(LNot(LGreaterEqual(WRD2,WRD1)))
+                {Return(312)}
+
+
+            //Test LLessEqual with Word Data
+            if(LNot(LLessEqual(WRD1,WRD2)))
+                {Return(313)}
+
+            //test on DWord data
+            Store(0x12121212,DWD1)
+            Store(0x21212121,DWD2)
+
+            if(LNot(LGreater(DWD2,DWD1)))
+                {Return(314)}
+
+            if(LNot(LLess(DWD1,DWD2)))
+                {Return(315)}
+
+
+            //Test LGreaterEqual with Dword
+            if(LNot(LGreaterEqual(DWD2,DWD1)))
+                {Return(316)}
+
+            //Test LLessEqual DWord
+            if(LNot(LLessEqual(DWD1,DWD2)))
+                {Return(317)}
+
+            Return(0)
+        }//LSGR
+
+        //The test method
+        Method(TEST)
+        {
+            Store ("++++++++ LOps Test", Debug)
+
+            Store(0,RSLT)
+            //Call LAndOp method
+            Store(ANDL(2,2),RSLT)
+            if(LNotEqual(RSLT,0))
+             {Return(RSLT)}
+
+            //Call LOrOp Method
+            Store(ORL_(5,5),RSLT)
+            if(LNotEqual(RSLT,0))
+            {Return(RSLT)}
+
+            //Call LSGR Method
+            Store(LSGR(5,7),RSLT)
+            if(LNotEqual(RSLT,0))
+            {Return(RSLT)}
+
+            Return(0)
+        }//TEST
+    }//LOPS
+
+//
+// test FdSetOps.asl
+//
+//  FindSetLeftBit - Find Set Left Bit
+//  FindSetLeftBitTerm  := FindSetLeftBit
+//  (   Source, //TermArg=>Integer
+//      Result  //Nothing | SuperName
+//  ) => Integer
+//  Source is evaluated as integer data type, and the one-based bit location of
+//  the first MSb (most significant set bit) is optionally stored into Result.
+//  The result of 0 means no bit was set, 1 means the left-most bit set is the
+//  first bit, 2 means the left-most bit set is the second bit, and so on.
+//  FindSetRightBit - Find Set Right Bit
+
+//  FindSetRightBitTerm := FindSetRightBit
+//  (   Source, //TermArg=>Integer
+//      Result  //Nothing | SuperName
+//  ) => Integer
+//  Source is evaluated as integer data type, and the one-based bit location of
+//  the most LSb (least significant set bit) is optionally stored in Result.
+//  The result of 0 means no bit was set, 32 means the first bit set is the
+//  32nd bit, 31 means the first bit set is the 31st bit, and so on.
+
+//  If the Control method is success Zero is returned. Otherwise a non-zero
+//  number is returned.
+//
+    Device (FDSO)
+    {   //  FDSO
+
+        //  Create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,      //  8-bit BYTE
+        }   //  Field(RAM)
+
+        //  Byte Data
+        Name (BYT1, 1)
+        Name (BRSL, 0x00)
+
+        //  Word Data
+        Name (WRD1, 0x100)
+        Name (WRSL, 0x0000)
+
+        //  DWord Data
+        Name (DWD1, 0x10000)
+        Name (DRSL, 0x00000000)
+        Name (RSLT, 1)
+        Name (CNTR, 1)
+
+        Method (SHFT,2)
+        //  Arg0 is the actual data and Arg1 is the bit position
+        {   //  SHFT
+            Store (Arg0, Local0)
+            Store (Arg1, Local1)
+
+            FindSetLeftBit (Arg0, BRSL)
+            If (LNotEqual (BRSL, Arg1))
+                {   Return (0x11)   }
+            If (LNotEqual (Arg0, Local0))
+                {   Return (0x12)   }
+
+            FindSetLeftBit (Local0, BRSL)
+            If (LNotEqual (BRSL, Local1))
+                {   Return (0x13)   }
+            If (LNotEqual (Arg0, Local0))
+                {   Return (0x14)   }
+
+            //  test the byte value for SetLeftBit
+            Store (7, BYT1)
+            FindSetLeftBit (BYT1, BRSL)
+            If (LNotEqual (BRSL, 3))
+                {   Return (0x15)   }
+            If (LNotEqual (BYT1, 7))
+                {   Return (0x16)   }
+
+            Store (1, BYT1)
+            Store (1, CNTR)
+            While (LLessEqual (CNTR, 8))
+            {   //  FindSetLeftBit check loop for byte data
+                FindSetLeftBit (BYT1, BRSL)
+                If (LNotEqual (BRSL, CNTR))
+                    {   Return (0x17)   }
+
+                //  Shift the bits to check the same
+                ShiftLeft (BYT1, 1, BYT1)
+                Increment (CNTR)
+            }   //  FindSetLeftBit check loop for byte data
+
+
+            //  Check BYTE value for SetRightBit
+            Store (7, BYT1)
+            FindSetRightBit (BYT1, BRSL)
+            If (LNotEqual (BRSL, 1))
+                {   Return (0x21)   }
+            If (LNotEqual (BYT1, 7))
+                {   Return (0x22)   }
+
+            Store (1, CNTR)
+            Store (0xFF, BYT1)
+            While (LLessEqual (CNTR, 8))
+            {   //  FindSetRightBit check loop for byte data
+                FindSetRightBit (BYT1, BRSL)
+                If (LNotEqual (BRSL, CNTR))
+                    {   Return (0x23)   }
+
+                ShiftLeft (BYT1, 1, BYT1)
+                Increment (CNTR)
+            }   //  FindSetRightBit check loop for byte data
+
+
+            //  Test Word value for SetLeftBit
+            Store (9, CNTR)
+            Store (0x100, WRD1)
+            While (LLessEqual (CNTR, 16))
+            {
+                //  FindSetLeftBit check loop for Word data
+                FindSetLeftBit (WRD1, WRSL)
+                If (LNotEqual (WRSL, CNTR))
+                    {   Return (0x31)   }
+
+                //  Shift the bits to check the same
+                ShiftLeft (WRD1, 1, WRD1)
+                Increment (CNTR)
+            }   //  FindSetLeftBit check loop for Word data
+
+            //  Check Word value for SetRightBit
+            Store (9, CNTR)
+            Store (0xFF00, WRD1)
+            While (LLessEqual (CNTR, 16))
+            {
+                //  FindSetRightBit check loop for Word data
+                FindSetRightBit (WRD1, WRSL)
+                If (LNotEqual (WRSL, CNTR))
+                    {   Return (0x32)   }
+
+                ShiftLeft (WRD1, 1, WRD1)
+                Increment (CNTR)
+            }   //  FindSetRightBit check loop for Word data
+
+            //  Test the DWord value for SetLeftBit
+            Store (17, CNTR)
+            Store (0x10000, DWD1)
+            While (LLessEqual (CNTR, 32))
+            {
+                //  FindSetLeftBit check loop for Dword
+                FindSetLeftBit (DWD1, DRSL)
+                If (LNotEqual (DRSL, CNTR))
+                    {   Return (0x41)   }
+
+                //  Shift the bits to check the same
+                ShiftLeft (DWD1, 1, DWD1)
+                Increment (CNTR)
+            }   //  FindSetLeftBit check loop for Dword
+
+            //  Check DWord value for SetRightBit
+            Store (17, CNTR)
+            Store (0xFFFF0000, DWD1)
+            While (LLessEqual (CNTR, 32))
+            {   //  FindSetRightBit Check loop for DWORD
+                FindSetRightBit (DWD1, DRSL)
+                If (LNotEqual (DRSL, CNTR))
+                    {   Return (0x42)   }
+
+                ShiftLeft (DWD1, 1, DWD1)
+                Increment (CNTR)
+            }   //  FindSetRightBit Check loop for DWORD
+
+            Return (0)
+        }   //  SHFT
+
+        //  Test method called from amlexec
+        Method (TEST)
+        {   //  TEST
+
+            Store ("++++++++ FdSetOps Test", Debug)
+
+            Store (SHFT (0x80, 8), RSLT)
+            If (LNotEqual (RSLT, 0))
+                {   Return (RSLT)   }
+
+            Return (0)  //  pass
+        }   //  TEST
+    }   //  Device FDSO
+
+//
+// test MulDivOp.asl
+//
+    Device (MLDV)
+    {
+        //  create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,  //  8-bit BYTE
+        }   //  Field(RAM)
+
+        Method (TEST)
+        {
+            Store ("++++++++ MulDivOp Test", Debug)
+
+            Name (RMDR, 0)
+            Name (DWRD, 0x12345678)
+            Name (WRD, 0x1234)
+            Name (BYT, 0x12)
+
+            //  Test MultiplyOp with DWORD data
+            Store (0x12345678, DWRD)
+            Multiply (DWRD, 3, DWRD)
+            If (LNotEqual (DWRD, 0x369D0368))
+                {   Return (DWRD)   }
+
+            //  Test MultiplyOp with WORD data
+            Multiply (WRD, 4, WRD)
+            If (LNotEqual (WRD, 0x48D0))
+                {   Return (WRD)    }
+
+            //  Test MultiplyOp with BYTE data
+            Multiply (BYT, 5, BYT)
+            If (LNotEqual (BYT, 0x5A))
+                {   Return (BYT)    }
+
+            //  Test DivideOp with DWORD data
+            Divide (DWRD, 3, DWRD, RMDR)
+            If (LNotEqual (DWRD, 0x12345678))
+                {   Return (DWRD)   }
+            If (LNotEqual (RMDR, 0))
+                {   Return (RMDR)   }
+
+            //  Test DivideOp with WORD data
+            Divide (WRD, 4, WRD, RMDR)
+            If (LNotEqual (WRD, 0x1234))
+                {   Return (WRD)    }
+            If (LNotEqual (RMDR, 0))
+                {   Return (RMDR)   }
+
+            //  Test DivideOp with BYTE data
+            Divide (BYT, 5, BYT, RMDR)
+            If (LNotEqual (BYT, 0x12))
+                {   Return (BYT)    }
+            If (LNotEqual (RMDR, 0))
+                {   Return (RMDR)   }
+
+
+            //  test MultiplyOp with DWORD SystemMemory OpRegion
+            Store (0x01234567, SMDW)
+            Multiply (SMDW, 2, SMDW)
+            If (LNotEqual (SMDW, 0x02468ACE))
+                {   Return (SMDW)   }
+
+            //  test DivideOp with DWORD SystemMemory OpRegion
+            Divide (SMDW, 3, SMDW, RMDR)
+            If (LNotEqual (SMDW, 0x00C22E44))
+                {   Return (SMDW)   }
+            If (LNotEqual (RMDR, 2))
+                {   Return (RMDR)   }
+
+
+            //  test MultiplyOp with WORD SystemMemory OpRegion
+            Store (0x0123, SMWD)
+            Multiply (SMWD, 3, SMWD)
+            If (LNotEqual (SMWD, 0x369))
+                {   Return (SMWD)   }
+
+            //  test DivideOp with WORD SystemMemory OpRegion
+            Divide (SMWD, 2, SMWD, RMDR)
+            If (LNotEqual (SMWD, 0x01B4))
+                {   Return (SMWD)   }
+            If (LNotEqual (RMDR, 1))
+                {   Return (RMDR)   }
+
+
+            //  test MultiplyOp with BYTE SystemMemory OpRegion
+            Store (0x01, SMBY)
+            Multiply (SMBY, 7, SMBY)
+            If (LNotEqual (SMBY, 0x07))
+                {   Return (SMBY)   }
+
+            //  test DivideOp with BYTE SystemMemory OpRegion
+            Divide (SMBY, 4, SMBY, RMDR)
+            If (LNotEqual (SMBY, 0x01))
+                {   Return (SMBY)   }
+            If (LNotEqual (RMDR, 3))
+                {   Return (RMDR)   }
+
+            Return (0)
+        }   //  TEST
+    }   //  MLDV
+
+//
+// test NBitOps.asl
+//
+//NAnd - Bit-wise NAnd
+//NAndTerm  := NAnd(
+//  Source1,    //TermArg=>Integer
+//  Source2 //TermArg=>Integer
+//  Result  //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally
+//stored in Result.
+
+//NOr - Bitwise NOr
+//NOrTerm   := NOr(
+//  Source1,    //TermArg=>Integer
+//  Source2 //TermArg=>Integer
+//  Result  //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally
+//stored in Result.
+// Not - Not
+//NotTerm   := Not(
+//  Source, //TermArg=>Integer
+//  Result  //Nothing | SuperName
+//) => Integer
+//Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in
+//Result.
+
+//If the Control method is success Zero is returned else a non-zero number is returned
+
+    Device (NBIT)
+    {//NBIT
+
+        //Create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,  //  8-bit BYTE
+        }// Field(RAM)
+
+
+        //And with Byte Data
+        Name (BYT1, 0xff)
+        Name (BYT2, 0xff)
+        Name (BRSL, 0x00)
+
+        //And with Word Data
+        Name (WRD1, 0xffff)
+        Name (WRD2, 0xffff)
+        Name (WRSL, 0x0000)
+
+        //And with DWord Data
+        Name (DWD1, 0xffffffff)
+        Name (DWD2, 0xffffffff)
+        Name (DRSL, 0x00000000)
+        Name(RSLT,1)
+
+
+        Name(ARSL,0x00)
+        Name(LRSL,0x00)
+
+        Method(NNDB,2)
+        {//NNDB
+
+            Store(0xffffffff,SMDW)
+            Store(0xffff,SMWD)
+            Store(0xff,SMBY)
+
+
+            NAnd(Arg0,Arg1,ARSL)
+            if(LNotEqual(ARSL,0xfffffffd))
+             {Return(11)}
+
+             Store(Arg0,local0)
+             Store(Arg1,Local1)
+
+             NAnd(Local0,Local1,LRSL)
+                if(LNotEqual(LRSL,0xfffffffd))
+             {Return(12)}
+
+
+            //Byte data
+            NAnd(BYT1,BYT2,BRSL)
+            if(LNotEqual(BRSL,0xffffff00))
+             {Return(13)}
+
+            //Word Data
+             NAnd(WRD1,WRD2,WRSL)
+            if(LNotEqual(WRSL,0xffff0000))
+             {Return(14)}
+
+             //DWord Data
+             NAnd(DWD1,DWD2,DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+             {Return(15)}
+
+             //Byte data
+            NAnd(SMBY,0xff,BRSL)
+            if(LNotEqual(BRSL,0xffffff00))
+             {Return(16)}
+
+            //Word Data
+             NAnd(SMWD,0xffff,WRSL)
+            if(LNotEqual(WRSL,0xffff0000))
+             {Return(17)}
+
+             //DWord Data
+             NAnd(SMDW,0xffffffff,DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+             {Return(18)}
+
+            Return(0)
+
+        }//NNDB
+
+        Method(NNOR,2)
+        {//NNOR
+
+            NOr(Arg0,Arg1,ARSL)
+            if(LNotEqual(ARSL,0xfffffffd))
+             {Return(21)}
+
+            Store(Arg0,local0)
+            Store(Arg1,Local1)
+
+            NOr(Local0,Local1,LRSL)
+            if(LNotEqual(LRSL,0xfffffffd))
+             {Return(22)}
+
+
+            //Byte data
+            NOr(BYT1,BYT2,BRSL)
+            if(LNotEqual(BRSL,0xffffff00))
+             {Return(23)}
+
+            //Word Data
+            NOr(WRD1,WRD2,WRSL)
+            if(LNotEqual(WRSL,0xffff0000))
+             {Return(24)}
+
+            //DWord Data
+            NOr(DWD1,DWD2,DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+             {Return(25)}
+
+             //System Memory Byte data
+            NOr(SMBY,0xff,BRSL)
+            if(LNotEqual(BRSL,0xffffff00))
+             {Return(26)}
+
+            //System Memory Word Data
+            NOr(SMWD,0xffff,WRSL)
+            if(LNotEqual(WRSL,0xffff0000))
+             {Return(27)}
+
+            //System Memory DWord Data
+            NOr(SMDW,0xffffffff,DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+             {Return(28)}
+
+            Return(0)
+
+        }//NNOR
+
+        Method(NNOT,2)
+        {//NNOT
+
+            Or(Arg0,Arg1,ARSL)
+            Not(ARSL,ARSL)
+            if(LNotEqual(ARSL,0xfffffffd))
+             {Return(31)}
+
+            Store(Arg0,local0)
+            Store(Arg1,Local1)
+
+            Or(Local0,Local1,LRSL)
+            Not(LRSL,LRSL)
+            if(LNotEqual(LRSL,0xfffffffd))
+             {Return(32)}
+
+
+            //Byte data
+            Or(BYT1,BYT2,BRSL)
+            Not(BRSL,BRSL)
+            if(LNotEqual(BRSL,0xffffff00))
+             {Return(33)}
+
+            //Word Data
+            Or(WRD1,WRD2,WRSL)
+            Not(WRSL,WRSL)
+            if(LNotEqual(WRSL,0xffff0000))
+             {Return(34)}
+
+            //DWord Data
+            Or(DWD1,DWD2,DRSL)
+            Not(DRSL,DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+             {Return(35)}
+
+             //System Memory Byte data
+            Or(SMBY,0xff,BRSL)
+            Not(BRSL,BRSL)
+            if(LNotEqual(BRSL,0xffffff00))
+             {Return(36)}
+
+            //System Memory Word Data
+            Or(SMWD,0xffff,WRSL)
+            Not(WRSL,WRSL)
+            if(LNotEqual(WRSL,0xffff0000))
+             {Return(37)}
+
+            //System Memory DWord Data
+            Or(SMDW,0xffffffff,DRSL)
+            Not(DRSL,DRSL)
+            if(LNotEqual(DRSL,0x00000000))
+             {Return(38)}
+
+            Return(0)
+        }//NNOT
+
+
+        Method(TEST)
+        {
+
+            Store ("++++++++ NBitOps Test", Debug)
+
+            Store(NNDB(2,2),RSLT)
+            if(LNotEqual(RSLT,0))
+                {Return(RSLT)}
+
+            Store(NNOR(2,2),RSLT)
+            if(LNotEqual(RSLT,0))
+                {Return(RSLT)}
+
+            Store(NNOT(2,2),RSLT)
+            if(LNotEqual(RSLT,0))
+                {Return(RSLT)}
+
+
+           Return(0)
+        }
+
+    }//Device NBIT
+
+//
+// test ShftOp.asl
+//
+//ShiftRightTerm    := ShiftRight(
+//  Source, //TermArg=>Integer
+//  ShiftCount  //TermArg=>Integer
+//  Result  //Nothing | SuperName
+//) => Integer
+//Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit
+//zeroed ShiftCount times.  The result is optionally stored into Result.
+
+//ShiftLeft(
+//  Source, //TermArg=>Integer
+//  ShiftCount  //TermArg=>Integer
+//  Result  //Nothing | SuperName
+//) => Integer
+//Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant
+//bit zeroed ShiftCount times. The result is optionally stored into Result.
+
+//If the Control method is success Zero is returned else a non-zero number is returned
+    Device (SHFT)
+    {//SHFT
+
+        //Create System Memory Operation Region and field overlays
+        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {
+            SMDW,   32, //  32-bit DWORD
+            SMWD,   16, //  16-bit WORD
+            SMBY,   8,  //  8-bit BYTE
+        }// Field(RAM)
+
+
+        Name(SHFC,0x00)
+
+        //And with Byte Data
+        Name (BYT1, 0xff)
+        Name (BRSL, 0x00)
+
+        //And with Word Data
+        Name (WRD1, 0xffff)
+        Name (WRSL, 0x0000)
+
+        //And with DWord Data
+        Name (DWD1, 0xffffffff)
+        Name (DRSL, 0x00000000)
+
+        Name(RSLT,1)
+
+        Name(ARSL,0x00)
+        Name(LRSL,0x00)
+
+        Method(SLFT,2)
+        {//SLFT
+
+            Store(0xffffffff,SMDW)
+            Store(0xffff,SMWD)
+            Store(0xff,SMBY)
+
+
+            //Arg0-> 2 & Arg1->2
+            ShiftLeft(Arg0,Arg1,ARSL)
+            if(LNotEqual(ARSL,8))
+            {Return(11)}
+
+             Store(Arg0,local0)
+             Store(Arg1,Local1)
+
+             //Local0->8 and Local1->2
+             ShiftLeft(Local0,Local1,LRSL)
+                if(LNotEqual(LRSL,8))
+             {Return(12)}
+
+            Store(2,SHFC)
+            //Byte data
+            ShiftLeft(BYT1,SHFC,BRSL)
+            if(LNotEqual(BRSL,0x3FC))
+             {Return(13)}
+
+            Store(4,SHFC)
+            //Word Data
+             ShiftLeft(WRD1,SHFC,WRSL)
+            if(LNotEqual(WRSL,0xFFFF0))
+             {Return(14)}
+
+            Store(8,SHFC)
+            //DWord Data
+            ShiftLeft(DWD1,SHFC,DRSL)
+            if(LNotEqual(DRSL,0xFFFFFF00))
+             {Return(15)}
+
+
+             //System Memory Byte data
+            Store(4,SHFC)
+            ShiftLeft(SMBY,SHFC,BRSL)
+            if(LNotEqual(BRSL,0xFF0))
+            {Return(16)}
+
+            //Word Data
+            Store(4,SHFC)
+            ShiftLeft(SMWD,SHFC,WRSL)
+            if(LNotEqual(WRSL,0xffff0))
+             {Return(17)}
+
+            //DWord Data
+            Store(8,SHFC)
+            ShiftLeft(SMDW,SHFC,DRSL)
+            if(LNotEqual(DRSL,0xFFFFFF00))
+                {Return(18)}
+
+            Return(0)
+
+        }//SLFT
+
+        Method(SRGT,2)
+        {//SRGT
+            //And with Byte Data
+            Store (0xff,BYT1)
+            Store (0x00,BRSL)
+
+            //And with Word Data
+            Store (0xffff,WRD1)
+            Store (0x0000,WRSL)
+
+            //And with DWord Data
+            Store(0xffffffff,DWD1)
+            Store (0x00000000,DRSL)
+
+            //Reinitialize the result objects
+            Store(0x00,ARSL)
+            Store(0x00,LRSL)
+
+            Store(0xffffffff,SMDW)
+            Store(0xffff,SMWD)
+            Store(0xff,SMBY)
+
+            //Arg0-> 2 & Arg1->2
+            ShiftRight(Arg0,Arg1,ARSL)
+            if(LNotEqual(ARSL,0))
+            {Return(21)}
+
+             Store(Arg0,local0)
+             Store(Arg1,Local1)
+
+             //Local0->8 and Local1->2
+             ShiftRight(Local0,Local1,LRSL)
+                if(LNotEqual(LRSL,0))
+             {Return(22)}
+
+            Store(2,SHFC)
+            //Byte data
+            ShiftRight(BYT1,SHFC,BRSL)
+            if(LNotEqual(BRSL,0x3F))
+             {Return(23)}
+
+            Store(4,SHFC)
+            //Word Data
+             ShiftRight(WRD1,SHFC,WRSL)
+            if(LNotEqual(WRSL,0xFFF))
+             {Return(24)}
+
+            Store(8,SHFC)
+            //DWord Data
+            ShiftRight(DWD1,SHFC,DRSL)
+            if(LNotEqual(DRSL,0xFFFFFF))
+             {Return(25)}
+
+            //System Memory Byte data
+            Store(4,SHFC)
+            ShiftRight(SMBY,SHFC,BRSL)
+            if(LNotEqual(BRSL,0xF))
+            {Return(26)}
+
+            //Word Data
+            Store(4,SHFC)
+            ShiftRight(SMWD,SHFC,WRSL)
+            if(LNotEqual(WRSL,0xFFF))
+             {Return(27)}
+
+            //DWord Data
+            Store(8,SHFC)
+            ShiftRight(SMDW,SHFC,DRSL)
+            if(LNotEqual(DRSL,0xFFFFFF))
+                {Return(28)}
+
+            Return(0)
+        }//SRGT
+
+        //Test method called from amlexec
+        Method(TEST)
+        {
+            Store ("++++++++ ShftOp Test", Debug)
+
+            Store(SLFT(2,2),RSLT)
+            if(LNotEqual(RSLT,0))
+                {Return(RSLT)}
+            Store(SRGT(2,2),RSLT)
+            if(LNotEqual(RSLT,0))
+                {Return(RSLT)}
+           Return(0)
+        }
+
+    }//Device SHFT
+
+//
+// test Xor.asl and slightly modified
+//
+//This code tests the XOR opcode term
+//Syntax of XOR term
+//          XOr(
+//                  Source1  //TermArg=>BufferTerm
+//                  Source2  //TermArg=>Integer
+//                  Result //NameString
+//              )
+//"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in
+// Result
+    Device (XORD)
+    {
+        //This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD
+        Method (TEST)
+        {
+            Store ("++++++++ Xor Test", Debug)
+
+            //Overlay in system memory
+            OperationRegion (RAM, SystemMemory, 0x800000, 256)
+            Field (RAM, ByteAcc, NoLock, Preserve)
+            {
+                RES1,   1,  //Offset
+                BYT1,   8,  //First BYTE
+                BYT2,   8,  //Second BYTE
+                RBYT,   8,  //Result Byte
+                RES2,   1,  //Offset
+                WRD1,   16, //First WORD field
+                WRD2,   16, //Second WORD field
+                RWRD,   16, //RSLT WORD field
+                RES3,   1,  //Offset
+                DWD1,   32, //First Dword
+                DWD2,   32, //Second Dword
+                RDWD,   32, //Result Dword
+                RES4,   1,  //Offset
+            }
+
+            // Store bits in the single bit fields for checking
+            //  at the end
+            Store(1, RES1)
+            Store(1, RES2)
+            Store(1, RES3)
+            Store(1, RES4)
+
+            // Check the stored single bits
+            if(LNotEqual(RES1, 1))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES2, 1))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES3, 1))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES4, 1))
+            {
+                Return(1)
+            }
+
+            //************************************************
+            // (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition
+            Store(0x00,BYT1)
+            Store(0x00,BYT2)
+            XOr(BYT1,BYT2,Local0)
+            Store (Local0, RBYT)
+            if(LNotEqual(RBYT,0))
+            {   Return(1)}
+
+            // (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition
+            Store(0xff,BYT1)
+            Store(0xff,BYT2)
+            XOr(BYT1,BYT2,Local0)
+            Store (Local0, RBYT)
+            if(LNotEqual(RBYT,0))
+            {   Return(1)}
+
+            // (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition
+            Store(0x55,BYT1)
+            Store(0xAA,BYT2)
+            XOr(BYT1,BYT2,Local0)
+            Store (Local0, RBYT)
+            if(LNotEqual(RBYT,0xFF))
+            {   Return(1)}
+
+            //(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition
+            Store(0xAA,BYT1)
+            Store(0x55,BYT2)
+            XOr(BYT1,BYT2,Local0)
+            Store (Local0, RBYT)
+            if(LNotEqual(RBYT,0xFF))
+            {   Return(1)}
+
+            Store(0x12,BYT1)
+            Store(0xED,BYT2)
+
+            XOr(BYT1,BYT2,Local0)
+            Store (Local0, RBYT)
+            if(LNotEqual(RBYT,0xFF))
+            {
+                Return(1)
+            }
+
+            // Store known values for checking later
+            Store(0x12, BYT1)
+            if(LNotEqual(BYT1, 0x12))
+            {
+                Return(1)
+            }
+
+            Store(0xFE, BYT2)
+            if(LNotEqual(BYT2, 0xFE))
+            {
+                Return(1)
+            }
+
+            Store(0xAB, RBYT)
+            if(LNotEqual(RBYT, 0xAB))
+            {
+                Return(1)
+            }
+
+            //***********************************************
+            // (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition
+            Store(0x0000,WRD1)
+            Store(0x0000,WRD2)
+            XOr(WRD1,WRD2,RWRD)
+            if(LNotEqual(RWRD,0))
+            {   Return(1)}
+
+            // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition
+            Store(0xffff,WRD1)
+            Store(0xffff,WRD2)
+            XOr(WRD1,WRD2,RWRD)
+            if(LNotEqual(RWRD,0))
+            {   Return(1)}
+
+            // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition
+            Store(0x5555,WRD1)
+            Store(0xAAAA,WRD2)
+            XOr(WRD1,WRD2,RWRD)
+            if(LNotEqual(RWRD,0xFFFF))
+            {   Return(1)}
+
+            //(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition
+            Store(0xAAAA,WRD1)
+            Store(0x5555,WRD2)
+            XOr(WRD1,WRD2,RWRD)
+            if(LNotEqual(RWRD,0xFFFF))
+            {   Return(1)}
+
+            Store(0x1234,WRD1)
+            Store(0xEDCB,WRD2)
+            XOr(WRD1,WRD2,RWRD)
+            if(LNotEqual(RWRD,0xFFFF))
+            {   Return(1)}
+
+            // Store known values for checking later
+            Store(0x1234, WRD1)
+            if(LNotEqual(WRD1, 0x1234))
+            {
+                Return(1)
+            }
+
+            Store(0xFEDC, WRD2)
+            if(LNotEqual(WRD2, 0xFEDC))
+            {
+                Return(1)
+            }
+
+            Store(0x87AB, RWRD)
+            if(LNotEqual(RWRD, 0x87AB))
+            {
+                Return(1)
+            }
+
+
+            //**************************************************
+            // (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition
+            Store(0x00000000,DWD1)
+            Store(0x00000000,DWD2)
+            XOr(DWD1,DWD2,RDWD)
+            if(LNotEqual(RDWD,0))
+            {   Return(1)}
+
+            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition
+            Store(0xffffffff,DWD1)
+            Store(0xffffffff,DWD2)
+            XOr(DWD1,DWD2,RDWD)
+            if(LNotEqual(RDWD,0))
+            {   Return(1)}
+
+            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
+            Store(0x55555555,DWD1)
+            Store(0xAAAAAAAA,DWD2)
+            XOr(DWD1,DWD2,RDWD)
+            if(LNotEqual(RDWD,0xFFFFFFFF))
+            {   Return(1)}
+
+            //(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition
+            Store(0xAAAAAAAA,DWD1)
+            Store(0x55555555,DWD2)
+            XOr(DWD1,DWD2,RDWD)
+            if(LNotEqual(RDWD,0xFFFFFFFF))
+            {   Return(1)}
+
+            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
+            Store(0x12345678,DWD1)
+            Store(0xEDCBA987,DWD2)
+            XOr(DWD1,DWD2,RDWD)
+            if(LNotEqual(RDWD,0xFFFFFFFF))
+            {   Return(1)}
+
+            Store(0x12345678,DWD1)
+            if(LNotEqual(DWD1,0x12345678))
+            {
+                Return(1)
+            }
+
+            Store(0xFEDCBA98,DWD2)
+            if(LNotEqual(DWD2,0xFEDCBA98))
+            {
+                Return(1)
+            }
+
+            Store(0x91827364,RDWD)
+            if(LNotEqual(RDWD,0x91827364))
+            {
+                Return(1)
+            }
+
+            //****************************************************
+            // Check the stored single bits
+            if(LNotEqual(RES1, 1))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES2, 1))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES3, 1))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES4, 1))
+            {
+                Return(1)
+            }
+
+            // Change all of the single bit fields to zero
+            Store(0, RES1)
+            Store(0, RES2)
+            Store(0, RES3)
+            Store(0, RES4)
+
+            // Now, check all of the fields
+
+            // Byte
+            if(LNotEqual(BYT1, 0x12))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(BYT2, 0xFE))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RBYT, 0xAB))
+            {
+                Return(1)
+            }
+
+            // Word
+            if(LNotEqual(WRD1, 0x1234))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(WRD2, 0xFEDC))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RWRD, 0x87AB))
+            {
+                Return(1)
+            }
+
+            // Dword
+            if(LNotEqual(DWD1, 0x12345678))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(DWD2, 0xFEDCBA98))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RDWD, 0x91827364))
+            {
+                Return(1)
+            }
+
+            // Bits
+            if(LNotEqual(RES1, 0))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES2, 0))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES3, 0))
+            {
+                Return(1)
+            }
+
+            if(LNotEqual(RES4, 0))
+            {
+                Return(1)
+            }
+
+
+            Return(0)
+        }   //  TEST
+    }   //  XORD
+
+//
+// test CrBytFld.asl
+//
+//  CrBytFld test
+//      Test for CreateByteField.
+//      Tests creating byte field overlay of buffer stored in Local0.
+//      Tests need to be added for Arg0 and Name buffers.
+//
+    Device (CRBF)
+    {   //  Test device name
+        Method (TEST)
+        {
+            Store ("++++++++ CrBytFld Test", Debug)
+
+            //  Local0 is unitialized buffer with 4 elements
+            Store (Buffer (4) {}, Local0)
+
+            //  create Byte Field named BF0 based on Local0 element 0
+            CreateByteField (Local0, 0, BF0)
+
+            //  validate CreateByteField did not alter Local0
+            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
+            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
+                {   Return (2)  }
+
+            //  store something into BF0
+            Store (1, BF0)
+
+            //  validate Store did not alter Local0 object type
+            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
+            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
+                {   Return (3)  }
+
+            //  verify that the Store into BF0 was successful
+            If (LNotEqual (BF0, 1))
+                {   Return (4)  }
+
+
+            //  create Byte Field named BF1 based on Local0 element 1
+            CreateByteField (Local0, 1, BF1)
+
+            //  validate CreateByteField did not alter Local0
+            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
+            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
+                {   Return (10) }
+
+            //  store something into BF1
+            Store (5, BF1)
+
+            //  validate Store did not alter Local0 object type
+            Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
+            If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
+                {   Return (11) }
+
+            //  verify that the Store into BF1 was successful
+            If (LNotEqual (BF1, 5))
+                {   Return (12) }
+
+            //  verify that the Store into BF1 did not alter BF0
+            If (LNotEqual (BF0, 1))
+                {   Return (13) }
+
+
+            //  store something into BF0
+            Store (0xFFFF, BF0)
+
+            //  verify that the Store into BF0 was successful
+            If (LNotEqual (BF0, 0xFF))
+                {   Return (20) }
+
+            //  verify that the Store into BF0 did not alter BF1
+            If (LNotEqual (BF1, 5))
+                {   Return (21) }
+
+
+            Return (0)
+        }   //  TEST
+    }   //  CRBF
+
+//
+// test IndexOp4.asl
+//
+//  IndexOp4 test
+//      This is just a subset of the many RegionOp/Index Field test cases.
+//      Tests access of index fields smaller than 8 bits.
+//
+    Device (IDX4)
+    {   //  Test device name
+
+        //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
+        //          Tests OperationRegion memory access using misaligned BYTE,
+        //          WORD, and DWORD field element accesses. Validation is performed
+        //          using both misaligned field entries and aligned field entries.
+        //
+        //          MADM returns 0 if all test cases pass or non-zero identifying
+        //          the failing test case for debug purposes. This non-zero numbers
+        //          are not guaranteed to be in perfect sequence (i.e., test case
+        //          index), but are guaranteed to be unique so the failing test
+        //          case can be uniquely identified.
+        //
+        Method (MADM, 1)    //  Misaligned Dynamic RAM SystemMemory OperationRegion
+        //  Arg0    --  SystemMemory OperationRegion base address
+        {   //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
+            OperationRegion (RAM, SystemMemory, Arg0, 0x100)
+            Field (RAM, DwordAcc, NoLock, Preserve)
+            {   //  aligned field definition (for verification)
+                DWD0,   32, //  aligned DWORD field
+                DWD1,   32      //  aligned DWORD field
+            }
+            Field (RAM, ByteAcc, NoLock, Preserve)
+            {   //  bit access field definition
+                BIT0,   1,      //  single bit field entry
+                BIT1,   1,      //  single bit field entry
+                BIT2,   1,      //  single bit field entry
+                BIT3,   1,      //  single bit field entry
+                BIT4,   1,      //  single bit field entry
+                BIT5,   1,      //  single bit field entry
+                BIT6,   1,      //  single bit field entry
+                BIT7,   1,      //  single bit field entry
+                BIT8,   1,      //  single bit field entry
+                BIT9,   1,      //  single bit field entry
+                BITA,   1,      //  single bit field entry
+                BITB,   1,      //  single bit field entry
+                BITC,   1,      //  single bit field entry
+                BITD,   1,      //  single bit field entry
+                BITE,   1,      //  single bit field entry
+                BITF,   1,      //  single bit field entry
+                BI10,   1,      //  single bit field entry
+                BI11,   1,      //  single bit field entry
+                BI12,   1,      //  single bit field entry
+                BI13,   1,      //  single bit field entry
+                BI14,   1,      //  single bit field entry
+                BI15,   1,      //  single bit field entry
+                BI16,   1,      //  single bit field entry
+                BI17,   1,      //  single bit field entry
+                BI18,   1,      //  single bit field entry
+                BI19,   1,      //  single bit field entry
+                BI1A,   1,      //  single bit field entry
+                BI1B,   1,      //  single bit field entry
+                BI1C,   1,      //  single bit field entry
+                BI1D,   1,      //  single bit field entry
+                BI1E,   1,      //  single bit field entry
+                BI1F,   1       //  single bit field entry
+            }   //  bit access field definition
+
+            Field (RAM, ByteAcc, NoLock, Preserve)
+            {   //  two-bit access field definition
+                B2_0,   2,      //  single bit field entry
+                B2_1,   2,      //  single bit field entry
+                B2_2,   2,      //  single bit field entry
+                B2_3,   2,      //  single bit field entry
+                B2_4,   2,      //  single bit field entry
+                B2_5,   2,      //  single bit field entry
+                B2_6,   2,      //  single bit field entry
+                B2_7,   2,      //  single bit field entry
+                B2_8,   2,      //  single bit field entry
+                B2_9,   2,      //  single bit field entry
+                B2_A,   2,      //  single bit field entry
+                B2_B,   2,      //  single bit field entry
+                B2_C,   2,      //  single bit field entry
+                B2_D,   2,      //  single bit field entry
+                B2_E,   2,      //  single bit field entry
+                B2_F,   2       //  single bit field entry
+            }   //  bit access field definition
+
+            //  initialize memory contents using aligned field entries
+            Store (0x5AA55AA5, DWD0)
+            Store (0x5AA55AA5, DWD1)
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BIT0)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT0, 0))
+                    {   Return (1)  }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55AA4))
+                    {   Return (2)  }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BIT1)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT1, 1))
+                    {   Return (3)  }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55AA6))
+                    {   Return (4)  }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BIT2)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT2, 0))
+                    {   Return (5)  }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55AA2))
+                    {   Return (6)  }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BIT3)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT3, 1))
+                    {   Return (7)  }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55AAA))
+                    {   Return (8)  }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BIT4)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT4, 1))
+                    {   Return (9)  }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55ABA))
+                    {   Return (10) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BIT5)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT5, 0))
+                    {   Return (11) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55A9A))
+                    {   Return (12) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BIT6)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT6, 1))
+                    {   Return (13) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55ADA))
+                    {   Return (14) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BIT7)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT7, 0))
+                    {   Return (15) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55A5A))
+                    {   Return (16) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BIT8)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT8, 1))
+                    {   Return (17) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55B5A))
+                    {   Return (18) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BIT9)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BIT9, 0))
+                    {   Return (19) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA5595A))
+                    {   Return (20) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BITA)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BITA, 1))
+                    {   Return (21) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA55D5A))
+                    {   Return (22) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BITB)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BITB, 0))
+                    {   Return (23) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA5555A))
+                    {   Return (24) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BITC)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BITC, 0))
+                    {   Return (25) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA5455A))
+                    {   Return (26) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BITD)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BITD, 1))
+                    {   Return (27) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA5655A))
+                    {   Return (28) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BITE)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BITE, 0))
+                    {   Return (29) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA5255A))
+                    {   Return (30) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BITF)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BITF, 1))
+                    {   Return (31) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA5A55A))
+                    {   Return (32) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI10)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI10, 0))
+                    {   Return (33) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA4A55A))
+                    {   Return (34) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI11)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI11, 1))
+                    {   Return (35) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA6A55A))
+                    {   Return (36) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI12)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI12, 0))
+                    {   Return (37) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AA2A55A))
+                    {   Return (38) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI13)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI13, 1))
+                    {   Return (39) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5AAAA55A))
+                    {   Return (40) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI14)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI14, 1))
+                    {   Return (41) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5ABAA55A))
+                    {   Return (42) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI15)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI15, 0))
+                    {   Return (43) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5A9AA55A))
+                    {   Return (44) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI16)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI16, 1))
+                    {   Return (45) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5ADAA55A))
+                    {   Return (46) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI17)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI17, 0))
+                    {   Return (47) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5A5AA55A))
+                    {   Return (48) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI18)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI18, 1))
+                    {   Return (49) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5B5AA55A))
+                    {   Return (50) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI19)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI19, 0))
+                    {   Return (51) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x595AA55A))
+                    {   Return (52) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI1A)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI1A, 1))
+                    {   Return (53) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x5D5AA55A))
+                    {   Return (54) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI1B)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI1B, 0))
+                    {   Return (55) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x555AA55A))
+                    {   Return (56) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI1C)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI1C, 0))
+                    {   Return (57) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x455AA55A))
+                    {   Return (58) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI1D)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI1D, 1))
+                    {   Return (59) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x655AA55A))
+                    {   Return (60) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, BI1E)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI1E, 0))
+                    {   Return (61) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x255AA55A))
+                    {   Return (62) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, BI1F)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (BI1F, 1))
+                    {   Return (63) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55AA55A))
+                    {   Return (64) }
+
+
+            //  set memory contents to known values using misaligned field entries
+            Store (3, B2_0)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_0, 3))
+                    {   Return (65) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55AA55B))
+                    {   Return (66) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, B2_1)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_1, 1))
+                    {   Return (67) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55AA557))
+                    {   Return (68) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, B2_2)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_2, 0))
+                    {   Return (69) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55AA547))
+                    {   Return (70) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (3, B2_3)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_3, 3))
+                    {   Return (71) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55AA5C7))
+                    {   Return (72) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (3, B2_4)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_4, 3))
+                    {   Return (73) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55AA7C7))
+                    {   Return (74) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, B2_5)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_5, 0))
+                    {   Return (75) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55AA3C7))
+                    {   Return (76) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, B2_6)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_6, 1))
+                    {   Return (77) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55A93C7))
+                    {   Return (78) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, B2_7)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_7, 1))
+                    {   Return (79) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55A53C7))
+                    {   Return (80) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, B2_8)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_8, 0))
+                    {   Return (81) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55853C7))
+                    {   Return (82) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, B2_9)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_9, 1))
+                    {   Return (83) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA55453C7))
+                    {   Return (84) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (2, B2_A)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_A, 2))
+                    {   Return (85) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA56453C7))
+                    {   Return (86) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (2, B2_B)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_B, 2))
+                    {   Return (87) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA5A453C7))
+                    {   Return (88) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (3, B2_C)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_C, 3))
+                    {   Return (89) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xA7A453C7))
+                    {   Return (90) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (3, B2_D)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_D, 3))
+                    {   Return (91) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0xAFA453C7))
+                    {   Return (92) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (1, B2_E)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_E, 1))
+                    {   Return (93) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x9FA453C7))
+                    {   Return (94) }
+
+            //  set memory contents to known values using misaligned field entries
+            Store (0, B2_F)
+                //  verify memory contents using misaligned field entries
+                If (LNotEqual (B2_F, 0))
+                    {   Return (95) }
+                //  verify memory contents using aligned field entries
+                If (LNotEqual (DWD0, 0x1FA453C7))
+                    {   Return (96) }
+
+
+            Return (0)  //  pass
+        }   //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
+
+        Method (TEST)
+        {
+            Store ("++++++++ IndexOp4 Test", Debug)
+
+            //  MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments:
+            //      Arg0    --  SystemMemory OperationRegion base address
+            Store (MADM (0x800000), Local0)
+            If (LNotEqual (Local0, 0))      //  MADM returns zero if successful
+                {   Return (Local0) }       //  failure:    return MADM error code
+
+            Return (Local0)
+        }   //  TEST
+    }   //  IDX4
+
+//
+// test Event.asl
+//
+//  EventOp, ResetOp, SignalOp, and WaitOp test cases.
+//
+    Device (EVNT)
+    {
+        Event (EVNT)    //  event synchronization object
+
+        Method (TEVN, 1)
+        //  Arg0:   time to Wait for event in milliseconds
+        {   //  TEVN control method to test ResetOp, SignalOp, and WaitOp
+            //  reset EVNT to initialization (zero) state
+            Reset (EVNT)
+
+            //  prime EVNT with two outstanding signals
+            Signal (EVNT)
+            Signal (EVNT)
+
+
+            //  acquire existing signal
+            Store (Wait (EVNT, Arg0), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x21)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LNotEqual (Local0, 0))  //  Number is type 1
+                {   Return (0x22)   }       //  timeout occurred without acquiring signal
+
+            Store ("Acquire 1st existing signal PASS", Debug)
+
+
+            //  acquire existing signal
+            Store (Wait (EVNT, Arg0), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x31)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LNotEqual (Local0, 0))  //  Number is type 1
+                {   Return (0x32)   }       //  timeout occurred without acquiring signal
+
+            Store ("Acquire 2nd existing signal PASS", Debug)
+
+
+            //  ensure WaitOp timeout test cases do not hang
+            if (LEqual (Arg0, 0xFFFF))
+                {   Store (0xFFFE, Arg0)    }
+
+            //  acquire non-existing signal
+            Store (Wait (EVNT, Arg0), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x41)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LEqual (Local0, 0))     //  Number is type 1
+                {   Return (0x42)   }       //  non-existant signal was acquired
+
+            Store ("Acquire signal timeout PASS", Debug)
+
+
+            //  prime EVNT with two outstanding signals
+            Signal (EVNT)
+            Signal (EVNT)
+
+            //  reset EVNT to initialization (zero) state
+            Reset (EVNT)
+
+            //  acquire non-existing signal
+            Store (Wait (EVNT, Arg0), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x51)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LEqual (Local0, 0))     //  Number is type 1
+                {   Return (0x52)   }       //  non-existant signal was acquired
+
+            Store ("Reset signal PASS", Debug)
+
+
+            //  acquire non-existing signal using Lvalue timeout
+            Store (Wait (EVNT, Zero), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x61)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LEqual (Local0, 0))     //  Number is type 1
+                {   Return (0x62)   }       //  non-existant signal was acquired
+
+            Store ("Zero Lvalue PASS", Debug)
+
+
+            //  acquire non-existing signal using Lvalue timeout
+            Store (Wait (EVNT, One), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x71)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LEqual (Local0, 0))     //  Number is type 1
+                {   Return (0x72)   }       //  non-existant signal was acquired
+
+            Store ("One Lvalue PASS", Debug)
+
+            //  Lvalue Event test cases
+    // ILLEGAL SOURCE OPERAND        Store (EVNT, Local2)
+
+            //  validate Local2 is an Event
+            Store (ObjectType (EVNT), Local1)
+            If (LNotEqual (Local1, 7))  //  Event is type 7
+                {   Return (0x81)   }       //  Local1 indicates Local0 is not a Number
+
+            //  reset EVNT to initialization (zero) state
+            Reset (EVNT)
+
+            //  prime EVNT with two outstanding signals
+            Signal (EVNT)
+
+            //  acquire existing signal
+            Store (Wait (EVNT, Arg0), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x82)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LNotEqual (Local0, 0))  //  Number is type 1
+                {   Return (0x83)   }       //  timeout occurred without acquiring signal
+
+            Store ("Acquire Lvalue existing signal PASS", Debug)
+
+
+            //  acquire non-existing signal
+            Store (Wait (EVNT, Arg0), Local0)
+
+            //  validate Local0 is a Number
+            Store (ObjectType (Local0), Local1)
+            If (LNotEqual (Local1, 1))  //  Number is type 1
+                {   Return (0x84)   }       //  Local1 indicates Local0 is not a Number
+
+            If (LEqual (Local0, 0))     //  Number is type 1
+                {   Return (0x85)   }       //  non-existant signal was acquired
+
+            Store ("Acquire Lvalue signal timeout PASS", Debug)
+
+
+            Return (0)  //  success
+        }   //  TEVN control method to test ResetOp, SignalOp, and WaitOp
+
+        Method (TEST)
+        {
+            Store ("++++++++ Event Test", Debug)
+
+            Store (TEVN (100), Local0)
+
+            Return (Local0)
+        }   //  TEST
+    }   //  EVNT
+
+//
+// test SizeOfLv.asl
+//
+//  Test for SizeOf (Lvalue)
+//
+//  This next section will contain the packages that the SizeOfOp will be
+//  exercised on.  The first one, PKG0, is a regular package of 3 elements.
+//  The 2nd one, PKG1, is a nested package with 3 packages inside it, each
+//  with 3 elements.  It is expected that SizeOf operator will return the
+//  same value for these two packages since they both have 3 elements.  The
+//  final package, PKG2, has 4 elements and the SizeOf operator is expected
+//  to return different results for this package.
+
+    Name (PKG0,
+        Package (3)
+        {0x0123, 0x4567, 0x89AB}
+    )   //  PKG0
+
+    Name (PKG1,
+        Package (3)
+        {
+            Package (3) {0x0123, 0x4567, 0x89AB},
+            Package (3) {0xCDEF, 0xFEDC, 0xBA98},
+            Package (3) {0x7654, 0x3210, 0x1234}
+        }
+    )   //  PKG1
+
+    Name (PKG2,
+        Package (4)
+        {0x0123, 0x4567, 0x89AB, 0x8888}
+    )   //  PKG2
+
+    Name (PKG3,
+        Package (5)
+        {0x0123, 0x4567, 0x89AB, 0x8888, 0x7777}
+    )   //  PKG3
+
+//  End Packages    **********************************************************
+
+//  The following section will declare the data strings that will be used to
+//  exercise the SizeOf operator.  STR0 and STR1 are expected to be equal,
+//  STR2 is expected to have a different SizeOf value than STR0 and STR1.
+
+    Name (STR0, "ACPI permits very flexible methods of expressing a system")
+
+    Name (STR1, "MIKE permits very flexible methods of expressing a system")
+
+    Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
+
+//  This string is being made in case we want to do a SizeOf comparison
+//  between strings and packages or buffers
+    Name (STR3, "12345")
+
+//  End Strings     **********************************************************
+
+//  The following section will declare the buffers that will be used to exercise
+//  the SizeOf operator.
+
+    Name (BUF0, Buffer (10) {})
+    Name (BUF1, Buffer (10) {})
+    Name (BUF2, Buffer (8)  {})
+    Name (BUF3, Buffer (5)  {})
+
+//  End Buffers     **********************************************************
+    Device (SZLV)
+    {
+
+        Method (CMPR, 2)
+        {
+            //  CMPR is passed two arguments.  If unequal, return 1 to indicate
+            //  that, otherwise return 0 to indicate SizeOf each is equal.
+
+            Store (0x01, Local0)
+
+            if (LEqual (SizeOf(Arg0), SizeOf(Arg1)))
+            {
+                Store (0x00, Local0)
+            }
+
+            return (Local0)
+        }   //  CMPR
+
+
+        Method (TEST)
+        {
+
+            Store ("++++++++ SizeOfLv Test", Debug)
+
+            //  TBD:    SizeOf ("string")
+            //          SizeOf (Buffer)
+            //          SizeOf (Package)
+            //          SizeOf (String)
+            //          SizeOf (STR0)   --  where Name (STR0,...) -- lot's of cases
+            //              buffer, string, package,
+            //          SizeOf (METH) -- where METH control method returns
+            //              buffer, string, package,
+
+            //  TBD:    SLOC [SizeOf (Local0)] -- dup SARG
+
+            //  Compare the elements that we expect to be the same.  Exit out with an error
+            //  code on the first failure.
+            if (LNotEqual (0x00, CMPR (STR0, STR1)))
+            {
+                Return (0x01)
+            }
+
+            if (LNotEqual (0x00, CMPR (STR3, BUF3)))
+            {
+                Return (0x02)
+            }
+
+            if (LNotEqual (0x00, CMPR (STR3, PKG3)))
+            {
+                Return (0x03)
+            }
+
+            //  In the following section, this test will cover the SizeOf
+            //  operator for Local values.
+            //  In this case, both Local0 and Local1 should have the same Size
+            Store (STR0, Local0)
+            Store (STR1, Local1)
+
+            if (LNotEqual (SizeOf (Local0), SizeOf (Local1)))
+            {
+                Return (0x04)
+            }
+
+            //  Now create a case where Local0 and Local1 are different
+            Store (STR2, Local1)
+
+            if (LEqual (SizeOf (Local0), SizeOf (Local1)))
+            {
+                Return (0x05)
+            }
+
+            //  Finally, check for the return of SizeOf for a known Buffer.  Just
+            //  in case we magically pass above cases due to all Buffers being Zero
+            //  bytes in size, or Infinity, etc.
+            if (LNotEqual (0x05, SizeOf (BUF3)))
+            {
+                Return (0x06)
+            }
+
+            Return (0)
+        }   //  TEST
+    }   //  SZLV
+
+
+//
+// test BytField.asl
+//
+//  BytField test
+//      This is just a subset of the many RegionOp/Index Field test cases.
+//      Tests access of TBD.
+//
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+        Device (BYTF)
+        {   //  Test device name
+            Method (TEST)
+            {
+                Store ("++++++++ BytField Test", Debug)
+
+                Return (\_TZ.C19B.RSLT)
+            }   //  TEST
+        }   //  BYTF
+
+        Device (C005)
+        {   //  Device C005
+            Device (C013)
+            {   //  Device C013
+            }   //  Device C013
+        }   //  Device C005
+
+        Method (C115)
+        {   //  C115 control method
+            Acquire (\_GL, 0xFFFF)
+            Store (\_SB.C005.C013.C058.C07E, Local0)
+            Release (\_GL)
+            And (Local0, 16, Local0)
+            Store (ShiftRight (Local0, 4, ), Local1)
+            If (LEqual (Local1, 0))
+                {   Return (1)  }
+            Else
+                {   Return (0)  }
+        }   //  C115 control method
+    }   //  _SB system bus
+
+    OperationRegion (C018, SystemIO, 0x5028, 4)
+    Field (C018, AnyAcc, NoLock, Preserve)
+    {   //  Field overlaying C018
+        C019,   32
+    }   //  Field overlaying C018
+
+    OperationRegion (C01A, SystemIO, 0x5030, 4)
+    Field (C01A, ByteAcc, NoLock, Preserve)
+    {   //  Field overlaying C01A
+        C01B,   8,
+        C01C,   8,
+        C01D,   8,
+        C01E,   8
+    }   //  Field overlaying C01A
+
+    Mutex (\C01F, 0)
+    Name (\C020, 0)
+    Name (\C021, 0)
+
+    Method (\C022, 0)
+    {   //  \C022 control method
+        Acquire (\C01F, 0xFFFF)
+        If (LEqual (\C021, 0))
+        {
+            Store (C019, Local0)
+            And (Local0, 0xFFFEFFFE, Local0)
+            Store (Local0, C019)
+            Increment (\C021)
+        }
+        Release (\C01F)
+    }   //  \C022 control method
+
+    Scope (\_SB.C005.C013)
+    {   //  Scope \_SB.C005.C013
+        Device (C058)
+        {   //  Device C058
+            Name (_HID, "*PNP0A06")
+
+            OperationRegion (C059, SystemIO, 0xE0, 2)
+            Field (C059, ByteAcc, NoLock, Preserve)
+            {   //  Field overlaying C059
+                C05A,   8,
+                C05B,   8
+            }   //  Field overlaying C059
+
+            OperationRegion (C05C, SystemIO, 0xE2, 2)
+            Field (C05C, ByteAcc, NoLock, Preserve)
+            {   //  Field overlaying C05C
+                C05D,   8,
+                C05E,   8
+            }   //  Field overlaying C05C
+            IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
+            {   //  IndexField overlaying C05D/C05E
+                ,       0x410,  //  skip
+                C05F,   8,
+                C060,   8,
+                C061,   8,
+                C062,   8,
+                C063,   8,
+                C064,   8,
+                C065,   8,
+                C066,   8,
+                C067,   8,
+                C068,   8,
+                C069,   8,
+                C06A,   8,
+                C06B,   8,
+                C06C,   8,
+                C06D,   8,
+                C06E,   8,
+                ,       0x70,       //  skip
+                C06F,   8,
+                C070,   8,
+                C071,   8,
+                C072,   8,
+                C073,   8,
+                C074,   8,
+                C075,   8,
+                C076,   8,
+                C077,   8,
+                C078,   8,
+                C079,   8,
+                C07A,   8,
+                C07B,   8,
+                C07C,   8,
+                C07D,   8,
+                C07E,   8
+            }   //  IndexField overlaying C05D/C05E
+
+            OperationRegion (C07F, SystemIO, 0xE4, 2)
+            Field (C07F, ByteAcc, NoLock, Preserve)
+            {   //  Field overlaying C07F
+                C080,   8,
+                C081,   8
+            }   //  Field overlaying C07F
+
+            OperationRegion (C082, SystemIO, 0xE0, 1)
+            Field (C082, ByteAcc, NoLock, Preserve)
+            {   //  Field overlaying C082
+                C083,   8
+            }   //  Field overlaying C082
+
+            OperationRegion (C084, SystemIO, 0xFF, 1)
+            Field (C084, ByteAcc, NoLock, Preserve)
+            {   //  Field overlaying C084
+                C085,   8
+            }   //  Field overlaying C084
+
+            OperationRegion (C086, SystemIO, 0xFD, 1)
+            Field (C086, ByteAcc, NoLock, Preserve)
+            {   //  Field overlaying C086
+                C087,   8
+            }   //  Field overlaying C086
+
+            Mutex (C088, 0)
+            Mutex (C089, 0)
+            Mutex (C08A, 0)
+            Mutex (C08B, 0)
+            Mutex (C08C, 0)
+            Mutex (C08D, 0)
+
+            Name (C08E, 0xFFFFFFFD)
+            Name (C08F, 0)
+
+            Method (C0AA, 4)
+            {   //  C0AA control method
+                Store (Buffer (4) {}, Local7)
+                CreateByteField (Local7, 0, C0AB)
+                CreateByteField (Local7, 1, C0AC)
+                CreateByteField (Local7, 2, C0AD)
+                CreateByteField (Local7, 3, C0AE)
+                Acquire (^C08B, 0xFFFF)
+                Acquire (\_GL, 0xFFFF)
+                \C022 ()
+                Store (1, \_SB.C005.C013.C058.C06B)
+                While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
+                    {   Stall (100) }
+                Store (Arg3, \_SB.C005.C013.C058.C06E)
+                Store (Arg2, \_SB.C005.C013.C058.C06D)
+                Store (Arg1, \_SB.C005.C013.C058.C06C)
+                Store (Arg0, \_SB.C005.C013.C058.C06B)
+                While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
+                    {   Stall (100) }
+                Store (\_SB.C005.C013.C058.C06E, C0AB)
+                Store (\_SB.C005.C013.C058.C06D, C0AC)
+                Store (\_SB.C005.C013.C058.C06C, C0AD)
+                Store (\_SB.C005.C013.C058.C06B, C0AE)
+                If (LNot (LEqual (Arg0, 23)))
+                {
+                    Store (2, \_SB.C005.C013.C058.C06B)
+                    Stall (100)
+                }
+                Release (\_GL)
+                Release (^C08B)
+                Return (Local7)
+            }   //  C0AA control method
+        }   //  Device C058
+    }   //  Scope \_SB.C005.C013
+
+    Scope (\_TZ)
+    {   //  \_TZ thermal zone scope
+        Name (C18B, Package (2)
+        {
+            Package (2)
+            {
+                Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
+                Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
+            },
+            Package (2)
+            {
+                Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
+                Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
+            }
+        })  //  C18B
+
+        Name (C18C, Package (2)
+        {
+            Package (2)
+            {
+                Package (3) {0x64, 0x4B, 0x32},
+                Package (3) {0x64, 0x4B, 0x32}
+            }
+        })  //  C81C
+
+        Name (C18D, 0)
+        Name (C18E, 0)
+        Name (C18F, 0)
+        Name (C190, 0)
+        Name (C191, 3)
+        Name (C192, 0)
+        Name (C193, 1)
+        Name (C194, 2)
+        Mutex (C195, 0)
+        Name (C196, 1)
+        Name (C197, 0x0B9C)
+        Name (C198, 0x0B9C)
+        Name (C199, 0xFFFFFFFD)
+        Name (C19A, 0)
+
+        Device (C19B)
+        {   //  Device C19B
+            Name (RSLT, 0)  //  default to zero
+
+            Method (XINI)
+            {   //  _INI control method (Uses Global Lock -- can't run under AcpiExec)
+                Store (\_SB.C115, C19A)
+                \_TZ.C19C._SCP (0)
+                Subtract (0x0EB2, 0x0AAC, Local1)   //  Local1 = AACh - EB2h
+                Divide (Local1, 10, Local0, Local2) //  Local0 = Local1 / 10
+                                                                //  Local2 = Local1 % 10
+                \_SB.C005.C013.C058.C0AA (14, Local2, 0, 0)
+                Store
+                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D)
+                Store
+                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E)
+                Store
+                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F)
+
+                Store (1, RSLT) //  set RSLT to 1 if _INI control method completes
+            }   //  _INI control method
+
+            //  PowerResource (C19D) {...}
+        }   //  Device C19B
+
+        ThermalZone (C19C)
+        {
+            Method (_SCP, 1)
+            {   //  _SCP control method
+                Store (Arg0, Local0)
+                If (LEqual (Local0, 0))
+                {
+                    Store (0, \_TZ.C192)
+                    Store (1, \_TZ.C193)
+                    Store (2, \_TZ.C194)
+                    Store (3, \_TZ.C191)
+                }
+                Else
+                {
+                    Store (0, \_TZ.C191)
+                    Store (1, \_TZ.C192)
+                    Store (2, \_TZ.C193)
+                    Store (3, \_TZ.C194)
+                }
+            }   //  _SCP control method
+        }   //  ThermalZone C19C
+    }   //  \_TZ thermal zone scope
+
+
+//
+// test DwrdFld.asl
+//
+    Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} )
+
+    Device (DWDF)
+    {
+        Method (TEST)
+        {
+            Store ("++++++++ DwrdFld Test", Debug)
+
+            CreateByteField (BUFR, 0, BYTE)
+            Store (0xAA, BYTE)
+
+            CreateWordField (BUFR, 1, WORD)
+            Store (0xBBCC, WORD)
+
+            CreateDWordField (BUFR, 3, DWRD)
+            Store (0xDDEEFF00, DWRD)
+
+            CreateByteField (BUFR, 7, BYT2)
+            Store (0x11, BYT2)
+
+            CreateWordField (BUFR, 8, WRD2)
+            Store (0x2233, WRD2)
+
+            Return (0)
+
+        }   //  End Method TEST
+    }   //  Device DWDF
+
+    //
+    // test DivAddx.asl
+    //
+    Name (B1LO, 0xAA)
+    Name (B1HI, 0xBB)
+
+    Method (MKW_, 2)
+    {   //  This control method will take two bytes and make them into a WORD
+
+        Multiply (B1HI, 256, Local0)    //  Make high byte.....high
+        Or (Local0, B1LO, Local0)       //  OR in the low byte
+        Return (Local0)                 //  Return the WORD
+
+    }   //  MKW_
+
+    Device (DVAX)
+    {
+        Method (TEST)
+        {
+
+            Store ("++++++++ DivAddx Test", Debug)
+
+            Store (25, B1LO)
+            Store (0, B1HI)
+
+            //  We'll multiply 25 * 3 to get 75, add 99 to it then divide
+            //  by 100.  We expect to get 74 for the remainder and 1 for
+            //  the quotient.
+            Divide(
+                Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63),
+                            //  Dividend,
+                100,        //  Divisor
+                Local4,     //  Remainder
+                Local2)     //  Quotient
+
+            If (LAnd (LEqual (74, Local4), LEqual (1, Local2)))
+            {   //  Indicate Pass
+                Store (0x00, Local0)
+            }
+
+            Else
+            {   //  Indicate Fail
+                Store (0x01, Local0)
+            }
+
+            Return (Local0)
+        }   //  End Method TEST
+    }   //  Device DVAX
+
+//
+// test IndexFld.asl (IndexOp6.asl)
+//
+//  IndexFld test
+//      This is just a subset of the many RegionOp/Index Field test cases.
+//      Tests index field element AccessAs macro.
+//      Also tests name resolution of index field elements with same names
+//      but different namespace scopes.
+//
+    Device (IDX6)
+    {   //  Test device name
+
+        OperationRegion (SIO, SystemIO, 0x100, 2)
+        Field (SIO, ByteAcc, NoLock, Preserve)
+        {
+            INDX,   8,
+            DATA,   8
+        }
+        IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
+        {
+            AccessAs (ByteAcc, 0),
+            IFE0,   8,
+            IFE1,   8,
+            IFE2,   8,
+            IFE3,   8,
+            IFE4,   8,
+            IFE5,   8,
+            IFE6,   8,
+            IFE7,   8,
+            IFE8,   8,
+            IFE9,   8,
+        }
+
+        Device (TST_)
+        {   //  TST_:   provides a different namespace scope for IFE0 and IFE1
+            OperationRegion (SIO2, SystemIO, 0x100, 2)
+            Field (SIO2, ByteAcc, NoLock, Preserve)
+            {
+                IND2,   8,
+                DAT2,   8
+            }
+            IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
+            {
+                IFE0,   8,  //  duplicate IndexField name with different scope
+                IFE1,   8
+            }
+        }   //  TST_:   provides a different namespace scope for IFE0 and IFE1
+
+        Method (TEST)
+        {
+            Store ("++++++++ IndexOp6 Test", Debug)
+
+            Store (IFE0, Local0)
+            Store (IFE1, Local1)
+            Store (IFE2, Local2)
+
+            //  validate name resolution of IndexFields with different scopes
+            Store (\IDX6.IFE0, Local3)
+            Store (\IDX6.IFE1, Local4)
+            //  verioading of namespace can resolve following names
+            Store (\IDX6.TST_.IFE0, Local5)
+            Store (\IDX6.TST_.IFE1, Local6)
+
+            Return (0)
+        }   //  TEST
+    }   //  IDX6
+
+//
+// test IndexOp5.asl
+//
+//  IndexOp5 test
+//      This is just a subset of the many RegionOp/Index Field test cases.
+//      Tests copying string into buffer then performing IndexOp on result.
+//
+    Device (IDX5)
+    {   //  Test device name
+
+        Name (OSFL, 0)  //  0 == Windows 98, 1 == Windows NT
+
+        //  MCTH is a control method to compare two strings. It returns
+        //  zero if the strings mismatch, or 1 if the strings match.
+        //  This exercises the test case of copying a string into a buffer
+        //  and performing an IndexOp on the resulting buffer.
+        Method (MCTH, 2)    //  Control Method to compare two strings
+        {   //  MCTH:   Control Method to compare two strings
+            //  Arg0:       first string to compare
+            //  Arg1:       second string to compare
+            //  Return: zero if strings mismatch, 1 if strings match
+
+            //  check if first string's length is less than second string's length
+            If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
+                {   Return (0)  }
+
+            //  increment length to include NULL termination character
+            Add (SizeOf (Arg0), 1, Local0)  //  Local0 = strlen(Arg0) + 1
+
+            //  create two buffers of size Local0 [strlen(Arg0)+1]
+            Name (BUF0, Buffer (Local0) {})
+            Name (BUF1, Buffer (Local0) {})
+
+            //  copy strings into buffers
+            Store (Arg0, BUF0)
+            Store (Arg1, BUF1)
+
+            //  validate BUF0 and BUF1 are still buffers
+            Store (ObjectType (BUF0), Local1)
+            If (LNotEqual (Local1, 3))  //  Buffer is type 3
+                {   Return (20) }
+            Store (ObjectType (BUF1), Local1)
+            If (LNotEqual (Local1, 3))  //  Buffer is type 3
+                {   Return (21) }
+
+            // Decrement because the Index base below is zero based
+            //  while Local0 length is one based.
+            Decrement (Local0)
+
+            While (Local0)
+            {   //  loop through all BUF0 buffer elements
+                Decrement (Local0)
+
+                //  check if BUF0[n] == BUF1[n]
+                If (LEqual (DerefOf (Index (BUF0, Local0, )),
+                        DerefOf (Index (BUF1, Local0, ))))
+                    {   }   //  this is how the code was really implemented
+                Else
+                    {   Return (Zero)   }
+            }   //  loop through all BUF0 buffer elements
+
+            Return (One)    //  strings / buffers match
+        }   //  MCTH:   Control Method to compare two strings
+
+
+        Method (TEST)
+        {
+            Store ("++++++++ IndexOp5 Test", Debug)
+
+            If (MCTH (\_OS, "Microsoft Windows NT"))
+                {   Store (1, OSFL) }
+
+            If (LNotEqual (OSFL, 1))
+                {   Return (11) }
+
+            Return (0)
+        }   //  TEST
+    }   //  IDX5
+
+//
+// test IndexOp.asl
+//
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+
+        Method (C097)
+            {   Return (1)  }
+
+        Device (PCI2)
+        {   //  Root PCI Bus
+            Name (_HID, EISAID("PNP0A03"))
+            Name (_ADR, 0x00000000)
+            Name (_CRS, Buffer(26)  {"\_SB_.PCI2._CRS..........."})
+            Method (_STA)   {Return (0x0F)}
+
+            Device (ISA)
+            {   //  ISA bridge
+                Name (_ADR, 0x00030000)     //  ISA bus ID
+
+                Device (EC0)
+                {   //  Embedded Controller
+                    Name (_GPE, 0)              //  EC use GPE0
+                    Name (_ADR, 0x0030000)  //  PCI address
+
+                    Method (_STA,0)         //  EC Status
+                        {   Return(0xF) }       //  EC is functioning
+
+                    Name (_CRS, ResourceTemplate()
+                        {
+                            IO (Decode16, 0x62, 0x62, 1, 1)
+                            IO (Decode16, 0x66, 0x66, 1, 1)
+                        }
+                    )
+
+                //  create EC's region and field
+                    OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+                    Field (RAM, AnyAcc, NoLock, Preserve)
+                    {
+                        //  AC information
+                        ADP,    1,      //  AC Adapter 1:On-line, 0:Off-line
+                        AFLT,   1,      //  AC Adapter Fault  1:Fault  0:Normal
+                        BAT0,   1,      //  BAT0  1:present, 0:not present
+                        ,       1,      //  reserved
+                        ,       28, //  filler to force DWORD alignment
+
+                        //  CMBatt information
+                        BPU0,   32, //  Power Unit
+                        BDC0,   32, //  Designed Capacity
+                        BFC0,   32, //  Last Full Charge Capacity
+                        BTC0,   32, //  Battery Technology
+                        BDV0,   32, //  Design Voltage
+                        BST0,   32, //  Battery State
+                        BPR0,   32, //  Battery Present Rate
+                                        //  (Designed Capacity)x(%)/{(h)x100}
+                        BRC0,   32, //  Battery Remaining Capacity
+                                        //  (Designed Capacity)(%)^100
+                        BPV0,   32, //  Battery Present Voltage
+                        BTP0,   32, //  Trip Point
+                        BCW0,   32, //  Design capacity of Warning
+                        BCL0,   32, //  Design capacity of Low
+                        BCG0,   32, //  capacity granularity 1
+                        BG20,   32, //  capacity granularity 2
+                        BMO0,   32, //  Battery model number field
+                        BIF0,   32, //  OEM Information(00h)
+                        BSN0,   32, //  Battery Serial Number
+                        BTY0,   32, //  Battery Type (e.g., "Li-Ion")
+                        BTY1,   32      //  Battery Type (e.g., "Li-Ion")
+                    }   //  Field
+                }   //  EC0: Embedded Controller
+            }   //  ISA bridge
+        }   //  PCI2 Root PCI Bus
+
+        Device (IDX0)
+        {   //  Test device name
+            Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
+            Name (_PCL, Package() {\_SB})
+            Method (_STA)
+            {
+                //  _STA bits 0-3 indicate existence of battery slot
+                //  _STA bit 4 indicates battery (not) present
+                If (\_SB.PCI2.ISA.EC0.BAT0)
+                    {   Return (0x1F)   }   //  Battery present
+                else
+                    {   Return (0x0F)   }   //  Battery not present
+            }   //  _STA
+
+            Method (_BIF)
+            {
+                Name (BUFR, Package(13) {})
+                Store (\_SB.PCI2.ISA.EC0.BPU0, Index (BUFR,0))  //  Power Unit
+                Store (\_SB.PCI2.ISA.EC0.BDC0, Index (BUFR,1))  //  Designed Capacity
+                Store (\_SB.PCI2.ISA.EC0.BFC0, Index (BUFR,2))  //  Last Full Charge Capa.
+                Store (\_SB.PCI2.ISA.EC0.BTC0, Index (BUFR,3))  //  Battery Technology
+                Store (\_SB.PCI2.ISA.EC0.BDV0, Index (BUFR,4))  //  Designed Voltage
+                Store (\_SB.PCI2.ISA.EC0.BCW0, Index (BUFR,5))  //  Designed warning level
+                Store (\_SB.PCI2.ISA.EC0.BCL0, Index (BUFR,6))  //  Designed Low level
+                Store (\_SB.PCI2.ISA.EC0.BCG0, Index (BUFR,7))  //  Capacity granularity 1
+                Store (\_SB.PCI2.ISA.EC0.BG20, Index (BUFR,8))  //  Capacity granularity 2
+
+                Store ("", Index (BUFR,9))                              //  Model Number
+
+                Store ("", Index (BUFR,10))                         //  Serial Number
+
+                Store ("LiOn", Index (BUFR,11))                     //  Battery Type
+
+                Store ("Chicony", Index (BUFR,12))                  //  OEM Information
+
+                Return (BUFR)
+            }   //  _BIF
+
+            Method (_BST)
+            {
+                Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180})
+                Return (BUFR)
+            }   //  _BST
+
+            Method (_BTP,1)
+            {
+                Store (arg0, \_SB.PCI2.ISA.EC0.BTP0)    //  Set Battery Trip point
+            }
+
+            Method (TEST)
+            {
+
+                Store ("++++++++ IndexOp Test", Debug)
+
+                //  test storing into uninitialized package elements
+                Name (PBUF, Package(4) {})  //  leave unitialized
+                Store (0x01234567, Index (PBUF,0))
+                Store (0x89ABCDEF, Index (PBUF,1))
+                Store (0xFEDCBA98, Index (PBUF,2))
+                Store (0x76543210, Index (PBUF,3))
+
+                //  verify values stored into uninitialized package elements
+                If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567))
+                    {   Return (0x10)   }
+
+                If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF))
+                    {   Return (0x11)   }
+
+                If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98))
+                    {   Return (0x12)   }
+
+                If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210))
+                    {   Return (0x13)   }
+
+
+                //  store _BIF package return value into Local0
+                Store (_BIF, Local0)
+
+                //  save Local0 object type value into Local1
+                Store (ObjectType (Local0), Local1)
+
+                //  validate Local0 is a Package
+                If (LNotEqual (Local1, 4))  //  Package type is 4
+                    {   Return (0x21)   }   //  failure
+
+
+                //  test storing into buffer field elements
+                Name (BUFR, Buffer(16)
+                    {   //  initial values
+                        00, 00, 00, 00, 00, 00, 00, 00,
+                        00, 00, 00, 00, 00, 00, 00, 00,
+                    }
+                )   //  BUFR
+                //  test storing into buffer field elements
+                Store (0x01234567, Index (BUFR,0))  //  should only store 0x67
+                Store (0x89ABCDEF, Index (BUFR,4))  //  should only store 0xEF
+                Store (0xFEDCBA98, Index (BUFR,8))  //  should only store 0x98
+                Store (0x76543210, Index (BUFR,12)) //  should only store 0x10
+
+                //  verify storing into buffer field elements
+                If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67))
+                    {   Return (0x30)   }
+
+                If (LNotEqual (DerefOf (Index (BUFR,1)), 0))
+                    {   Return (0x31)   }
+
+                If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF))
+                    {   Return (0x34)   }
+
+                If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98))
+                    {   Return (0x38)   }
+
+                If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10))
+                    {   Return (0x3C)   }
+
+
+                Return (0)  //  pass
+            }   //  TEST
+        }   //  IDX0
+    }   //  _SB system bus
+
+//
+// test BitIndex.asl
+//
+//  BitIndex test
+//  This is a test case for accessing fields defined as single bits in
+//  memory.  This is done by creating two index fields that overlay the
+//  same DWORD in memory.  One field accesses the DWORD as a DWORD, the
+//  other accesses individual bits of the same DWORD field in memory.
+//
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+        OperationRegion (RAM, SystemMemory, 0x800000, 0x100)
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {   //  Any access
+            TREE,   3,
+            WRD0,   16,
+            WRD1,   16,
+            WRD2,   16,
+            WRD3,   16,
+            WRD4,   16,
+            DWRD,   32, //  DWORD field
+        }
+        Field (RAM, AnyAcc, NoLock, Preserve)
+        {   //  Any access
+            THRE,   3,
+            WD00,   16,
+            WD01,   16,
+            WD02,   16,
+            WD03,   16,
+            WD04,   16,
+            BYT0,   8,  //  Start off with a BYTE
+            BIT0,   1,  //  single-bit field
+            BIT1,   1,  //  single-bit field
+            BIT2,   1,  //  single-bit field
+            BIT3,   1,  //  single-bit field
+            BIT4,   1,  //  single-bit field
+            BIT5,   1,  //  single-bit field
+            BIT6,   1,  //  single-bit field
+            BIT7,   1,  //  single-bit field
+            BIT8,   1,  //  single-bit field
+            BIT9,   1,  //  single-bit field
+            BITA,   1,  //  single-bit field
+            BITB,   1,  //  single-bit field
+            BITC,   1,  //  single-bit field
+            BITD,   1,  //  single-bit field
+            BITE,   1,  //  single-bit field
+            BITF,   1,  //  single-bit field
+            BYTZ,   8,  //  End with a BYTE for a total of 32 bits
+        }
+
+        Device (BITI)
+        {   //  Test device name
+
+            Method (MBIT)   //  Test single bit memory accesses
+            {
+
+                If (LNotEqual (DWRD, 0x00))
+                {
+                    Store (0xFF00, Local0)
+                }
+                Else
+                {
+                    //  Prime Local0 with 0...assume passing condition
+                    Store (0, Local0)
+
+                    //  set memory contents to known values using DWORD field
+                    Store (0x5A5A5A5A, DWRD)
+
+                    //  Given the value programmed into DWRD, only the odd bits
+                    //  of the lower nibble should be set. BIT1, BIT3 should be set.
+                    //  BIT0 and BIT2 should be clear
+
+                    If (BIT0)
+                    {
+                        Or (Local0, 0x01, Local0)
+                    }
+
+                    If (LNot (BIT1))
+                    {
+                        Or (Local0, 0x02, Local0)
+                    }
+
+                    If (BIT2)
+                    {
+                        Or (Local0, 0x04, Local0)
+                    }
+
+                    If (LNot (BIT3))
+                    {
+                        Or (Local0, 0x08, Local0)
+                    }
+
+                    //  Now check the upper nibble.  Only the "even" bits should
+                    //  be set.  BIT4, BIT6.  BIT5 and BIT7 should be clear.
+                    If (LNot (BIT4))
+                    {
+                        Or (Local0, 0x10, Local0)
+                    }
+
+                    If (BIT5)
+                    {
+                        Or (Local0, 0x20, Local0)
+                    }
+
+                    If (LNot (BIT6))
+                    {
+                        Or (Local0, 0x40, Local0)
+                    }
+
+                    If (BIT7)
+                    {
+                        Or (Local0, 0x80, Local0)
+                    }
+                }   //  End Else DWRD zeroed out
+
+                Return (Local0)
+            }   //  MBIT:   Test single bit memory accesses
+
+            Method (TEST)
+            {
+
+                Store ("++++++++ BitIndex Test", Debug)
+
+                //  Zero out DWRD
+                Store (0x00000000, DWRD)
+
+                //  MBIT returns zero if successful
+                //  This may be causing problems -- Return (MBIT)
+                Store (MBIT, Local0)
+
+                Return (Local0)
+            }   //  TEST
+        }   //  BITI
+    }   //  _SB system bus
+
+//
+// test IndexOp3.asl
+//
+//  Additional IndexOp test cases to support ACPICMB (control method battery
+//  test) on Compaq laptops. Test cases include storing a package into
+//  an IndexOp target and validating that changing source and destination
+//  package contents are independent of each other.
+//
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+
+        Name (C174, 13)
+        Name (C175, 8)
+
+        Device (C158)
+        {   //  C158:   AC Adapter device
+            Name (_HID, "ACPI0003") //  AC Adapter device
+            Name (_PCL, Package (1) {\_SB})
+
+            Method (_PSR)
+            {
+                Acquire (\_GL, 0xFFFF)
+                Release (\_GL)
+                And (Local0, 1, Local0) //  Local0 &= 1
+                Return (Local0)
+            }   //  _PSR
+        }   //  C158:   AC Adapter device
+
+        Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"})
+
+        Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F})
+
+        Name (C178, Package (4)
+        {
+            Package (4) {0, 0, 0x966B, 0x4190},
+            Package (4) {0, 0, 0x966B, 0x4190},
+            Package (4) {0, 0, 0x966B, 0x4190},
+            Package (4) {0, 0, 0x966B, 0x4190}
+        })  //  C178
+
+        Name (C179, Package (4) {0, 0, 0x966B, 0x4190})
+
+        Name (C17A, Package (4)
+        {
+            Package (3) {0, 0, 0},
+            Package (3) {0, 0, 0},
+            Package (3) {0, 0, 0},
+            Package (3) {0, 0, 0}
+        })  //  C17A
+
+        Method (C17B, 1)
+        {   //  C17B:   _BIF implementation
+            Name (C17C, Package (13)
+            {   //  C17C:   _BIF control method return package
+                0,                  //  Power Unit (0 ==> mWh and mW)
+                0x99F5,         //  Design Capacity
+                0x99F5,         //  Last Full Charge Capacity
+                1,                  //  Battery Technology (1 ==> rechargeable)
+                0x3840,         //  Design Voltage
+                0x1280,         //  Design Capacity of Warning
+                0x0AC7,         //  Design Capacity of Low
+                1,                  //  Battery Capacity Granularity 1 (Low -- Warning)
+                1,                  //  Battery Capacity Granularity 2 (Warning -- Full)
+                "2891",         //  Model Number (ASCIIZ)
+                "(-Unknown-)",  //  Serial Number (ASCIIZ)
+                "LIon",         //  Battery Type (ASCIIZ)
+                0                   //  OEM Information (ASCIIZ)
+            })  //  C17C:   _BIF control method return package
+
+            And (Arg0, 7, Local0)                       //  Local0 = Arg0 & 7
+
+            ShiftRight (Local0, 1, Local4)          //  Local4 = Local0 >> 1
+
+            Store (C179, Index (C178, Local4, ))    //  C178->Local4 = C179
+
+            //  verify source and destination packages can be altered independent
+            //  of each other (i.e., changing one's contents does NOT change other's
+            //  contents)
+            Store (0x1234, Index (C179, 2, ))               //  C179[2] = 0x1234
+            Store (DerefOf (Index (C179, 2, )), Local2) //  Local2 = C179[2]
+            if (LNotEqual (Local2, 0x1234))
+                {   Return (0x1234) }
+                                                                        //  Local2 = C178[0,2]
+            Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2)
+            if (LNotEqual (Local2, 0x966B))
+                {   Return (0x1234) }
+
+            // Restore data to allow iterative execution
+            Store (0x966B, Index (C179, 2, ))               //  C179[2] = 0x966B
+
+                                                                        //  C178[0,3] = 0x5678
+            Store (0x5678, Index (DerefOf (Index (C178, 0, )), 3, ))
+                                                                        //  Local2 = C178[0,3]
+            Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 3, )), Local2)
+            if (LNotEqual (Local2, 0x5678))
+                {   Return (0x5678) }
+
+            Store (DerefOf (Index (C179, 3, )), Local2) //  Local2 = C179[3]
+            if (LNotEqual (Local2, 0x4190))
+                {   Return (0x5678) }
+
+            // Restore data to allow iterative execution
+            Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, ))    //  C179[2] = 0x4190
+
+            Return (C17C)
+        }   //  C17B:   _BIF implementation
+
+        Device (C154)
+        {   //  C154:   Battery 0
+            Name (_HID, "*PNP0C0A")     //  Control Method Battey ID
+            Name (_UID, 0)                  //  first instance
+
+            Method (_BIF)
+            {   //  _BIF
+                Return (C17B (48))
+            }   //  _BIF
+        }   //  C154:   Battery 0
+
+        Device (IDX3)
+        {
+            Method (LCLB)
+            {   //  LCLB control method: test Index(Local#) where Local# is buffer
+                //  Local0 is index counter
+                //  Local1 is buffer
+                //  Local2 receives BUFR[Local0] via Deref(Index(Local1...))
+                //  Local3 is Local1 or Local2 object type
+                //  Local4 is return error code
+
+                Name (BUFR, Buffer ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+                //  save PKG into Local1
+                Store (BUFR, Local1)
+
+                //  save Local2 object type value into Local3
+                Store (ObjectType (Local1), Local3)
+
+                //  validate Local1 is a Buffer
+                If (LNotEqual (Local3, 3))      //  Buffer type is 3
+                    {   Return (0x9F)   }
+
+
+                Store (0, Local0)
+                While (LLess (Local0, 5))
+                {   //  While (Local0 < 5)
+                    //  Local2 = Local1[Local0]
+                    Store (DerefOf (Index (Local1, Local0, )), Local2)
+
+                    //  save Local2 object type value into Local3
+                    Store (ObjectType (Local2), Local3)
+
+                    //  validate Local2 is a Number
+                    If (LNotEqual (Local3, 1))      //  Number type is 1
+                        {   Return (0x9E)   }
+
+                    //  validate Local1[Local0] value == Local0
+                    If (LNotEqual (Local0, Local2))
+                    {   //  Local0 != Local2 == PKG[Local0]
+                        //  Local4 = 0x90 + loop index (Local0)
+                        Add (0x90, Local0, Local4)
+
+                        //  return 0x90 + loop index
+                        Return (Local4)
+                    }
+
+                    Increment (Local0)
+                }   //  While (Local0 < 5)
+
+                Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug)
+
+                Return (0)  //  Pass
+            }   //  LCLB control method: test Index(Local#) where Local# is buffer
+
+            Method (LCLP)
+            {   //  LCLP control method: test Index(Local#) where Local# is package
+                //  Local0 is index counter
+                //  Local1 is package
+                //  Local2 receives PKG[Local0] via Deref(Index(Local1...))
+                //  Local3 is Local1 or Local2 object type
+                //  Local4 is return error code
+
+                Name (PKG, Package ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+                //  save PKG into Local1
+                Store (PKG, Local1)
+
+                //  save Local2 object type value into Local3
+                Store (ObjectType (Local1), Local3)
+
+                //  validate Local1 is a Package
+                If (LNotEqual (Local3, 4))      //  Package type is 4
+                    {   Return (0x8F)   }
+
+
+                Store (0, Local0)
+                While (LLess (Local0, 5))
+                {   //  While (Local0 < 5)
+                    //  Local2 = Local1[Local0]
+                    Store (DerefOf (Index (Local1, Local0, )), Local2)
+
+                    //  save Local2 object type value into Local3
+                    Store (ObjectType (Local2), Local3)
+
+                    //  validate Local2 is a Number
+                    If (LNotEqual (Local3, 1))      //  Number type is 1
+                        {   Return (0x8E)   }
+
+                    //  validate Local1[Local0] value == Local0
+                    If (LNotEqual (Local0, Local2))
+                    {   //  Local0 != Local2 == PKG[Local0]
+                        //  Local4 = 0x80 + loop index (Local0)
+                        Add (0x80, Local0, Local4)
+
+                        //  return 0x80 + loop index
+                        Return (Local4)
+                    }
+
+                    Increment (Local0)
+                }   //  While (Local0 < 5)
+
+                Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug)
+
+                Return (0)  //  Pass
+            }   //  LCLP control method: test Index(Local#) where Local# is package
+
+            Method (TEST)
+            {
+
+                Store ("++++++++ IndexOp3 Test", Debug)
+
+                //  store _BIF package return value into Local0
+                Store (\_SB.C154._BIF, Local0)
+
+                //  save Local0 object type value into Local1
+                Store (ObjectType (Local0), Local1)
+
+                //  validate Local0 is a Package
+                If (LNotEqual (Local1, 4))      //  Package type is 4
+                {   //  failure: did not return a Package (type 4)
+                    //  if Local0 is a Number, it contains an error code
+                    If (LEqual (Local1, 1))     //  Number type is 1
+                        {   Return (Local0) }   //  return Local0 error code
+                    Else                                //  Local0 is not a Number
+                        {   Return (1)  }           //  return default error code
+                }   //  failure: did not return a Package (type 4)
+
+                //  save LCLB control method return value into Local2
+                Store (LCLB, Local2)
+                If (LNotEqual (Local2, 0))
+                    {   Return (Local2) }   //  return failure code
+
+                //  save LCLP control method return value into Local2
+                Store (LCLP, Local2)
+                If (LNotEqual (Local2, 0))
+                    {   Return (Local2) }   //  return failure code
+
+                Return (0)  //  Pass
+            }   //  TEST
+        }   //  IDX3:   Test device name
+    }   //  _SB system bus
+
+//
+// MTL developed test to exercise Indexes into buffers
+//
+    Device(IDX7)
+    {
+
+        Name (PKG4, Package() {
+                0x2,
+                "A short string",
+                Buffer() {0xA, 0xB, 0xC, 0xD},
+                0x1234,
+                Package() {IDX7, 0x3}
+                })
+
+        //
+        // Generic Test method
+        //
+        // This test returns 0xE (14) - ObjectType = Buffer Field
+        Method(TST1)
+        {
+            Name (DEST, Buffer ()                           //  62 characters plus NULL
+                {"Destination buffer that is longer than the short source buffer"})
+
+            //  verify object type returned by Index(Buffer,Element,)
+            Store (Index (DEST, 2, ), Local1)
+            Store (ObjectType (Local1), Local2)
+            If (LEqual(Local2, 14))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x1)
+            }
+
+        }
+
+        Method(TST2)
+        {
+            Name (BUF0, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
+            Store(0x55, Index(BUF0, 2))
+            Store(DerefOf(Index(BUF0, 2)), Local0)
+            If (LEqual(Local0, 0x55))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x2)
+            }
+
+
+        }
+
+        Method(TST3)
+        {
+            Name (BUF1, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
+            Store(Index(BUF1, 1), Local0)
+            Store(DerefOf(Local0), Local1)
+            If (LEqual(Local1, 0x2))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x3)
+            }
+
+        }
+
+        Method(TST4)
+        {
+            // Index (PKG4, 0) is a Number
+            Store (Index (PKG4, 0), Local0)
+            Store (ObjectType(Local0), Local1)
+            If (LEqual(Local1, 0x1))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x4)
+            }
+
+        }
+
+        Method(TST5)
+        {
+            // Index (PKG4, 1) is a String
+            Store (Index (PKG4, 1), Local0)
+            Store (ObjectType(Local0), Local1)
+            If (LEqual(Local1, 0x2))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x5)
+            }
+
+        }
+
+        Method(TST6)
+        {
+            // Index (PKG4, 2) is a Buffer
+            Store (Index (PKG4, 2), Local0)
+            Store (ObjectType(Local0), Local1)
+            If (LEqual(Local1, 0x3))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x6)
+            }
+
+        }
+
+        Method(TST7)
+        {
+            // Index (PKG4, 3) is a Number
+            Store (Index (PKG4, 3), Local0)
+            Store (ObjectType(Local0), Local1)
+            If (LEqual(Local1, 0x1))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x7)
+            }
+
+        }
+
+        Method(TST8)
+        {
+            // Index (PKG4, 4) is a Package
+            Store (Index (PKG4, 4), Local0)
+            Store (ObjectType(Local0), Local1)
+            If (LEqual(Local1, 0x4))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x8)
+            }
+
+        }
+
+        Method(TST9)
+        {
+            // DerefOf (Index (PKG4, 0)) is a Number
+            Store (DerefOf (Index (PKG4, 0)), Local0)
+            If (LEqual(Local0, 0x2))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0x9)
+            }
+
+        }
+
+        Method(TSTA)
+        {
+            // DerefOf (Index (PKG4, 1)) is a String
+            Store (DerefOf (Index (PKG4, 1)), Local0)
+            Store (SizeOf(Local0), Local1)
+            If (LEqual(Local1, 0xE))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0xA)
+            }
+
+        }
+
+        Method(TSTB)
+        {
+            // DerefOf (Index (PKG4, 2)) is a Buffer
+            Store (DerefOf (Index (PKG4, 2)), Local0)
+            Store (SizeOf(Local0), Local1)
+            If (LEqual(Local1, 0x4))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0xB)
+            }
+
+        }
+
+        Method(TSTC)
+        {
+            // DerefOf (Index (PKG4, 3)) is a Number
+            Store (DerefOf (Index (PKG4, 3)), Local0)
+            If (LEqual(Local0, 0x1234))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0xC)
+            }
+
+        }
+
+        Method(TSTD)
+        {
+            // DerefOf (Index (PKG4, 4)) is a Package
+            Store (DerefOf (Index (PKG4, 4)), Local0)
+            Store (SizeOf(Local0), Local1)
+            If (LEqual(Local1, 0x2))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0xD)
+            }
+
+        }
+
+        Method(TSTE)
+        {
+            // DerefOf (Index (PKG4, 2)) is a Buffer
+            Store (DerefOf (Index (PKG4, 2)), Local0)
+            // DerefOf (Index (Local0, 1)) is a Number
+            Store (DerefOf (Index (Local0, 1)), Local1)
+            If (LEqual(Local1, 0xB))
+            {
+                Return(0)
+            }
+            Else
+            {
+                Return(0xE)
+            }
+
+        }
+
+        Method (TSTF)
+        {
+            Name (SRCB, Buffer (12) {}) //  12 characters
+            Store ("Short Buffer", SRCB)
+
+            Name (DEST, Buffer ()                       //  62 characters plus NULL
+                {"Destination buffer that is longer than the short source buffer"})
+
+            //  overwrite DEST contents, starting at buffer position 2
+            Store (SRCB, Index (DEST, 2))
+
+            //
+            //  The DEST buffer element should be replaced with the last element of
+            //      the SRCB element (i.e. 's'->'r')
+            Store (DerefOf (Index (DEST, 2)), Local0)
+
+            If (LNotEqual (Local0, 0x72))       //  'r'
+            {
+                //  DEST element does not match the value from SRCB
+                Return(Or(Local0, 0x1000))
+            }
+
+            Return(0)
+        }
+
+        Method (TSTG)
+        {
+
+            Name (SRCB, Buffer (12) {}) //  12 characters
+            Store ("Short Buffer", SRCB)
+
+            Name (DEST, Buffer ()                       //  62 characters plus NULL
+                {"Destination buffer that is longer than the short source buffer"})
+
+            //  overwrite DEST contents, starting at buffer position 2
+            Store (SRCB, Index (DEST, 2))
+
+            //
+            // The next element of DEST should be unchanged
+            //
+            Store (DerefOf (Index (DEST, 3)), Local0)
+
+            If (LNotEqual (Local0, 0x74))       //  't'
+            {
+                //  DEST has been changed
+                Return(Or(Local0, 0x2000))
+            }
+
+            //
+            // The next element of DEST should be unchanged
+            //
+            Store (DerefOf (Index (DEST, 4)), Local0)
+
+            If (LNotEqual (Local0, 0x69))       //  'i'
+            {
+                //  DEST has been changed
+                Return(Or(Local0, 0x2100))
+            }
+
+            //
+            // The next element of DEST should be unchanged
+            //
+            Store (DerefOf (Index (DEST, 5)), Local0)
+
+            If (LNotEqual (Local0, 0x6E))       //  'n'
+            {
+                //  DEST has been changed
+                Return(Or(Local0, 0x2200))
+            }
+
+            //
+            // The next element of DEST should be unchanged
+            //
+            Store (DerefOf (Index (DEST, 6)), Local0)
+
+            If (LNotEqual (Local0, 0x61))       //  'a'
+            {
+                //  DEST has been changed
+                Return(Or(Local0, 0x2300))
+            }
+
+            //
+            // The next element of DEST should be unchanged
+            //
+            Store (DerefOf (Index (DEST, 7)), Local0)
+
+            If (LNotEqual (Local0, 0x74))       //  't'
+            {
+                //  DEST has been changed
+                Return(Or(Local0, 0x2400))
+            }
+
+            //
+            //  Verify DEST elements beyond end of SRCB buffer copy
+            //  have not been changed
+            Store (DerefOf (Index (DEST, 14)), Local0)
+
+            If (LNotEqual (Local0, 0x66))       // 'f'
+            {
+                //  DEST has been changed
+                Return(Or(Local0, 0x2400))
+            }
+
+            Return(0)
+        }
+
+        //
+        // This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit
+        //  number into the index'ed buffer
+        //
+        Method (TSTH)
+        {
+            // Create a Destination Buffer
+            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+            // Store a number > UINT8 into an index of the buffer
+            Store (0x12345678, Index(DBUF, 2))
+
+            // Check the results
+            Store (DerefOf (Index (DBUF, 2)), Local0)
+            If (LNotEqual (Local0, 0x78))   // 0x78
+            {
+                Return(Or(Local0, 0x3000))
+            }
+
+            Store (DerefOf (Index (DBUF, 3)), Local0)
+            If (LNotEqual (Local0, 0x64))   // 'd'
+            {
+                Return(Or(Local0, 0x3100))
+            }
+
+            Store (DerefOf (Index (DBUF, 4)), Local0)
+            If (LNotEqual (Local0, 0x65))   // 'e'
+            {
+                Return(Or(Local0, 0x3200))
+            }
+
+            Store (DerefOf (Index (DBUF, 5)), Local0)
+            If (LNotEqual (Local0, 0x66))   // 'f'
+            {
+                Return(Or(Local0, 0x3300))
+            }
+
+            Return(0)
+        }
+
+        Method (TSTI)
+        {
+            // Create a Destination Buffer
+            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+            // Store a String into an index of the buffer
+            Store ("ABCDEFGH", Index(DBUF, 2))
+
+            // Check the results
+            Store (DerefOf (Index (DBUF, 2)), Local0)
+            If (LNotEqual (Local0, 0x48))   // 'H'
+            {
+                Return(Or(Local0, 0x4000))
+            }
+
+            Store (DerefOf (Index (DBUF, 3)), Local0)
+            If (LNotEqual (Local0, 0x64))   // 'd'
+            {
+                Return(Or(Local0, 0x4100))
+            }
+
+            Store (DerefOf (Index (DBUF, 4)), Local0)
+            If (LNotEqual (Local0, 0x65))   // 'e'
+            {
+                Return(Or(Local0, 0x4200))
+            }
+
+            Store (DerefOf (Index (DBUF, 5)), Local0)
+            If (LNotEqual (Local0, 0x66))   // 'f'
+            {
+                Return(Or(Local0, 0x4300))
+            }
+
+            Return(0)
+        }
+
+        Method(TSTJ)
+        {
+            // Create a Destination Buffer
+            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+            // Store a number > UINT8 into an index of the buffer
+            Store (0x1234, Index(DBUF, 2))
+
+            // Check the results
+            Store (DerefOf (Index (DBUF, 2)), Local0)
+            If (LNotEqual (Local0, 0x34))   // 0x34
+            {
+                Return(Or(Local0, 0x3000))
+            }
+
+            Store (DerefOf (Index (DBUF, 3)), Local0)
+            If (LNotEqual (Local0, 0x64))   // 'd'
+            {
+                Return(Or(Local0, 0x3100))
+            }
+
+            Store (DerefOf (Index (DBUF, 4)), Local0)
+            If (LNotEqual (Local0, 0x65))   // 'e'
+            {
+                Return(Or(Local0, 0x3200))
+            }
+
+            Store (DerefOf (Index (DBUF, 5)), Local0)
+            If (LNotEqual (Local0, 0x66))   // 'f'
+            {
+                Return(Or(Local0, 0x3300))
+            }
+
+            Return(0)
+        }
+
+        Method(TSTK)
+        {
+            // Create a Destination Buffer
+            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+            // Store a number > UINT8 into an index of the buffer
+            Store (0x123456, Index(DBUF, 2))
+
+            // Check the results
+            Store (DerefOf (Index (DBUF, 2)), Local0)
+            If (LNotEqual (Local0, 0x56))   // 0x56
+            {
+                Return(Or(Local0, 0x3000))
+            }
+
+            Store (DerefOf (Index (DBUF, 3)), Local0)
+            If (LNotEqual (Local0, 0x64))   // 'd'
+            {
+                Return(Or(Local0, 0x3100))
+            }
+
+            Store (DerefOf (Index (DBUF, 4)), Local0)
+            If (LNotEqual (Local0, 0x65))   // 'e'
+            {
+                Return(Or(Local0, 0x3200))
+            }
+
+            Store (DerefOf (Index (DBUF, 5)), Local0)
+            If (LNotEqual (Local0, 0x66))   // 'f'
+            {
+                Return(Or(Local0, 0x3300))
+            }
+
+            Return(0)
+        }
+
+        Method(TSTL)
+        {
+            // Create a Destination Buffer
+            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+            // Store a number > UINT8 into an index of the buffer
+            Store (0x12, Index(DBUF, 2))
+
+            // Check the results
+            Store (DerefOf (Index (DBUF, 2)), Local0)
+            If (LNotEqual (Local0, 0x12))   // 0x12
+            {
+                Return(Or(Local0, 0x3000))
+            }
+
+            Store (DerefOf (Index (DBUF, 3)), Local0)
+            If (LNotEqual (Local0, 0x64))   // 'd'
+            {
+                Return(Or(Local0, 0x3100))
+            }
+
+            Store (DerefOf (Index (DBUF, 4)), Local0)
+            If (LNotEqual (Local0, 0x65))   // 'e'
+            {
+                Return(Or(Local0, 0x3200))
+            }
+
+            Store (DerefOf (Index (DBUF, 5)), Local0)
+            If (LNotEqual (Local0, 0x66))   // 'f'
+            {
+                Return(Or(Local0, 0x3300))
+            }
+
+            Return(0)
+        }
+
+        Method(TEST)
+        {
+            Store ("++++++++ IndexOp7 Test", Debug)
+
+            Store(TST1(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST2(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST3(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST4(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST5(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST6(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST7(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST8(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TST9(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTA(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTB(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTC(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTD(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTE(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+    /* No longer ACPI compliant */
+    /*
+            Store(TSTF(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+    */
+
+            Store(TSTG(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTH(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+    /* No longer ACPI compliant */
+    /*
+            Store(TSTI(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+    */
+            Store(TSTJ(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTK(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Store(TSTL(), Local0)
+            if (LGreater (Local0, 0))
+            {
+                Return(Local0)
+            }
+
+            Return(Local0)
+
+        }
+
+    } // Device(IDX7)
+
+//
+// test MatchOp.asl
+//
+//  MatchOp test cases that utilize nested DerefOf(Index(...)) to validate
+//  MatchOp, DerefOfOp, and IndexOp of nested packages.
+//
+    Device (MTCH)
+    {
+
+        Method (TEST)
+        {
+            Store ("++++++++ MatchOp Test", Debug)
+
+            Name (TIM0, Package ()
+                {
+                    Package ()  {0x78, 0xB4, 0xF0, 0x0384},
+                    Package ()  {0x23, 0x21, 0x10, 0},
+                    Package ()  {0x0B, 9, 4, 0},
+                    Package ()  {0x70, 0x49, 0x36, 0x27, 0x19},
+                    Package ()  {0, 1, 2, 1, 2},
+                    Package ()  {0, 0, 0, 1, 1},
+                    Package ()  {4, 3, 2, 0},
+                    Package ()  {2, 1, 0, 0}
+                })  //  TIM0
+
+            Name (TMD0, Buffer (20) {0xFF, 0xFF, 0xFF, 0xFF })
+            CreateDWordField (TMD0, 0, PIO0)    //  0xFFFFFFFF
+            CreateDWordField (TMD0, 4, DMA0)
+            CreateDWordField (TMD0, 8, PIO1)
+            CreateDWordField (TMD0, 12, DMA1)
+            CreateDWordField (TMD0, 16, CHNF)
+
+
+            //  validate PIO0 value
+            Store (PIO0, Local3)
+
+            //  save Local3 object type value into Local2
+            Store (ObjectType (Local3), Local2)
+
+            //  validate Local3 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+                {   Return (2)  }   //  failure
+
+            //  validate Local3 Number value
+            If (LNotEqual (Local3, 0xFFFFFFFF)) //  Number value 0xFFFFFFFF
+                {   Return (3)  }   //  failure
+
+            Store ("DWordField PASS", Debug)
+
+
+            Store (0, Local5)
+            Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6)
+
+            //  save Local6 object type value into Local2
+            Store (ObjectType (Local6), Local2)
+
+            //  validate Local6 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+                {   Return (4)  }   //  failure
+
+            Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug)
+
+
+            //  validate following produces a nested package to validate
+            //  that MatchOp did not corrupt SearchPackage (TIM0)
+            Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+            //  save Local4 object type value into Local2
+            Store (ObjectType (Local4), Local2)
+
+            //  validate Local4 is a Package
+            If (LNotEqual (Local2, 4))  //  Package type is 4
+                {   Return (5)  }   //  failure
+
+            Store ("DerefOf(Index(TIM0,1)),... PASS", Debug)
+
+
+            And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0)
+
+            //  save Local0 object type value into Local2
+            Store (ObjectType (Local0), Local2)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+                {   Return (6)  }   //  failure
+
+            //  validate Local0 Number value
+            If (LNotEqual (Local0, 3))  //  Number value 3
+                {   Return (7)  }   //  failure
+
+            Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug)
+
+
+            //  again, validate following produces a nested package
+            Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+            //  save Local4 object type value into Local2
+            Store (ObjectType (Local4), Local2)
+
+            //  validate Local4 is a Package
+            If (LNotEqual (Local2, 4))  //  Package type is 4
+                {   Return (8)  }   //  failure
+
+            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+            //  again, validate following produces a nested package
+            Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+            //  save Local4 object type value into Local2
+            Store (ObjectType (Local4), Local2)
+
+            //  validate Local4 is a Package
+            If (LNotEqual (Local2, 4))  //  Package type is 4
+                {   Return (9)  }   //  failure
+
+            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+            //  test nested DerefOf(Index) operators
+            Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
+
+            //  save Local1 object type value into Local2
+            Store (ObjectType (Local1), Local2)
+
+            //  validate Local1 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+                {   Return (10) }   //  failure
+
+            //  zero indicates pass, non-zero is an error code
+            If (LNotEqual (Local1, 0))
+                {   Return (11) }   //  failure
+
+            Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug)
+
+
+            //  again, validate following produces a nested package
+            Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+            //  save Local4 object type value into Local2
+            Store (ObjectType (Local4), Local2)
+
+            //  validate Local4 is a Package
+            If (LNotEqual (Local2, 4))  //  Package type is 4
+                {   Return (12) }   //  failure
+
+            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+            //  retest nested DerefOf(Index) operators
+            Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
+
+            //  save Local1 object type value into Local2
+            Store (ObjectType (Local1), Local2)
+
+            //  validate Local1 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+                {   Return (13) }   //  failure
+
+            //  zero indicates pass, non-zero is an error code
+            If (LNotEqual (Local1, 0))
+                {   Return (14) }   //  failure
+
+            Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+            //  again, validate following produces a nested package
+            Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+            //  save Local4 object type value into Local2
+            Store (ObjectType (Local4), Local2)
+
+            //  validate Local4 is a Package
+            If (LNotEqual (Local2, 4))  //  Package type is 4
+                {   Return (15) }   //  failure
+
+            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+            Return (0)  //  pass
+        }   //  TEST
+    }   // MTCH
+
+//
+// test WhileBrk.asl
+//
+//  This code tests the Break term and While term
+//
+//  Syntax of Break term
+//      BreakTerm := Break
+//  The break operation causes the current package execution to complete.
+//
+//  Syntax of While Term
+//      WhileTerm   := While(
+//          Predicate   //TermArg=>Integer
+//      ) {TermList}
+//  Predicate is evaluated as an integer.
+//  If the integer is non-zero, the list of terms in TermList is executed.
+//  The operation repeats until the Predicate evaluates to zero.
+//
+// MTL NOTE: This test has been modified to reflect ACPI 2.0 break
+// NOTE: This test, when run under the MS ACPI.SYS grinds the system to
+//  a halt.
+//
+    Device (WHLB)
+    {
+        Name (CNT0, 0)
+        Name (CNT1, 0)
+
+        Method (TEST)
+        {
+            //  Check Break statement nested in If nested in While nested in
+            //  While only exits inner-most While loop
+            Store (0, CNT0)
+
+            While (LLess (CNT0, 4))
+            {
+                Store (0, CNT1)
+                While (LLess (CNT1, 10))
+                {
+                    if (LEqual (CNT1, 1))
+                    {
+                        Break       //  exit encompassing loop
+                    }
+
+                    Increment (CNT1)
+                }
+
+                If (LNotEqual (CNT1, 1))
+                {
+                    //  failure
+                    Return (7)
+                }
+
+                Increment (CNT0)
+            }
+
+            //  Verify Break only exited inner-most While loop
+
+            If (LNotEqual (CNT0, 4))
+            {
+                //  failure
+                Return (8)
+            }
+
+            Store ("While/While/If/Break PASS", Debug)
+
+            Store ("++++++++ WhileBrk Test", Debug)
+
+            //  Check Break statement nested in While
+            Store (0, CNT0)
+
+            While (LLess (CNT0, 10))
+            {
+                Break       //  exit encompassing package
+                Increment (CNT0)
+            }
+
+            If (LNotEqual (CNT0, 0))    //  instruction after Break executed
+            {
+                Return (4)
+            }
+
+
+            Store (0, CNT0)
+
+            //  Test While Term
+            While (LLess (CNT0, 10))
+            {
+                Increment (CNT0)
+            }
+
+            //  Check if the while loop was executed until the condition is satisfied.
+            If (LNotEqual (CNT0, 10))
+            {
+                Return (1)
+            }
+
+
+            //  While loop in a reverse order
+            While (LGreater (CNT0, 0))
+            {
+                Decrement (CNT0)
+            }
+
+            //  Check if the while loop was executed until the condition is satisfied.
+            If (LNotEqual (CNT0, 0))
+            {
+                Return (2)
+            }
+
+
+            Store ("While/Break PASS", Debug)
+
+
+            //  Check Break statement nested in If nested in While
+            Store (0, CNT0)
+
+            While (LLess (CNT0, 10))
+            {
+                if (LEqual (CNT0, 5))
+                {
+                    Break       //  exit encompassing Package (If)
+
+                    //  if we execute the next instruction,
+                    //  Break did not exit the loop
+                    Store (20, CNT0)    //  exit While loop with value larger
+                                            //  than above
+                }
+
+                Increment (CNT0)    //  check if Break exited both If and While
+            }   //  While
+
+            If (LGreater (CNT0, 19))
+            {   //  instruction after Break inside IfOp executed
+                Return (5)
+            }
+
+            //
+            // Break will exit out of the while loop, therefore
+            //  the CNT0 counter should still Increment until 5
+            //
+            If (LNotEqual (CNT0, 5))
+            {   //  instruction after Break inside WhileOp executed
+                Return (6)
+            }
+            Store ("While/If/Break PASS", Debug)
+
+
+            //  All the conditions passed
+            Return (0)
+        }   //  TEST
+    }   //  WHLB
+
+
+//
+// test IndexOp2.asl
+//
+//  Additional IndexOp test cases to support ACPICMB (control method battery
+//  test) on Toshiba Portege 7020CT. Test cases include appropriate bit
+//  shifting of Field elements and reading Field elements greater than 64 bits.
+//
+// MTL NOTE: This test has been modified slightly from the original test
+//  to take into account ACPI specification limitations.
+//
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+
+        Device (MEM)
+        {   //  MEM
+            Name (_HID, 0x010CD041)
+            Name (_STA, 0x0F)
+
+            OperationRegion (SMEM, SystemMemory, 0x800000, 0x100)
+            Field (SMEM, AnyAcc, NoLock, Preserve)
+            {   //  Field:  SMEM overlay using 32-bit field elements
+                SMD0,   32, //  32-bits
+                SMD1,   32,     //  32-bits
+                SMD2,   32,     //  32-bits
+                SMD3,   32  //  32-bits
+            }   //  Field:  SMEM overlay using 32-bit field elements
+            Field (SMEM, AnyAcc, NoLock, Preserve)
+            {   //  Field:  SMEM overlay using greater than 32-bit field elements
+                SME0,   69, //  larger than an integer (32 or 64)
+                SME1,   97  //  larger than an integer
+            }   //  Field:  SMEM overlay using greater than 32-bit field elements
+
+            OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
+            Field (SRAM, AnyAcc, NoLock, Preserve)
+            {   //  Field:  SRAM overlay
+                    ,   0x34000,    //  skip
+                IEAX,   0x20,
+                IEBX,   0x20,
+                IECX,   0x20,
+                IEDX,   0x20,
+                IESI,   0x20,
+                IEDI,   0x20,
+                IEBP,   0x20,
+                    ,   0x20,
+                OEAX,   0x20,
+                OEBX,   0x20,
+                OECX,   0x20,
+                OEDX,   0x20,
+                OESI,   0x20,
+                OEDI,   0x20,
+                OEBP,   0x20,
+                    ,   0x618,  //  skip
+                ACST,   1,
+                BES1,   1,
+                BES2,   1,
+                    ,   5,          //  skip
+                BMN1,   0x68,
+                BSN1,   0x58,
+                BTP1,   0x48,
+                BPU1,   0x20,
+                BDC1,   0x20,
+                BLF1,   0x20,
+                BTC1,   0x20,
+                BDV1,   0x20,
+                BST1,   0x20,
+                BPR1,   0x20,
+                BRC1,   0x20,
+                BPV1,   0x20,
+                    ,   0x20,
+                BCW1,   0x20,
+                BCL1,   0x20,
+                BG11,   0x20,
+                BG21,   0x20,
+                BOI1,   0x20,
+                    ,   0x530,  //  skip
+                BMN2,   0x68,
+                BSN2,   0x58,
+                BTP2,   0x48,
+                BPU2,   0x20,
+                BDC2,   0x20,
+                BLF2,   0x20,
+                BTC2,   0x20,
+                BDV2,   0x20,
+                BST2,   0x20,
+                BPR2,   0x20,
+                BRC2,   0x20,
+                BPV2,   0x20,
+                    ,   0x20,
+                BCW2,   0x20,
+                BCL2,   0x20,
+                BG12,   0x20,
+                BG22,   0x20,
+                BOI2,   0x20,
+                    ,   0x518,  //  skip
+                AC01,   0x10,
+                AC11,   0x10,
+                PSV1,   0x10,
+                CRT1,   0x10,
+                TMP1,   0x10,
+                AST1,   0x10,
+                AC21,   0x10,
+                AC31,   0x10,
+                AC02,   0x10,
+                AC12,   0x10,
+                PSV2,   0x10,
+                CRT2,   0x10,
+                TMP2,   0x10,
+                AST2,   0x10,
+                AC22,   0x10,
+                AC32,   0x10,
+                AC03,   0x10,
+                AC13,   0x10,
+                PSV3,   0x10,
+                CRT3,   0x10,
+                TMP3,   0x10,
+                AST3,   0x10,
+                AC23,   0x10,
+                AC33,   0x10,
+                    ,   0x80,       //  skip
+                TMPF,   0x10,
+                    ,   0x570,  //  skip
+                FANH,   1,
+                FANL,   7,
+                TF11,   1,
+                TF21,   1,
+                TF31,   1,
+                    ,   1,
+                TF10,   1,
+                TF20,   1,
+                TF30,   1,
+                    ,   1,
+                TP11,   1,
+                TP21,   1,
+                TP31,   1,
+                    ,   0x6D,   //  109
+                GP50,   1,
+                GP51,   1,
+                GP52,   1,
+                GP53,   1,
+                    ,   4,
+                GP60,   1,
+                GP61,   1,
+                GP62,   1,
+                GP63,   1,
+                GP64,   1,
+                GP65,   1,
+                GP66,   1,
+                    ,   1,
+                GP70,   1,
+                GP71,   1,
+                GP72,   1,
+                GP73,   1,
+                GP74,   1,
+                GP75,   1,
+                GP76,   1,
+                    ,   1,
+                WED0,   1,
+                WED1,   1,
+                WED2,   1,
+                WED3,   1,
+                WED4,   1,
+                    ,   3,
+                SBL0,   1,
+                SBL1,   1,
+                SBL2,   1,
+                SBL3,   1,
+                    ,   4,
+                LIDS,   1,
+                VALF,   1,
+                    ,   2,
+                DCKI,   1,
+                DCKF,   1,
+                BT1F,   1,
+                BT2F,   1,
+                    ,   0x7D0,  //  skip
+                HKCD,   8,
+                    ,   8,
+                DLID,   0x20,
+                DSRN,   0x20,
+                    ,   0x20,
+                BDID,   0x20,
+                DSPW,   1,
+                VGAF,   1,
+                VWE0,   1,
+                VWE1,   1,
+                PPSC,   1,
+                SPSC,   1,
+                EWLD,   1,
+                EWPS,   1,
+                    ,   0x1768, //  skip
+                PRES,   0x8000
+            }   //  Field:  SRAM overlay
+        }   //  MEM
+
+        Device (BAT1)
+        {   //  BAT1
+            Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
+            Name (_UID, 1)
+            Name (_PCL, Package (1) {\_SB})
+
+            Method (_STA)
+            {   //  _STA
+                If (\_SB.MEM.BES1)
+                    {   Return (0x1F)   }   //  battery present
+                Else
+                    {   Return (0x0F)   }   //  battery not present
+            }   //  _STA
+
+            Method (_BIF)
+            {   //  _BIF
+                Name (BUFR, Package (13)    {})
+
+                Store (\_SB.MEM.BPU1, Index (BUFR, 0))
+                Store (\_SB.MEM.BDC1, Index (BUFR, 1))
+                Store (\_SB.MEM.BLF1, Index (BUFR, 2))
+                Store (\_SB.MEM.BTC1, Index (BUFR, 3))
+                Store (\_SB.MEM.BDV1, Index (BUFR, 4))
+                Store (\_SB.MEM.BCW1, Index (BUFR, 5))
+                Store (\_SB.MEM.BCL1, Index (BUFR, 6))
+                Store (\_SB.MEM.BG11, Index (BUFR, 7))
+                Store (\_SB.MEM.BG21, Index (BUFR, 8))
+                Store (\_SB.MEM.BMN1, Index (BUFR, 9))
+                Store (\_SB.MEM.BSN1, Index (BUFR, 10))
+                Store (\_SB.MEM.BTP1, Index (BUFR, 11))
+                Store (\_SB.MEM.BOI1, Index (BUFR, 12))
+
+                Return (BUFR)
+            }   //  _BIF
+        }   //  BAT1
+
+        Device (IDX2)
+        {
+            Method (B2IB)
+            {   //  B2IB:   store from Buffer into Index'ed Buffer
+
+                Name (SRCB, Buffer ()   {"Short Buffer"})   //  12 characters plus NULL
+
+                Name (DEST, Buffer ()                           //  62 characters plus NULL
+                    {"Destination buffer that is longer than the short source buffer"})
+
+
+                //  verify object type returned by Index(Buffer,Element,)
+
+                Store (Index (DEST, 2, ), Local1)
+                Store (ObjectType (Local1), Local2)
+
+                If (LNotEqual (Local2, 14))     //  Buffer Field is type 14
+                {
+                    //  Local2 indicates Local1 is not a Buffer Field
+
+                    Return (0x61)
+                }
+
+                //  verify object type and value returned by DerefOf(Index(Buffer,Element,))
+                //  should return Number containing element value
+
+                Store (DerefOf (Local1), Local3)
+                Store (ObjectType (Local3), Local4)
+
+                If (LNotEqual (Local4, 1))          //  Number is type 1
+                {
+                    //  Local2 indicates Local1 is not a Number
+                    Return (0x62)
+                }
+                Else
+                {
+                    If (LNotEqual (Local3, 0x73))       //  expect 's' element from DEST
+                    {
+                        Return (0x63)
+                    }
+                }
+
+                Store ("DerefOf(Index(Buffer,,)) PASS", Debug)
+
+
+                //
+                // The following sections have been rewritten because storing into
+                // an Indexed buffer only changes one byte - the FIRST byte of the
+                // buffer is written to the source index.  This is the ONLY byte
+                // written -- as per ACPI 2.0
+                //
+                // Overwrite DEST contents, at buffer position 2 [only]
+
+                Store (SRCB, Index (DEST, 2, ))
+
+                //
+                // Check that the next byte is not changed
+                //
+                Store (DerefOf (Index (DEST, 3, )), Local0)
+                If (LNotEqual (Local0, 0x74))       //  't'
+                {
+                    //  DEST element is not matching original value
+                    If (LEqual (Local0, 0x68))
+                    {
+                        //  DEST element was altered to 'h'
+                        Return (0x68)
+                    }
+                    Else
+                    {
+                        // DEST element is an unknown value
+                        Return (0x69)
+                    }
+                }
+
+                //
+                // Check that the elements beyond the SRCB buffer copy
+                //  have not been altered.
+                //
+                Store (DerefOf (Index (DEST, 14)), Local0)
+
+                //
+                // This should be an 'f'.
+                //
+                If (LNotEqual (Local0, 0x66))
+                {
+                    //  DEST element was zero'd by buffer copy
+                    If (LEqual (Local0, 0))
+                    {
+                        //  DEST element is zero
+                        Return (0x6A)
+                    }
+                    Else
+                    {
+                        //  DEST element is unknown value
+                        Return (0x6B)
+                    }
+                }
+
+                Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug)
+
+                //
+                //  verify altering SRCB does NOT alter DEST
+                //
+                Store (0x6A, Index (SRCB, 1))   //  SRCB = "Sjort Buffer"
+
+                Store (DerefOf (Index (SRCB, 1)), Local0)
+
+                If (LNotEqual (Local0, 0x6A))       //  'j'
+                {
+                    //  SRCB element is unaltered
+                    Return (0x71)
+                }
+
+                Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that...
+
+                If (LNotEqual (Local0, 0x74))       //  't'
+                {
+                    //  DEST element is altered
+                    If (LEqual (Local0, 0x6A))  //  'j'
+                    {
+                        //  SRCB change altered DEST element
+                        Return (0x72)
+                    }
+                    Else
+                    {
+                        //  DEST element is unknown value
+                        Return (0x73)
+                    }
+                }
+
+                //  verify altering DEST does NOT alter SRCB
+
+                Store (0x6B, Index (DEST, 4, )) //  DEST = "DeSkination buffer..."
+
+                Store (DerefOf (Index (DEST, 4, )), Local0)
+
+                If (LNotEqual (Local0, 0x6B))       //  'k'
+                {
+                    //  DEST element is unaltered
+                    Return (0x74)
+                }
+
+                Store (DerefOf (Index (SRCB, 2, )), Local0)
+
+                If (LNotEqual (Local0, 0x6F))       //  'o'
+                {   //  SRC element is altered
+                    If (LEqual (Local0, 0x6B))  //  'k'
+                    {
+                        //  DEST change altered SRCB element
+                        Return (0x75)
+                    }
+                    Else
+                    {
+                        //  SRCB element is unknown value
+                        Return (0x76)
+                    }
+                }
+
+                Store ("SRCB and DEST independent PASS", Debug)
+
+
+                // verify string can be written to Index target/destination
+                // Only FIRST byte is written
+
+                Store ("New Buff", Index (DEST, 2, ))   //  DEST = "DeNkination buffer..."
+
+                Store (DerefOf (Index (DEST, 2, )), Local0)
+
+                If (LNotEqual (Local0, 0x4E))       //  'N'
+                {
+                    //  DEST element is unaltered
+                    Return (0x81)
+                }
+
+                Store (DerefOf (Index (DEST, 6, )), Local0)
+
+                If (LNotEqual (Local0, 0x61))       //  'a'
+                {
+                    //  DEST element is unaltered
+                    Return (0x82)
+                }
+
+                Store (DerefOf (Index (DEST, 10, )), Local0)
+
+                If (LNotEqual (Local0, 0x6E))       //  'n'
+                {
+                    //  DEST element is unaltered
+                    Return (0x83)
+                }
+
+                Store ("Store(String,Index) PASS", Debug)
+
+
+                Return (0)  //  pass
+            }   //  B2IB:   store from Buffer into Index'ed Buffer
+
+            Method (FB2P)
+            {   //  FB2P:   store from Field Buffer into Index'ed Package
+                Name (DEST, Package (2) {})
+
+                //  initialize memory using 32-bit field elements
+                Store (0x01234567, \_SB.MEM.SMD0)
+                Store (0x89ABCDEF, \_SB.MEM.SMD1)
+                Store (0xFEDCBA98, \_SB.MEM.SMD2)
+                Store (0x76543210, \_SB.MEM.SMD3)
+
+                //  move greater than 64-bit buffers into DEST package
+                Store (\_SB.MEM.SME0, Index (DEST, 0))
+                Store (\_SB.MEM.SME1, Index (DEST, 1))
+
+                //  validate DEST contents
+                Store (DerefOf (Index (DEST, 0, )), Local0)
+                Store (DerefOf (Index (DEST, 1, )), Local1)
+
+                //  verify Local0 and Local1 are Buffers
+                Store (ObjectType (Local0), Local2)
+                if (LNotEqual (Local2, 3))  //  Buffer type is 3
+                {
+                    Return (0x11)
+                }
+
+                Store (ObjectType (Local1), Local3)
+                if (LNotEqual (Local3, 3))  //  Buffer type is 3
+                {
+                    Return (0x12)
+                }
+
+                //  validate DEST buffer contents
+                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4)
+                If (LNotEqual (Local4, 0x67))
+                {
+                    Return (0x13)
+                }
+
+                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4)
+                If (LNotEqual (Local4, 0x45))
+                {
+                    Return (0x14)
+                }
+
+                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4)
+                If (LNotEqual (Local4, 0xEF))
+                {
+                    Return (0x15)
+                }
+
+                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4)
+                If (LNotEqual (Local4, 0xCD))
+                {
+                    Return (0x16)
+                }
+
+                Store ("Store(Mem,PkgElement) PASS", Debug)
+
+
+                //  validate changing source \_SB.MEM.SMD* does not impact DEST
+                Store (0x12345678, \_SB.MEM.SMD0)
+
+                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5)
+                If (LNotEqual (Local5, 0x67))
+                {
+                    Return (0x21)
+                }
+
+                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5)
+                If (LNotEqual (Local5, 0x45))
+                {
+                    Return (0x22)
+                }
+
+                //  validate changing DEST does not impact source \_SB.MEM.SMD*
+                Store (0x30, Index (DerefOf (Index (DEST, 0)), 0))
+
+                Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5)
+                If (LNotEqual (Local5, 0x30))
+                {
+                    Return (0x23)
+                }
+
+                //
+                // This section was modified from the original iPCO code because
+                //  it attempted to compare two buffers.  This is not allowed until
+                //  ACPI v2.0, so the test has been modified to just check the
+                //  changed \_SB.MEM.SMD0
+                //
+                Store (\_SB.MEM.SMD0, Local5)
+
+                If(LNotEqual(Local5, 0x12345678))
+                {
+                    Return (0x24)
+                }
+
+                Store ("Mem and Pkg independent PASS", Debug)
+
+
+                Return (0)
+            }   //  FB2P:   store from Field Buffer into Index'ed Package
+
+            Method (TEST)
+            {
+                Store ("++++++++ IndexOp2 Test", Debug)
+
+                //  store _BIF package return value into Local0
+
+                Store (\_SB.BAT1._BIF, Local0)
+
+                //  save Local0 object type value into Local1
+                Store (ObjectType (Local0), Local1)
+
+                //  validate Local0 is a Package
+                If (LNotEqual (Local1, 4))  //  Package type is 4
+                {
+                    //  failure
+                    Return (2)
+                }
+
+                //  validate source and destination buffers are independent of each
+                //  of each other (i.e., changing one's contents does not change
+                //  other's contents) using B2IB (store from Buffer into Index'ed
+                //  Buffer) and FB2P (store from Field Buffer into Index'ed Package)
+
+                //  call B2IB (store from Buffer into Index'ed Buffer)
+                Store (B2IB, Local2)    //  Local2 is B2IB return value
+
+                //  save Local2 object type value into Local3
+                Store (ObjectType (Local2), Local3)
+
+                //  validate Local2 is a Number
+                If (LNotEqual (Local3, 1))  //  Number type is 1
+                {
+                    //  failure
+                    Return (4)
+                }
+
+                //  zero indicates pass, non-zero is an error code
+                If (LNotEqual (Local2, 0))
+                {
+                    //  return B2IB error code
+                    Return (Local2)
+                }
+
+                //  call FB2P (store from Field Buffer into Index'ed Package)
+                Store (FB2P, Local2)    //  Local2 is FB2P return value
+
+                //  save Local2 object type value into Local3
+                Store (ObjectType (Local2), Local3)
+
+                //  validate Local2 is a Number
+                If (LNotEqual (Local3, 1))  //  Number type is 1
+                {
+                    //  failure
+                    Return (5)
+                }
+
+                //  zero indicates pass, non-zero is an error code
+                If (LNotEqual (Local2, 0))
+                {
+                    //  return FB2P error code
+                    Return (Local2)
+                }
+
+
+                Return (0)
+            }   //  TEST
+        }   //  IDX2:   Test device name
+    }   //  _SB system bus
+
+//
+// test SizeOf.asl
+//
+//  Test for SizeOf
+//      test cases include following SizeOf arguments:
+//          buffer, buffer field;
+//          control method argument, control method local variable;
+//          control method return values;
+//          direct string, string;
+//          package;
+//          buffer, package, and string package elements
+//
+// MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,...
+//  calls because it is not legal to perform a SizeOf operation on a Buffer Field.
+//  This test has also been extended to test additional Package element sizes.
+//
+    Device (SIZO)
+    {
+        //  SAR0 control method validates SizeOf(Arg)
+        //      SAR0 should only be called by SARG
+        Method (SAR0, 2)
+        //  Arg0    object to determine size of
+        //  Arg1    expected Arg length
+        {   //  SAR0:   SizeOf(Arg) test control method
+            //  Local0  Arg0 length
+            //  Local1  Local0 object type
+
+            //  Store first string size (Arg0) into Local7
+            Store (SizeOf (Arg0), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+                {   Return (0x21)   }
+
+            //  If strings are not of equal size, return error code
+            If (LNotEqual (Local0, Arg1))
+                {   Return (0x22)   }
+
+            Return (0)
+        }   //  SAR0:   SizeOf(Arg) test control method
+
+        Method (SARG)
+        {   //  SARG:   SizeOf(Arg) test control method
+            Name (BUFR, Buffer (12) {}) //  uninitialized Buffer
+            Name (BUF1, Buffer() {0x01, 0x02, 0x03, 0x04, 0x05})
+            Name (PKG0, Package (4) {}) //  uninitialized Package
+            Name (STR0, "String")
+            Name (PKG1, Package (4)
+            {
+                BUFR,
+                "String2",
+                STR0,
+                PKG0
+            })  //  PKG1
+
+            Name (PKG2, Package (4)
+            {
+                Buffer (15) {},
+                "String 1",
+                Package (2) {}
+            })  //  PKG2
+
+            //  Namespace entry buffer reference
+            Store (SAR0 (BUFR, 12), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x23)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=BUFR) PASS", Debug)
+
+
+            //  Namespace entry package reference
+            Store (SAR0 (PKG0, 4), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x24)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=PKG0) PASS", Debug)
+
+
+            //  Namespace entry string reference
+            Store (SAR0 (STR0, 6), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x25)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=STR0) PASS", Debug)
+
+
+            //  direct string reference
+            Store (SAR0 ("String", 6), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x26)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=String) PASS", Debug)
+
+            Store (0x55, Index (BUF1, 2))
+
+            /****************************************************
+            //
+            // This section is commented because it is illegal to
+            //  perform a SizeOf operation on a Buffer Field
+            //
+            //  Namespace BufferField reference
+            Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+                {   Return (0x27)   }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+                {   Return (Local0) }
+
+            Store ("SizeOf(Arg=BufferField) PASS", Debug)
+            ****************************************************/
+
+            //  Namespace BufferPackageElement reference
+            //
+            Store (SAR0 (Index(PKG1, 0), 12), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x28)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug)
+
+
+            //  Namespace StringPackageElement reference
+            Store (SAR0 (Index (PKG1, 1, ), 7), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x29)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=Package String Element) PASS", Debug)
+
+
+            //  Namespace StringPackageElement reference
+            Store (SAR0 (Index (PKG1, 2, ), 6), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x2A)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug)
+
+
+            //  Namespace PackagePackageElement reference
+            Store (SAR0 (Index (PKG1, 3, ), 4), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x2B)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug)
+
+            // Package Buffer Element
+            Store (SAR0 (Index (PKG2, 0), 15), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x2B)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug)
+
+            // Package String Element
+            Store (SAR0 (Index (PKG2, 1), 8), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x2B)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=Package String Element) PASS", Debug)
+
+            // Package Package Element
+            Store (SAR0 (Index (PKG2, 2), 2), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x2B)
+            }
+
+            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
+            {
+                Return (Local0)
+            }
+
+            Store ("SizeOf(Arg=Package Package Element) PASS", Debug)
+
+            Store ("SizeOf(Arg) PASS", Debug)
+
+            Return (0)
+        }   //  SARG:   SizeOf(Arg) test control method
+
+        Method (SBUF)
+        {   //  SBUF:   SizeOf(Buffer) test control method
+            Name (BUFR, Buffer (12) {})
+
+            //  store size of BUFR buffer into Local0
+            Store (SizeOf (BUFR), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x31)
+            }
+
+            If (LNotEqual (Local0, 12))     //  BUFR size is 12
+            {
+                Return (0x32)
+            }
+
+            Store ("SizeOf(BUFR) PASS", Debug)
+
+            Return (0)
+        }   //  SBUF:   SizeOf(Buffer) test control method
+
+
+        /****************************************************
+        //
+        // This section is commented because it is illegal to
+        //  perform a SizeOf operation on a Buffer Field
+        //
+        Method (SIND)
+        {   //  SIND:   SizeOf(Index(,,)) test control method
+            Name (BUFR, Buffer (12) {})
+
+            //  store size of Index(BUFR,2,) buffer into Local0
+            Store (SizeOf (Index (BUFR, 2, )), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x41)
+            }
+
+            If (LNotEqual (Local0, 10))     //  12 - 2 = 10
+            {
+                Return (0x42)
+            }
+
+            Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
+
+            //  TBD:    strings and packages
+
+            Return (0)
+        }   //  SIND:   SizeOf(Index(,,)) test control method
+        ****************************************************/
+
+        Method (SLOC)
+        {   //  SLOC:   SizeOf(Local) test control method
+            Name (BUFR, Buffer (12) {}) //  uninitialized Buffer
+            Name (STR0, "String")
+            Name (PKG0, Package (4) {}) //  uninitialized Package
+
+
+            //  store BUFR Buffer into Local2
+            Store (BUFR, Local2)
+
+            //  store size of BUFR buffer into Local0
+            Store (SizeOf (Local2), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x51)
+            }
+
+            If (LNotEqual (Local0, 12)) //  BUFR size is 12
+            {
+                Return (0x52)
+            }
+
+            Store ("SizeOf(Local2=Buffer) PASS", Debug)
+
+
+            //  store STR0 string into Local2
+            Store (STR0, Local2)
+
+            //  store size of STR0 buffer into Local0
+            Store (SizeOf (Local2), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x53)
+            }
+
+            If (LNotEqual (Local0, 6))      //  STR0 size is 6
+            {
+                Return (0x54)
+            }
+
+            Store ("SizeOf(Local2=String) PASS", Debug)
+
+
+            //  store PKG0 Package into Local2
+            Store (PKG0, Local2)
+
+            //  store size of PKG0 buffer into Local0
+            Store (SizeOf (Local2), Local0)
+
+            //  save Local0 object type value into Local1
+            Store (ObjectType (Local0), Local1)
+
+            //  validate Local0 is a Number
+            If (LNotEqual (Local1, 1))      //  Number type is 1
+            {
+                Return (0x55)
+            }
+
+            If (LNotEqual (Local0, 4))      //  PKG0 size is 4
+            {
+                Return (0x56)
+            }
+
+            Store ("SizeOf(Local2=Package) PASS", Debug)
+
+
+            Return (0)
+        }   //  SLOC:   SizeOf(Local) test control method
+
+        Method (TEST)
+        {
+            Store ("++++++++ SizeOf Test", Debug)
+
+            //  Store current operating system string into Local0
+            Store (_OS, Local0)
+
+            Store (SizeOf (_OS), Local3)
+
+            //  save Local3 object type value into Local4
+            Store (ObjectType (Local3), Local4)
+
+            //  validate Local3 is a Number
+            If (LNotEqual (Local4, 1))  //  Number type is 1
+            {
+                //  failure
+                Return (0x61)
+            }
+
+            //  Store current operating system string into Local0
+            //  This verifies above SizeOf(_OS) did not corrupt ACPI namespace
+            Store (_OS, Local0)
+
+            //  Store SARG [Validate SizeOf(Arg)] return value into Local1
+            Store (SARG, Local1)
+
+            //  save Local1 object type value into Local2
+            Store (ObjectType (Local1), Local2)
+
+            //  validate Local1 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+            {
+                //  failure
+                Return (0x62)
+            }
+
+            //  zero indicates pass, non-zero is an error code
+            If (LNotEqual (Local1, 0))
+            {
+                //  return SARG error code
+                Return (Local1)
+            }
+
+
+            //  Store SBUF [Validate SizeOf(Buffer)] return value into Local1
+            Store (SBUF, Local1)
+
+            //  save Local1 object type value into Local2
+            Store (ObjectType (Local1), Local2)
+
+            //  validate Local1 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+            {
+                //  failure
+                Return (0x63)
+            }
+
+            //  zero indicates pass, non-zero is an error code
+            If (LNotEqual (Local1, 0))
+            {
+                //  return SBUF error code
+                Return (Local1)
+            }
+
+            /****************************************************
+            //
+            // This section is commented because it is illegal to
+            //  perform a SizeOf operation on a Buffer Field
+            //
+            //  Store SIND [verify SizeOf(Index(,,))] return value into Local1
+            Store (SIND, Local1)
+
+            //  save Local1 object type value into Local2
+            Store (ObjectType (Local1), Local2)
+
+            //  validate Local1 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+            {
+                //  failure
+                Return (0x64)
+            }
+
+            //  zero indicates pass, non-zero is an error code
+            If (LNotEqual (Local1, 0))
+            {
+                //  return SARG error code
+                Return (Local1)
+            }
+            ****************************************************/
+
+            //  Store SLOC [verify SizeOf(Local)] return value into Local1
+            Store (SLOC, Local1)
+
+            //  save Local1 object type value into Local2
+            Store (ObjectType (Local1), Local2)
+
+            //  validate Local1 is a Number
+            If (LNotEqual (Local2, 1))  //  Number type is 1
+            {
+                //  failure
+                Return (0x65)
+            }
+
+            //  zero indicates pass, non-zero is an error code
+            If (LNotEqual (Local1, 0))
+            {
+                //  return SLOC error code
+                Return (Local1)
+            }
+
+
+            //  TBD:    SizeOf (METH) -- where METH control method returns
+            //              buffer, BufferField, string, package, package element
+
+
+            Return (0)
+        }   //  TEST
+    }   //  SIZO
+
+//
+// test SmiShare.asl
+//
+    Scope (\_SB)    //  System Bus
+    {   //  _SB system bus
+        //  Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
+        OperationRegion(RAM1, SystemMemory, 0x400000, 0xA)
+
+        Field (RAM1, AnyAcc, NoLock, Preserve)
+        {
+            BI1T, 1,        // Create some bits in memory to access
+            BI2T, 2,
+            BI3T, 3,
+            LST2, 2
+        }   //  End Field RAM1
+
+        Field (RAM1, WordAcc, NoLock, WriteAsZeros)
+        {
+            WRD, 16
+        }   //  End 2nd Field RAM1
+
+        Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
+        {
+            BYTE, 8
+        }   //  End 3rd Field RAM1
+
+        Field (RAM1, ByteAcc, NoLock, Preserve)
+        {
+            SMIC, 8,
+            SMID, 8
+        }
+
+        Device (MBIT)
+        {
+            Method (_INI)
+            {
+                Store (0, BI1T)
+                Store (3, BI2T)
+                Store (7, BI3T)
+                Store (0, LST2)
+            }   //  End _INI Method
+        }   //  End Device MBIT
+
+        Device (MWRD)
+        {
+            Method (_INI)
+            {
+                Store (0, WRD)
+            }   //  End _INI Method
+        }   //  End Device MWRD
+
+        Device (MBYT)
+        {
+            Method (_INI)
+            {
+                Store (0, BYTE)
+                Store (0xC, SMIC)
+                Store (0xD, SMID)
+            }   //  End _INI Method
+        }   //  End Device MBYT
+
+    /*
+        //  Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
+        OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
+
+        Field (\RAM1, AnyAcc, NoLock, Preserve)
+        {
+            BI1T, 1,        // Create some bits in memory to access
+            BI2T, 2,
+            BI3T, 3,
+            LST2, 2
+        }   //  End Field RAM1
+
+        Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
+        {
+            WRD, 16
+        }   //  End 2nd Field RAM1
+
+        Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
+        {
+            BYTE, 8
+        }   //  End 3rd Field RAM1
+
+        Field (\RAM1, ByteAcc, NoLock, Preserve)
+        {
+            SMIC, 8,
+            SMID, 8
+        }
+    */
+        Method (SMIX)
+        {
+            Return (BYTE)
+        }   //  End SMIX
+
+        Method (EVNT)
+        {
+            Store (SMIX, Local0)
+
+            If (And (Local0, 0x01))
+            {   Notify (\_SB_.SMIS, 0x21)}
+
+            If (And (Local0, 0x02))
+            {   Notify (\_SB_.SMIS, 0x22)}
+
+            If (And (Local0, 0x04))
+            {   Notify (\_SB_.SMIS, 0x24)}
+
+            If (And (Local0, 0x08))
+            {   Notify (\_SB_.SMIS, 0x28)}
+
+        }   //  End Method EVNT
+
+        Device (SMIS)
+        {
+            Method (BINK)
+            {
+                Store (0, Local0)               //  Zero out Local0
+
+                If (LNotEqual (SMID, 0xD))
+                {   Or (0x80, Local0, Local0)}
+
+                If (LNotEqual (SMIC, 0xC))
+                {   Or (0x40, Local0, Local0)}
+
+                If (LNotEqual (BYTE, 0))
+                {   Or (0x20, Local0, Local0)}
+
+                If (LNotEqual (WRD, 0))
+                {   Or (0x10, Local0, Local0)}
+
+                If (LNotEqual (LST2, 0))
+                {   Or (0x8, Local0, Local0)}
+
+                If (LNotEqual (BI3T, 0x7))
+                {   Or (0x4, Local0, Local0)}
+
+                If (LNotEqual (BI2T, 0x3))
+                {   Or (0x2, Local0, Local0)}
+
+                If (LNotEqual (BI1T, 0))
+                {   Or (0x1, Local0, Local0)}
+
+                Return (Local0)
+            }   //  End Method BINK
+
+            Method (TEST)
+            {
+                Store ("++++++++ SmiShare Test", Debug)
+
+                //  Expect EVNT to generate Notify value we just previously
+                //  stored in BYTE
+                Store (0x20, BYTE)
+                EVNT ()
+                Store (0x21, BYTE)
+                EVNT ()
+                Store (0x22, BYTE)
+                EVNT ()
+                Store (0x23, BYTE)
+                EVNT ()
+
+                Return (0)  //  pass
+            }   //  End Method TEST
+        }   //  Device SMIS
+
+        Device(CNDT)
+        {
+            Method(TEST)
+            {
+                If (ECOK)
+                {
+                    return("Broken")
+                }
+                Else
+                {
+                    return("Works")
+                }
+            }
+
+            Method(ECOK)
+            {
+                Return(0x0)
+            }
+        }
+
+    }   //  _SB system bus
+
+
+/* Test a very big buffer */
+
+    Name(WQAB, Buffer(6756)
+    {
+        0x46,0x4F,0x4D,0x42,0x01,0x00,0x00,0x00,
+        0x54,0x1A,0x00,0x00,0xBA,0xAD,0x00,0x00,
+        0x44,0x53,0x00,0x01,0x1A,0x7D,0xDA,0x54,
+        0x98,0xBD,0x92,0x00,0x01,0x06,0x18,0x42,
+        0x10,0x47,0x10,0x92,0x46,0x62,0x02,0x89,
+        0x80,0x90,0x18,0x18,0x14,0x81,0x85,0x00,
+        0x49,0x02,0x88,0xC4,0x41,0xE1,0x20,0xD4,
+        0x9F,0x40,0x7E,0x05,0x20,0x74,0x28,0x40,
+        0xA6,0x00,0x83,0x02,0x9C,0x22,0x88,0xA0,
+        0x57,0x01,0x36,0x05,0x98,0x14,0x60,0x51,
+        0x80,0x76,0x01,0x96,0x05,0xE8,0x16,0x20,
+        0x1D,0x96,0x88,0x04,0x47,0x89,0x01,0x47,
+        0xE9,0xC4,0x16,0x6E,0xD8,0xE0,0x85,0xA2,
+        0x68,0x06,0x51,0x12,0x94,0x8B,0x20,0x5D,
+        0x10,0x52,0x2E,0xC0,0x37,0x82,0x06,0x10,
+        0xA5,0x77,0x01,0xB6,0x05,0x98,0x86,0x27,
+        0xD2,0x20,0xE4,0x60,0x08,0x54,0xCE,0x80,
+        0x20,0x69,0x44,0x21,0x1E,0xA7,0x44,0x08,
+        0x0A,0x84,0x90,0xD4,0xF1,0xA0,0xA0,0x71,
+        0x88,0xAD,0xCE,0x46,0x93,0xA9,0x74,0x7E,
+        0x48,0x82,0x70,0xC6,0x2A,0x7E,0x3A,0x9A,
+        0xD0,0xD9,0x9C,0x60,0xE7,0x18,0x72,0x3C,
+        0x48,0xF4,0x20,0xB8,0x00,0x0F,0x1C,0x2C,
+        0x34,0x84,0x22,0x6B,0x80,0xC1,0x8C,0xDD,
+        0x63,0xB1,0x0B,0x4E,0x0A,0xEC,0x61,0xB3,
+        0x01,0x19,0xA2,0x24,0x38,0xD4,0x11,0xC0,
+        0x12,0x05,0x98,0x1F,0x87,0x0C,0x0F,0x95,
+        0x8C,0x25,0x24,0x1B,0xAB,0x87,0xC2,0xA5,
+        0x40,0x68,0x6C,0x27,0xED,0x19,0x45,0x2C,
+        0x79,0x4A,0x82,0x49,0xE0,0x51,0x44,0x36,
+        0x1A,0x27,0x28,0x1B,0x1A,0x25,0x03,0x42,
+        0x9E,0x05,0x58,0x07,0x26,0x04,0x76,0x2F,
+        0xC0,0x9A,0x00,0x73,0xB3,0x90,0xB1,0xB9,
+        0xE8,0xFF,0x0F,0x71,0xB0,0x31,0xDA,0x9A,
+        0xAE,0x90,0xC2,0xC4,0x88,0x12,0x2C,0x5E,
+        0xC5,0xC3,0x10,0xCA,0x93,0x42,0xA8,0x48,
+        0x95,0xA1,0x68,0xB4,0x51,0x2A,0x14,0xE0,
+        0x4C,0x80,0x30,0x5C,0x1D,0x03,0x82,0x46,
+        0x88,0x15,0x29,0x56,0xFB,0x83,0x20,0xF1,
+        0x2D,0x40,0x54,0x01,0xA2,0x48,0xA3,0x41,
+        0x9D,0x03,0x3C,0x5C,0x0F,0xF5,0xF0,0x3D,
+        0xF6,0x93,0x0C,0x72,0x90,0x67,0xF1,0xA8,
+        0x70,0x9C,0x06,0x49,0xE0,0x0B,0x80,0x4F,
+        0x08,0x1E,0x38,0xDE,0x35,0xA0,0x66,0x7C,
+        0xBC,0x4C,0x10,0x1C,0x6A,0x88,0x1E,0x68,
+        0xB8,0x13,0x38,0x44,0x06,0xE8,0x49,0x3D,
+        0x52,0x60,0x07,0x77,0x32,0xEF,0x01,0xAF,
+        0x0A,0xCD,0x5E,0x12,0x08,0xC1,0xF1,0xF8,
+        0x7E,0xC0,0x26,0x9C,0xC0,0xF2,0x07,0x81,
+        0x1A,0x99,0xA1,0x3D,0xCA,0xD3,0x8A,0x19,
+        0xF2,0x31,0xC1,0x04,0x16,0x0B,0x21,0x05,
+        0x10,0x1A,0x0F,0xF8,0x6F,0x00,0x8F,0x17,
+        0xBE,0x12,0xC4,0xF6,0x80,0x12,0x0C,0x0B,
+        0x21,0x23,0xAB,0xF0,0x78,0xE8,0x28,0x7C,
+        0x95,0x38,0x9C,0xD3,0x8A,0x67,0x82,0xE1,
+        0x20,0xF4,0x05,0x90,0x00,0x51,0xE7,0x0C,
+        0xD4,0x61,0xC1,0xE7,0x04,0x76,0x33,0x38,
+        0x83,0x47,0x00,0x8F,0xE4,0x84,0xFC,0x2B,
+        0xF1,0xC0,0xE0,0x03,0xE2,0xEF,0x1F,0xA7,
+        0xEC,0x11,0x9C,0xA9,0x01,0x7D,0x1C,0xF0,
+        0xFF,0x7F,0x28,0x7C,0x88,0x1E,0xDF,0x29,
+        0x1F,0xAF,0x4F,0x17,0x96,0x35,0x4E,0xE8,
+        0x77,0x08,0x9F,0x38,0x7C,0x64,0x71,0x44,
+        0x08,0x39,0x39,0x05,0xA0,0x81,0x4F,0xF7,
+        0xEC,0x22,0x9C,0xAE,0x27,0xE5,0x40,0xC3,
+        0xA0,0xE3,0x04,0xC7,0x79,0x00,0x1C,0xE3,
+        0x84,0x7F,0x2E,0x80,0x3F,0x40,0x7E,0xCA,
+        0x78,0xC5,0x48,0xE0,0x98,0x23,0x44,0x9F,
+        0x6B,0x3C,0x42,0x2C,0xFC,0x53,0x45,0xE1,
+        0x03,0x21,0x63,0x04,0x17,0xA0,0xC7,0x08,
+        0x7C,0x03,0x8E,0x11,0x7D,0x94,0xE0,0xEA,
+        0x0F,0x1A,0x74,0x80,0xB8,0xFF,0xFF,0x00,
+        0xE1,0x83,0x7A,0x80,0xC0,0x37,0xFA,0xD1,
+        0x03,0x3D,0x2E,0x8B,0x3E,0x0F,0xC8,0xF8,
+        0x89,0x46,0xF3,0xE2,0xA7,0x03,0x7E,0xF8,
+        0x00,0x0F,0xA8,0x87,0x84,0x03,0xC5,0x4C,
+        0x9B,0x83,0x3E,0xBB,0x1C,0x3A,0x76,0xB8,
+        0xE0,0x3F,0x81,0x80,0x4B,0xDE,0x21,0x0C,
+        0x14,0x23,0xC6,0x9F,0x83,0x7C,0x0A,0x03,
+        0xFF,0xFF,0xFF,0x14,0x06,0xFE,0xE1,0xF0,
+        0x20,0x4F,0x07,0x9F,0xB6,0xA8,0x74,0x18,
+        0xD4,0x81,0x0B,0xB0,0x32,0x89,0x08,0xCF,
+        0x12,0xB5,0x41,0xE8,0xD4,0xF0,0x36,0xF1,
+        0xB6,0xE5,0x5B,0x40,0x9C,0xD3,0xEC,0xED,
+        0xC0,0x45,0x30,0x22,0xD4,0x0C,0x45,0x4E,
+        0x5A,0x11,0x63,0x44,0x79,0xDC,0x32,0xCA,
+        0xDB,0xD6,0x0B,0x40,0xBC,0x13,0x7B,0xDE,
+        0x32,0x46,0xF0,0xC8,0x0F,0x5C,0x2C,0xC6,
+        0xEA,0xF5,0x5F,0xF3,0x81,0x0B,0x70,0xF6,
+        0xFF,0x3F,0x70,0x01,0x1C,0x0A,0x7A,0x18,
+        0x42,0x0F,0xC3,0x53,0x39,0x97,0x87,0xC8,
+        0x53,0x89,0x18,0x35,0x4C,0xD4,0x67,0x28,
+        0xDF,0x2D,0x7C,0x20,0x02,0xDF,0x99,0x0B,
+        0xF8,0xFD,0xFF,0x0F,0x44,0x70,0x8E,0x29,
+        0xB8,0x33,0x0D,0x78,0x7C,0xCE,0x40,0x20,
+        0xA7,0xE2,0x43,0x0D,0x60,0x41,0xF4,0x13,
+        0xC2,0x27,0x1A,0x2A,0x13,0x06,0x75,0xA8,
+        0x01,0xAC,0x5C,0x61,0x9E,0x46,0xCF,0xF9,
+        0x59,0xC6,0xA7,0x1A,0x1F,0x4A,0x8D,0x63,
+        0x88,0x97,0x99,0x87,0x1A,0x1F,0x0B,0x5E,
+        0x49,0x7D,0xA8,0x31,0x54,0x9C,0x87,0x1A,
+        0x0F,0x37,0x50,0xD4,0x37,0x9B,0x67,0x1B,
+        0xA3,0xC7,0xF7,0x0D,0xD5,0x10,0x0F,0x35,
+        0x4C,0xF2,0x4A,0x35,0x16,0x1F,0x6A,0xC0,
+        0xF1,0xFF,0x3F,0xD4,0x00,0xFC,0xFF,0xFF,
+        0x1F,0x6A,0x00,0x47,0x47,0x03,0x38,0x47,
+        0x46,0xDC,0xD1,0x00,0x5C,0x87,0x52,0xE0,
+        0x70,0x34,0x00,0x1E,0x47,0x21,0x30,0x5F,
+        0x68,0x7C,0x14,0x02,0x16,0xFF,0xFF,0xA3,
+        0x10,0xF8,0x65,0x9F,0x83,0x50,0x42,0x8F,
+        0x42,0x80,0xA0,0xDB,0xCF,0x53,0xC4,0xB3,
+        0x8F,0x2F,0x3F,0x0F,0x04,0x11,0x5E,0xF3,
+        0x7D,0x0A,0xF2,0x21,0xDF,0x47,0x21,0x06,
+        0x63,0x28,0x5F,0x83,0x7C,0x14,0x62,0x50,
+        0xAF,0x41,0xBE,0xEF,0x1B,0xE4,0xF1,0x22,
+        0x48,0xEC,0x67,0x02,0x1F,0x85,0x98,0xE8,
+        0xA3,0x10,0xA0,0xF0,0xFF,0x7F,0x14,0x02,
+        0xF8,0xFF,0xFF,0x3F,0x0A,0x01,0xCE,0x02,
+        0x1C,0x0D,0x40,0x37,0xAD,0x47,0x21,0xF0,
+        0xDE,0x59,0x4E,0xFB,0x04,0x7C,0x16,0x02,
+        0xCC,0xFE,0xFF,0xCF,0x42,0xC0,0xEC,0x28,
+        0x74,0x14,0x67,0xF9,0x2A,0xF4,0x04,0xF0,
+        0x02,0x10,0x23,0xCC,0x3B,0xD0,0x4B,0x26,
+        0xBB,0x8B,0x1B,0xE7,0xC9,0xE5,0x2C,0x9E,
+        0xC4,0x7D,0x09,0xF2,0x81,0xE2,0x59,0xC8,
+        0x50,0xA7,0x1B,0xF4,0x8D,0xDC,0x03,0x8B,
+        0x19,0x3F,0xC4,0xF3,0x90,0x21,0x9E,0x85,
+        0x00,0x76,0xFD,0xFF,0xCF,0x42,0x00,0xFF,
+        0xFF,0xFF,0x47,0x03,0xF8,0x2F,0x00,0x9F,
+        0x85,0x80,0xE7,0x09,0xE0,0x41,0xDB,0x67,
+        0x21,0x80,0x33,0x87,0xCB,0xF3,0x7F,0x05,
+        0x3A,0x96,0xF7,0x08,0xCF,0xFA,0x24,0x5F,
+        0x2F,0x3D,0xD3,0x87,0x82,0x67,0x21,0x86,
+        0x75,0x18,0x3E,0x0B,0x31,0x88,0x17,0x4D,
+        0x43,0xBC,0x70,0xFA,0x30,0xE0,0xFF,0x3F,
+        0x5E,0xE0,0x57,0x4E,0x03,0x05,0x09,0xF4,
+        0x2C,0x04,0x30,0xFE,0xFF,0x7F,0x16,0x02,
+        0xC8,0xB8,0x46,0x9D,0x85,0x80,0xE5,0x6D,
+        0xE5,0x19,0xDB,0xA7,0x95,0x04,0xFF,0xFF,
+        0x67,0x21,0xC0,0x41,0x2E,0x23,0x07,0x21,
+        0x4C,0xC4,0x87,0x83,0x8F,0x99,0x80,0x9E,
+        0x29,0xBE,0xB8,0x1B,0xE3,0x09,0xE0,0x45,
+        0xE2,0x31,0x93,0x1D,0x35,0x0D,0xF3,0x2C,
+        0x64,0xBC,0xB3,0x78,0x0D,0x78,0x82,0xF7,
+        0xE4,0x9F,0x85,0x18,0xD8,0x61,0x05,0x7B,
+        0x14,0x32,0xA8,0xC1,0x63,0x87,0x08,0x13,
+        0xE8,0x59,0x88,0xC5,0x7D,0xAE,0xE8,0x3C,
+        0xE1,0xB3,0x10,0xF0,0xFE,0xFF,0x9F,0x25,
+        0xE0,0x5E,0x0D,0x9E,0x85,0x00,0x13,0x87,
+        0x0D,0x9F,0x35,0xC0,0x33,0x7C,0x8F,0xEA,
+        0x1C,0x1E,0x8F,0x81,0x7F,0x56,0x1D,0xE7,
+        0x04,0x96,0x7B,0xD1,0xB2,0x71,0xA0,0xA1,
+        0x23,0xB2,0x3A,0x20,0x8D,0x0D,0x73,0x29,
+        0x89,0x7C,0x72,0x6C,0xD4,0x56,0x04,0xA7,
+        0x33,0x93,0x4F,0x00,0xD6,0x42,0x21,0x05,
+        0x34,0x1A,0x8B,0xE1,0x9D,0xF9,0xE8,0x44,
+        0x41,0x0C,0xE8,0xE3,0x90,0x6D,0x1C,0x0A,
+        0x50,0x7B,0xD1,0x14,0xC8,0x39,0x07,0xA3,
+        0x7F,0x76,0x74,0x36,0xBE,0x13,0x70,0x0D,
+        0x10,0x3A,0x25,0x18,0xDA,0x6A,0x04,0xFC,
+        0xFF,0x67,0x89,0x01,0x33,0xFE,0x53,0x8C,
+        0x09,0x7C,0x8E,0xC1,0x1F,0x0C,0xF0,0x03,
+        0x7F,0x31,0xA8,0xFA,0x5E,0xA0,0xFB,0x82,
+        0xD5,0xDD,0x64,0x20,0xCC,0xC8,0x04,0xF5,
+        0x9D,0x0E,0x40,0x01,0xE4,0x0B,0x81,0xCF,
+        0x51,0x0F,0x05,0x6C,0x22,0x21,0xC2,0x44,
+        0x33,0x3A,0x62,0xC2,0xA8,0xE8,0x13,0xA6,
+        0x20,0x9E,0xB0,0x63,0x4D,0x18,0x3D,0x13,
+        0x5F,0x74,0xD8,0x88,0x31,0x21,0xAE,0x1E,
+        0xD0,0x26,0x18,0xD4,0x97,0x22,0x58,0x43,
+        0xE6,0x63,0xF1,0x05,0x02,0x37,0x65,0x30,
+        0xCE,0x89,0x5D,0x13,0x7C,0xD9,0xC1,0xCD,
+        0x19,0x8C,0xF0,0x98,0xBB,0x18,0xBF,0x3A,
+        0x79,0x74,0xFC,0xA0,0xE0,0x1B,0x0E,0xC3,
+        0x7E,0x32,0xF3,0x8C,0xDE,0xCB,0x7C,0x8D,
+        0xC3,0xC0,0x7A,0xBC,0x1C,0xD6,0x68,0x61,
+        0x0F,0xED,0x3D,0xC4,0xFF,0xFF,0x43,0x8C,
+        0xCF,0x13,0xC6,0x08,0xEB,0xDB,0x0B,0x38,
+        0xEE,0x59,0xF0,0xEF,0x1A,0xE0,0xB9,0x84,
+        0xF8,0xAE,0x01,0x30,0xF0,0xFF,0x7F,0xD7,
+        0x00,0x4E,0xD7,0x04,0xDF,0x35,0x80,0xF7,
+        0xD0,0x7D,0xD7,0x00,0xAE,0xD9,0xEF,0x1A,
+        0xA8,0x63,0x80,0x15,0xDE,0x35,0xA0,0x5D,
+        0xD9,0xDE,0xD7,0x9E,0xB0,0xAC,0xE9,0xB2,
+        0x81,0x52,0x73,0xD9,0x00,0x14,0xFC,0xFF,
+        0x2F,0x1B,0x80,0x01,0x29,0x13,0x46,0x85,
+        0x9F,0x30,0x05,0xF1,0x84,0x1D,0xEC,0xB2,
+        0x01,0x8A,0x18,0x97,0x0D,0xD0,0x8F,0xED,
+        0x65,0x03,0x18,0xDC,0x13,0xF8,0x6D,0x03,
+        0x78,0x43,0xFA,0xB6,0x01,0xD6,0xFF,0xFF,
+        0x6D,0x03,0xAC,0xF9,0x6F,0x1B,0x28,0x0E,
+        0xAB,0xBC,0x6D,0x40,0x3C,0xC9,0x33,0x02,
+        0xAB,0xBA,0x6E,0xA0,0xF4,0x5C,0x37,0x00,
+        0x12,0x88,0x99,0x30,0x2A,0xFE,0x84,0x29,
+        0x88,0x27,0xEC,0x68,0xD7,0x0D,0x50,0x04,
+        0xB9,0x6E,0x80,0x7E,0x5E,0x09,0xFE,0xFF,
+        0xAF,0x1B,0xC0,0xE0,0xA2,0x80,0xB9,0x6F,
+        0x00,0x6F,0x58,0x7E,0xDF,0x00,0x7C,0xDC,
+        0xC4,0x31,0xF7,0x0D,0xC0,0xCC,0xFF,0xFF,
+        0xBE,0x01,0xB0,0xE7,0xA2,0x80,0xBB,0x6F,
+        0x00,0xEF,0x8B,0xB4,0xEF,0x1B,0x60,0xFE,
+        0xFF,0xDF,0x37,0xC0,0x28,0x6D,0xFD,0x1E,
+        0x1C,0x3D,0x21,0x78,0x7C,0xB8,0xFB,0xA5,
+        0xC7,0xE7,0xBB,0x39,0x38,0x06,0x79,0x8C,
+        0x87,0x76,0xC0,0xAF,0xEF,0x9E,0x98,0xEF,
+        0xE6,0xC0,0xFF,0x4C,0x70,0x3C,0x18,0x68,
+        0x1C,0x62,0xAB,0x97,0x06,0x72,0x34,0x38,
+        0x3F,0xDC,0x19,0x81,0x61,0x15,0x7F,0xF2,
+        0x47,0x38,0xC7,0xD0,0xD9,0xE1,0x20,0xB1,
+        0x83,0xE0,0xC1,0x56,0x6D,0x02,0x85,0x86,
+        0x50,0x14,0x18,0x14,0x8B,0x0F,0x18,0xF8,
+        0x61,0xB3,0xB3,0x00,0x93,0x04,0x87,0x3A,
+        0x02,0xF8,0x3E,0xD1,0xFC,0x38,0x74,0x37,
+        0x38,0x54,0x8F,0xE5,0xA1,0x80,0x9E,0x01,
+        0x71,0xC7,0x0C,0x32,0x69,0xCF,0x28,0xE2,
+        0x53,0xC2,0x29,0x85,0x49,0xE0,0xF3,0x03,
+        0x43,0xE3,0x04,0xAF,0x0D,0xA1,0xF9,0xFF,
+        0xFF,0xA4,0xC0,0x3C,0xDF,0x31,0x04,0x6C,
+        0x02,0xBB,0xBF,0x64,0xC8,0xDA,0xC0,0x75,
+        0x4B,0x32,0x44,0x6F,0x38,0xB2,0x85,0xA2,
+        0xE9,0x44,0x79,0xDF,0x88,0x62,0x67,0x08,
+        0xC2,0x88,0x12,0x2C,0xC8,0xA3,0x42,0xAC,
+        0x28,0x2F,0x05,0x46,0x88,0x18,0xE2,0x95,
+        0x23,0xD0,0x09,0x87,0x0F,0xF2,0xD8,0x14,
+        0xA7,0xFD,0x41,0x90,0x58,0x4F,0x02,0x8D,
+        0xC5,0x91,0x46,0x83,0x3A,0x07,0x78,0xB8,
+        0x3E,0xC4,0x78,0xF8,0x0F,0x21,0x06,0x39,
+        0xC8,0x73,0x7B,0x54,0x38,0x4E,0x5F,0x25,
+        0x4C,0xF0,0x02,0xE0,0x83,0x0A,0x1C,0xD7,
+        0x80,0x9A,0xF1,0x33,0x06,0x58,0x8E,0xE3,
+        0x3E,0xA9,0xC0,0x1D,0x8F,0xEF,0x07,0x6C,
+        0xC2,0x09,0x2C,0x7F,0x10,0xA8,0xE3,0x0C,
+        0x9F,0xE7,0x0B,0x8B,0x21,0x1F,0x13,0x4C,
+        0x60,0xB1,0x27,0x1B,0x3A,0x1E,0xF0,0xDF,
+        0x63,0x1E,0x2F,0x7C,0x32,0xF1,0x7C,0x4D,
+        0x30,0x22,0x84,0x9C,0x8C,0x07,0x7D,0x87,
+        0xC0,0x5C,0x6F,0xD8,0xB9,0x85,0x8B,0x3A,
+        0x68,0xA0,0x4E,0x0B,0x3E,0x28,0xB0,0x9B,
+        0x11,0xE6,0xB8,0xCE,0xCF,0x2A,0x60,0xF8,
+        0xFF,0x9F,0x55,0x60,0x8F,0x10,0xFE,0xED,
+        0xC1,0xF3,0xF2,0x95,0xE1,0xD5,0x21,0x81,
+        0x43,0x8E,0x10,0x3D,0x2E,0x8F,0x10,0x73,
+        0x3E,0xC2,0x0C,0x11,0x5C,0x67,0x01,0x70,
+        0x0C,0x11,0xF8,0x1C,0x70,0xC0,0x71,0x69,
+        0xE2,0x03,0xF5,0x01,0x07,0x70,0x70,0x4D,
+        0xC3,0x1D,0x70,0xC0,0x71,0x16,0x60,0xFF,
+        0xFF,0xC3,0x0D,0x2C,0x49,0x26,0x0E,0x23,
+        0x18,0x11,0x30,0x28,0x02,0x02,0xA4,0xB3,
+        0x80,0x0F,0x29,0x00,0x1F,0xAE,0x0C,0x0F,
+        0x29,0xD8,0x93,0x86,0x07,0x8E,0x1B,0x85,
+        0x07,0x8D,0x0B,0x30,0x68,0x7A,0xE2,0x80,
+        0x7F,0x4C,0xF0,0x19,0x05,0x1C,0xE3,0x06,
+        0xDF,0x2A,0x0C,0xFC,0xFF,0x3F,0x30,0xCC,
+        0xE1,0xC2,0x63,0x39,0x8A,0xA0,0x07,0x1E,
+        0xD4,0xF7,0x8C,0x33,0xF7,0x24,0x8F,0xD1,
+        0x51,0x0F,0x27,0xF4,0xE4,0x85,0x3B,0x57,
+        0xF9,0x0A,0x71,0x14,0x18,0xB8,0x77,0x29,
+        0x8F,0xCF,0x17,0x2B,0xC3,0x63,0x46,0xFB,
+        0x1E,0x72,0xD6,0x11,0x02,0xE2,0x2F,0x75,
+        0x6C,0xC0,0x60,0x39,0x18,0x00,0x87,0x01,
+        0xE3,0x13,0x0D,0x58,0x67,0x1B,0x3C,0xF4,
+        0x69,0x31,0xC4,0xE3,0x0B,0xFB,0x56,0x61,
+        0x82,0xEA,0x41,0x75,0x12,0xF4,0xD0,0xC0,
+        0x01,0xE8,0xA1,0xC1,0x3F,0xB9,0x90,0xFB,
+        0x2B,0x1D,0x82,0xB5,0xE2,0x69,0xDE,0x47,
+        0x1E,0xF3,0xDC,0xA2,0xBC,0x0D,0x3C,0x07,
+        0xF0,0xD3,0x82,0x87,0xE3,0x63,0x81,0xC7,
+        0xE9,0x4B,0x58,0x82,0xF7,0x1A,0x9F,0x6C,
+        0x1E,0x5C,0x58,0xB2,0x21,0xA0,0x06,0xEB,
+        0x21,0x60,0xA6,0x9A,0xC0,0x49,0x46,0x80,
+        0xCA,0x00,0xA1,0x1B,0xCB,0xE9,0x3E,0x8B,
+        0x84,0x38,0xCD,0x47,0x99,0xC7,0x02,0x8F,
+        0xF5,0xC1,0xC0,0xFF,0x7F,0xCD,0x23,0xD4,
+        0x7D,0xCD,0x33,0x7B,0x3A,0xC0,0xAC,0x22,
+        0xDC,0x7B,0xCE,0x1B,0x86,0xD1,0x9E,0x2D,
+        0x7C,0xCD,0x78,0xD6,0x34,0x42,0x38,0x76,
+        0x83,0xF3,0x48,0x8C,0xF0,0x82,0xC0,0x4E,
+        0x0C,0x0F,0x30,0xC6,0x39,0x79,0xC3,0xFA,
+        0xC2,0xCB,0x40,0x83,0x19,0xDB,0x97,0x01,
+        0x36,0x2A,0xDF,0x88,0xC0,0x97,0xFC,0x62,
+        0x00,0x65,0x16,0xBE,0x9E,0xF8,0xA0,0xC4,
+        0x2E,0x06,0x2C,0xE5,0xC5,0x00,0x54,0x37,
+        0x0C,0x5F,0x0C,0xE0,0x5F,0x89,0x5E,0x0C,
+        0xC0,0x70,0x71,0xF2,0x3D,0xC0,0x1E,0xEE,
+        0xA3,0x74,0x9C,0xBE,0xFD,0xBD,0x19,0xF8,
+        0x6C,0xC0,0x60,0x3C,0xC3,0x30,0xC6,0x08,
+        0xE3,0x51,0x86,0x31,0xC1,0xDC,0xB7,0x03,
+        0xE8,0x39,0x87,0x81,0x4A,0x78,0x3B,0x80,
+        0x72,0x0E,0xE8,0xF2,0x68,0x42,0x4F,0x01,
+        0x4F,0x07,0x3E,0x29,0x1A,0xA2,0xAF,0xB1,
+        0x0A,0x26,0x50,0xC4,0x07,0x0D,0x3E,0xB5,
+        0x28,0x3E,0x15,0x78,0x2D,0xCF,0x4E,0xE1,
+        0xE2,0x9C,0x89,0xA7,0x6A,0x38,0x03,0xBD,
+        0xE6,0x86,0x63,0xFF,0x7F,0x38,0xFC,0xA9,
+        0xE0,0x35,0x80,0x1D,0x24,0x3D,0x2D,0x23,
+        0xC2,0x38,0xA4,0x3C,0x32,0xF8,0xB6,0x18,
+        0xC7,0x90,0x0F,0x91,0xBE,0x13,0x18,0xF2,
+        0x21,0xEF,0x79,0xC7,0xC0,0xAF,0x08,0x71,
+        0x9E,0xB2,0x7C,0x67,0xF0,0x65,0x01,0x7C,
+        0x91,0x2E,0x0B,0x68,0x68,0x9F,0x64,0x7C,
+        0x41,0x30,0xEC,0x89,0xB3,0x00,0x77,0x05,
+        0x50,0x81,0xFA,0xAE,0x00,0xFF,0x42,0xF0,
+        0xAE,0x00,0x86,0x79,0xF9,0x56,0xC0,0x35,
+        0x1D,0x4A,0xD0,0x67,0x12,0x5F,0x17,0x70,
+        0x53,0x64,0xA9,0x8E,0x0A,0xD0,0x53,0x4C,
+        0x02,0x75,0x47,0xF7,0x51,0x01,0xC6,0x4D,
+        0xD9,0x07,0x54,0x76,0x5A,0x60,0x67,0x21,
+        0x76,0x1D,0xC1,0x5D,0x49,0x18,0xCA,0xB3,
+        0x81,0x2F,0x59,0xFC,0x70,0x00,0x03,0xDC,
+        0xB3,0x38,0xC4,0x08,0xB1,0xD9,0x81,0xEB,
+        0x75,0xD2,0x70,0x2F,0x44,0xEC,0xFF,0x7F,
+        0x32,0x00,0xE3,0x51,0x1B,0x1C,0x27,0x9D,
+        0xF0,0x91,0x9E,0x59,0xF8,0x49,0x19,0x30,
+        0x71,0xF2,0x03,0xE3,0xC9,0x1A,0xC6,0x00,
+        0xB8,0xBC,0x57,0x95,0x81,0xFC,0x43,0x90,
+        0x20,0x18,0xD4,0x29,0x19,0x38,0x1C,0xC5,
+        0x70,0xA7,0x64,0x78,0x50,0xF8,0xC3,0x00,
+        0xE6,0x46,0xE8,0x7B,0x82,0xA1,0xDE,0x93,
+        0x0E,0xE3,0x91,0xD0,0x04,0x3E,0x2D,0xC3,
+        0xFA,0xFF,0x9F,0x96,0x81,0xD5,0xB1,0xDD,
+        0x43,0xF6,0x59,0x01,0x77,0x76,0x80,0x3B,
+        0x3D,0x7E,0x7A,0x00,0x9C,0x00,0x3D,0x3D,
+        0x80,0xED,0xBC,0x01,0xF7,0x40,0x80,0x38,
+        0xFE,0xA3,0x82,0x5F,0x59,0x28,0x1C,0x3F,
+        0xB6,0xF3,0x63,0x09,0xEE,0x70,0xE0,0x23,
+        0x83,0x0F,0x90,0xB8,0xA1,0xF8,0x50,0x81,
+        0x3C,0x0B,0x80,0x62,0xF4,0x6C,0x04,0xEC,
+        0x06,0xF3,0xD2,0x12,0xE5,0xFF,0xFF,0xDE,
+        0xC0,0x4E,0x29,0xB8,0x83,0x00,0xF8,0x8E,
+        0x01,0xE0,0x1D,0x0C,0x97,0x35,0x66,0x94,
+        0x10,0x18,0x8D,0x19,0x77,0x08,0xE1,0x27,
+        0x02,0xDC,0x98,0x3D,0x6E,0x8F,0x19,0x77,
+        0x9C,0xE5,0xA3,0x7A,0xCA,0x08,0xE5,0x03,
+        0x07,0x3B,0x67,0xBC,0x11,0xF0,0xA1,0x03,
+        0x8F,0x03,0x0C,0xEE,0x48,0x01,0xC6,0xCB,
+        0x01,0x1B,0x3B,0xB8,0x83,0x90,0x53,0x20,
+        0x4B,0x87,0xD1,0xD8,0x71,0xB2,0x81,0x74,
+        0x8C,0xF1,0x21,0xD7,0x63,0xC7,0x0D,0xD6,
+        0x63,0xC7,0x1D,0x5F,0xB0,0xFF,0xFF,0xE3,
+        0x0B,0x18,0xC6,0xC0,0xC5,0x0F,0x03,0x7D,
+        0xF3,0xF3,0xE8,0x0C,0xEE,0x61,0xFB,0x04,
+        0x13,0xE3,0xF9,0x25,0xC4,0x23,0xCC,0x8B,
+        0x4B,0x84,0xA3,0x08,0xF2,0xE6,0x12,0xE7,
+        0xD5,0x20,0xCC,0x63,0x4B,0x94,0x10,0x11,
+        0x0E,0x26,0xCE,0x13,0x8C,0x11,0x0E,0x3C,
+        0x8A,0x21,0x22,0x9C,0x40,0x88,0x93,0x3E,
+        0xD9,0x20,0xE1,0x63,0x84,0x8D,0xF6,0x04,
+        0xC3,0xC7,0xC2,0xCF,0x2B,0x1E,0x3C,0x3F,
+        0xAD,0xF9,0x2E,0xE8,0xC9,0x9C,0xE3,0x43,
+        0x96,0xA7,0xF6,0x38,0xE9,0xC3,0x2C,0x6E,
+        0x50,0x0F,0x8E,0xEC,0xAE,0xE3,0xE3,0x35,
+        0xF6,0x14,0xE4,0x21,0xF0,0x13,0x81,0x2F,
+        0x88,0x9E,0xAC,0xEF,0x7A,0xEC,0x5E,0x66,
+        0x8C,0xEA,0xA7,0x80,0x3A,0xA6,0x9C,0xC1,
+        0x2B,0x04,0xBB,0xE7,0xF9,0x90,0xED,0xBB,
+        0x24,0x1B,0x05,0xEE,0x90,0xE0,0x33,0x12,
+        0x3F,0x55,0x78,0x18,0x1E,0x05,0x8C,0x19,
+        0xBC,0x23,0x1C,0x5A,0x88,0x03,0x7E,0xDF,
+        0x65,0x43,0x8D,0x71,0x7A,0x3E,0x7F,0xB0,
+        0x41,0xC0,0x87,0x3A,0x54,0x0F,0xF3,0xA8,
+        0x5E,0x0A,0x19,0xCE,0xD9,0xC1,0x1D,0x04,
+        0xF6,0xF8,0xE1,0x41,0xF0,0x9B,0x25,0x1F,
+        0x04,0x3B,0xDF,0xBC,0xC1,0x19,0xE4,0xFF,
+        0x7F,0x0C,0xB0,0xCF,0x54,0x3E,0x9A,0x20,
+        0x8E,0x80,0xE8,0xF3,0x87,0xC7,0xF0,0x26,
+        0xC7,0x87,0x83,0x3D,0x7A,0xE0,0x4E,0x22,
+        0x70,0x8F,0x5D,0x07,0xED,0x6B,0x9C,0x2F,
+        0x5A,0x30,0xEE,0x7B,0xCF,0x22,0xE0,0xC7,
+        0x78,0x6C,0x01,0xC7,0xA1,0x04,0xDC,0xC1,
+        0x8E,0x6B,0x1C,0x42,0x51,0x60,0x74,0x28,
+        0xC1,0xC5,0x00,0x12,0x8C,0x63,0x9C,0xD1,
+        0xD0,0x97,0x48,0x1F,0xD2,0xE0,0x0C,0x1A,
+        0xF6,0x3C,0x9F,0x50,0xB8,0x3D,0x01,0x8A,
+        0x4E,0x28,0x20,0xC3,0x7D,0x06,0xC1,0x9E,
+        0x10,0xF8,0x19,0x84,0xFD,0xFF,0x0F,0x8E,
+        0x1E,0xF7,0x7B,0xA3,0x4F,0x8D,0x6C,0xEE,
+        0x0F,0x01,0x27,0x70,0xEE,0xEC,0xD4,0x8C,
+        0x3B,0x33,0x60,0xCF,0x1F,0x1E,0x02,0x3F,
+        0x17,0x78,0xF8,0x1E,0x02,0x7E,0xF0,0x0F,
+        0xCC,0x06,0x07,0xE3,0x29,0xC2,0xD7,0x0E,
+        0x0E,0xCE,0x4F,0x03,0x06,0xE7,0xAF,0x50,
+        0x9F,0xE7,0x19,0x38,0xF6,0xD4,0xEB,0x7B,
+        0x87,0xE7,0xEB,0x43,0x05,0xFE,0xA6,0xE7,
+        0x43,0x05,0x38,0x0E,0x0F,0xFC,0xB0,0xC2,
+        0x86,0xF0,0x28,0x80,0x3F,0xB5,0xF8,0xF8,
+        0x17,0xE7,0x29,0x82,0xDD,0x46,0xB0,0x87,
+        0x0B,0xC0,0x51,0xB4,0xB3,0x18,0x2A,0xCC,
+        0x59,0x8C,0xFC,0xFF,0xCF,0x51,0xA8,0xB3,
+        0x18,0x3D,0x5C,0x00,0x2E,0x04,0x1F,0x0F,
+        0x40,0x73,0x10,0x78,0x5C,0xF0,0x85,0xE0,
+        0x48,0x0E,0xE4,0xE9,0x00,0xF0,0x19,0x4A,
+        0xC3,0xA1,0x09,0x13,0x03,0x06,0x75,0x3E,
+        0xF0,0x09,0xC5,0xC7,0x0E,0x7E,0x36,0xF0,
+        0x8D,0xDC,0x43,0xE5,0xA7,0x66,0x5F,0xF2,
+        0x11,0xE0,0x02,0x75,0xA0,0x61,0xA0,0x46,
+        0xE4,0x23,0xD2,0xFF,0xFF,0xB9,0x0D,0x1B,
+        0x60,0x68,0xF4,0x1C,0x0E,0xE3,0x80,0xEB,
+        0x73,0x38,0x76,0x40,0x3E,0x87,0xC3,0x3F,
+        0x47,0xC3,0x1F,0x1B,0x3B,0xDD,0xF3,0x81,
+        0xC1,0xBA,0x7E,0x63,0x06,0x06,0xB6,0x6F,
+        0x91,0x07,0x06,0x1C,0x51,0xCF,0xC6,0x57,
+        0x08,0x0F,0x0C,0x6C,0x80,0x1E,0x18,0xF0,
+        0x89,0x05,0x21,0x27,0x03,0x43,0x9D,0x32,
+        0x8C,0x1C,0xF3,0x89,0xC3,0xC3,0xF0,0xA1,
+        0x22,0xEA,0x33,0xC0,0x23,0x1E,0x1B,0x1B,
+        0xFB,0xFF,0x8F,0x0D,0x2C,0xC7,0x16,0x8F,
+        0x0D,0xFC,0x47,0x78,0xFC,0xD8,0xE0,0x8C,
+        0xE5,0xD1,0xC4,0x97,0x99,0x23,0x3B,0x8D,
+        0x33,0x7B,0x0D,0xF1,0xD1,0xEE,0xF1,0xDB,
+        0x63,0x03,0x97,0x85,0xB1,0x01,0xA5,0x90,
+        0x63,0x43,0x1F,0x52,0x7C,0x0A,0xB0,0x71,
+        0x54,0x32,0x0F,0x1F,0xAF,0x7C,0x62,0x38,
+        0xBA,0x20,0x6F,0xE8,0xBE,0x5C,0xF8,0x48,
+        0x63,0x30,0x5F,0x5A,0x7C,0x06,0xE5,0x43,
+        0x04,0xD7,0x57,0xC5,0x43,0x04,0x3E,0xA1,
+        0x86,0x88,0x1E,0xCF,0xFF,0xFF,0x11,0xCC,
+        0x43,0x64,0x43,0x03,0xAF,0x87,0xA1,0x01,
+        0xA5,0x98,0xC0,0x5E,0x85,0x87,0x46,0x4F,
+        0x3F,0x3E,0x04,0x30,0x08,0xDF,0x06,0xD8,
+        0x55,0xC0,0x57,0x21,0x83,0x24,0x18,0xE7,
+        0x64,0x41,0x07,0x07,0x8E,0x21,0x79,0x70,
+        0xF0,0x07,0xE3,0x21,0x70,0x60,0xCF,0xE0,
+        0xB9,0xE8,0x31,0xD8,0xA7,0x1D,0x9F,0x4A,
+        0xC0,0x77,0xE6,0x04,0xC7,0xE9,0x1D,0x7B,
+        0x29,0xF0,0x08,0x1E,0xAD,0x3C,0x02,0x7E,
+        0xB4,0x02,0x66,0xFF,0xFF,0xA3,0x15,0x30,
+        0x09,0x7A,0xE6,0xA4,0x03,0x77,0x34,0x18,
+        0xD4,0xD1,0x0A,0x5C,0x11,0xC0,0x75,0xDC,
+        0xF0,0xD1,0x02,0xCE,0x50,0x0F,0xDA,0x07,
+        0x65,0xCF,0xDA,0x97,0x21,0x76,0xB4,0x00,
+        0x97,0x89,0x43,0x08,0xD0,0x04,0x3E,0x89,
+        0x67,0xEF,0x43,0x03,0xB3,0x8A,0xA1,0x01,
+        0xA5,0xA3,0x01,0xEE,0x44,0x81,0xFD,0xFF,
+        0x9F,0x28,0x60,0xDE,0x30,0x70,0x07,0x0A,
+        0xC0,0xCD,0xE9,0xDB,0xE3,0xE2,0xD0,0x38,
+        0xC4,0xE7,0xA7,0x73,0xF6,0xD1,0xE8,0x4C,
+        0x71,0x67,0x11,0x30,0x9C,0x7D,0x11,0x8F,
+        0x18,0x03,0xF9,0x81,0x21,0x59,0x30,0x28,
+        0x16,0x0F,0xC5,0x07,0x03,0x0E,0xEC,0x23,
+        0x02,0x3B,0x17,0xB0,0x73,0xAD,0xE1,0xF8,
+        0x59,0xC0,0xA7,0x84,0xB7,0xA6,0x17,0x7B,
+        0x9F,0xD7,0x7D,0xD6,0x08,0xC9,0xCE,0xF4,
+        0x3E,0x89,0xE2,0x0E,0xA2,0x70,0x4E,0x9F,
+        0xE0,0x22,0xF0,0x65,0xDF,0xA3,0xE0,0xA7,
+        0x07,0xCF,0xF1,0x8D,0xC1,0xA7,0x07,0xE6,
+        0x7E,0xF8,0x9A,0xF1,0x33,0xC3,0xE3,0x43,
+        0x88,0x27,0xE2,0xDA,0xA6,0x20,0x5B,0x18,
+        0x42,0x09,0xF4,0xFF,0x8F,0x10,0xE5,0x6D,
+        0x20,0xCA,0x29,0x44,0x88,0x12,0xA4,0xB1,
+        0xC9,0x0B,0x35,0xCA,0xD9,0x45,0x6E,0x6D,
+        0xF6,0x82,0x0B,0x14,0x2A,0x66,0x9C,0x28,
+        0xEF,0x10,0xB1,0xDA,0x1F,0x04,0x91,0xF4,
+        0x32,0xD0,0x71,0xC9,0x91,0x0E,0x7D,0xE8,
+        0x61,0xFB,0x04,0x8C,0x3F,0x48,0xE2,0xAE,
+        0x2A,0x3E,0x28,0xF8,0x00,0x80,0x77,0x09,
+        0xA8,0x5B,0x9D,0xC7,0xED,0xF3,0x06,0xF8,
+        0xAF,0x17,0x58,0x82,0xF2,0x07,0x81,0x1A,
+        0x99,0xA1,0x3D,0xCC,0xB7,0x19,0x43,0xBE,
+        0x07,0x1C,0x16,0x3B,0x27,0xF9,0xF0,0x08,
+        0x1C,0x8E,0x01,0x4F,0x1B,0xBE,0x51,0x7B,
+        0xBE,0x3E,0x62,0x01,0x8E,0xFE,0xFF,0x47,
+        0x2C,0x30,0x9D,0xDF,0x7D,0x82,0x01,0xC7,
+        0xCD,0x82,0x9F,0x61,0x00,0x67,0x40,0xCF,
+        0x30,0x60,0x1F,0x2A,0x6E,0x08,0x5C,0xEE,
+        0x8A,0x28,0x90,0x05,0xC2,0xA0,0x0E,0xFD,
+        0xE4,0x08,0x42,0xCF,0x9C,0x70,0x86,0x72,
+        0xB2,0xBD,0x5F,0x1D,0xC8,0x2D,0xC2,0x43,
+        0x3D,0x8B,0xC7,0x04,0x76,0xDA,0x02,0x36,
+        0xFF,0xFF,0xE3,0x29,0xB0,0x98,0xF7,0xD3,
+        0x69,0x84,0x63,0x03,0xFB,0x71,0x0B,0x38,
+        0x1D,0xCC,0xE0,0xDC,0x7F,0xD8,0x2D,0x1A,
+        0x37,0x34,0xB0,0x0D,0xCC,0x43,0x03,0x3E,
+        0x27,0x47,0x30,0x9E,0x98,0xF8,0x55,0xE2,
+        0xE1,0x89,0x1F,0x43,0xC0,0xFA,0xFF,0x3F,
+        0x99,0x01,0xF6,0x84,0x1E,0xCB,0x50,0xD2,
+        0x4E,0x66,0x80,0xC0,0xFB,0xD8,0x3B,0xC3,
+        0x4B,0x83,0xE7,0x74,0xD2,0xCF,0x62,0x3E,
+        0x99,0x19,0x21,0x0A,0xBB,0x8F,0x19,0xAD,
+        0x37,0x14,0xCD,0x3C,0xE8,0x3B,0x99,0x51,
+        0x62,0x46,0x6A,0x0E,0x4C,0x48,0x11,0x0F,
+        0x27,0x4A,0x88,0x60,0xAF,0x13,0x6F,0x67,
+        0x4F,0x66,0x4C,0xD6,0xC9,0x0C,0x24,0xFF,
+        0xFF,0x93,0x19,0x98,0x5C,0x9F,0xCC,0x80,
+        0xCA,0x39,0x0A,0x7F,0x32,0x03,0x78,0x74,
+        0xC0,0xC2,0x9D,0xCC,0xC0,0xF2,0xFF,0x3F,
+        0xC4,0x00,0xCE,0xC7,0x0A,0x63,0x0C,0x3C,
+        0xDA,0xC1,0x0C,0x15,0xE6,0x6C,0x86,0x0E,
+        0x72,0x08,0xA1,0xC1,0x0E,0x21,0x50,0xE6,
+        0x72,0xA0,0xA7,0xF0,0x9A,0xE0,0x73,0x14,
+        0xD8,0x0F,0x67,0xC0,0xE1,0xD4,0x80,0x0F,
+        0x74,0xE2,0x42,0x8F,0xC2,0x23,0x0E,0x58,
+        0xFD,0xC0,0xC8,0xFF,0xFF,0x64,0x06,0x18,
+        0x78,0x6A,0xF8,0x40,0x82,0x63,0x31,0xEA,
+        0x1B,0xC4,0x21,0xBE,0x8D,0xF8,0xE8,0xFE,
+        0x6A,0xE2,0x4B,0x00,0xE6,0x42,0xE2,0xD3,
+        0x09,0xB3,0x70,0x38,0x03,0x5A,0x43,0x60,
+        0x57,0x26,0xCF,0x9C,0x0F,0xE1,0x6C,0x3C,
+        0x7A,0xDC,0xE9,0x04,0xDE,0x38,0x7C,0x3A,
+        0x01,0x5E,0x07,0x0C,0xCC,0x0C,0xC2,0x3F,
+        0x84,0xB0,0x21,0x9C,0xAA,0xC7,0x70,0xEE,
+        0xAF,0x38,0x3E,0x9D,0x80,0xF3,0xFF,0x7F,
+        0x62,0x03,0x0C,0x0A,0x7E,0x32,0xF8,0xB8,
+        0x46,0x25,0xC2,0xA0,0x8E,0xE6,0x80,0x7B,
+        0x98,0x27,0x36,0x26,0x6F,0xC5,0x1A,0x8B,
+        0x4F,0x6C,0x30,0xFF,0xFF,0x27,0x36,0x80,
+        0xD1,0x87,0x20,0xB0,0xFD,0xFF,0x0F,0x41,
+        0x60,0x1C,0xA0,0x0F,0x41,0x80,0x9B,0xD3,
+        0x09,0xEE,0xC4,0x07,0xB6,0x63,0x10,0x60,
+        0x6D,0xE8,0x3E,0x06,0x81,0xF9,0xFF,0x3F,
+        0x5A,0x98,0xA3,0xE0,0xC2,0x8E,0x7C,0x28,
+        0x29,0xA7,0x3E,0xB4,0x0C,0x20,0x69,0x38,
+        0xC9,0x01,0x9D,0xD3,0x3D,0x70,0x92,0x75,
+        0xEA,0x40,0x8F,0xC7,0xA0,0xAF,0x1C,0xBE,
+        0x12,0xF0,0x23,0x07,0x93,0x00,0xAA,0x41,
+        0xFA,0xCC,0x07,0x9C,0x8E,0x1C,0xE0,0x38,
+        0x26,0x05,0xC6,0xDE,0x0E,0xDE,0x22,0x3D,
+        0x89,0xA7,0xA1,0xE3,0x0C,0x51,0x38,0x26,
+        0x39,0x18,0x44,0x7A,0x95,0x62,0x03,0x7C,
+        0xAB,0xF1,0xD9,0xC8,0x07,0x10,0x78,0xE3,
+        0xF6,0xD8,0x61,0xFF,0xFF,0x0F,0x75,0xC0,
+        0x01,0xE2,0xA4,0xF8,0x21,0xC3,0x98,0x67,
+        0xC5,0x0F,0x75,0x80,0xF5,0x18,0x27,0x3A,
+        0x94,0xF0,0x43,0x1D,0x20,0xE8,0xFF,0x7F,
+        0xA8,0x03,0x86,0x38,0x6F,0x24,0xD1,0x1E,
+        0xEA,0x98,0xE8,0x43,0x1D,0x40,0xC8,0xFF,
+        0xFF,0xA1,0x0E,0x18,0x9E,0x87,0x00,0xAE,
+        0x9C,0xEF,0xC0,0x7C,0x22,0x02,0xEF,0xFF,
+        0xFF,0x7C,0x07,0xB8,0x1B,0x2D,0xCC,0x51,
+        0x70,0x41,0xAF,0x0E,0x03,0x51,0x09,0x30,
+        0x28,0x02,0xC7,0x5F,0x9B,0x60,0x1C,0xEA,
+        0x7C,0x87,0x3E,0x2F,0x78,0xD8,0x4F,0x05,
+        0x9E,0xC4,0xA9,0xFA,0x5A,0x70,0x14,0x4F,
+        0x00,0x3E,0xE1,0x01,0xFF,0xA1,0xC1,0x9A,
+        0x44,0xF1,0x43,0x03,0xF5,0x11,0xE4,0xFF,
+        0x7F,0x68,0xC0,0x28,0xEA,0xF9,0x06,0x7D,
+        0xCC,0xF2,0xD9,0x20,0xE6,0x0B,0x48,0x84,
+        0x07,0x10,0x5F,0x1F,0xD8,0x71,0xD2,0x67,
+        0xA0,0x40,0x51,0xDE,0x37,0xF8,0x09,0x07,
+        0x5C,0x83,0xF3,0x09,0x07,0xBC,0x87,0x23,
+        0x1F,0x4B,0xC0,0x77,0xD0,0x84,0x73,0x81,
+        0xF1,0x8D,0x8D,0x9D,0x06,0xC0,0x76,0x00,
+        0x06,0xDF,0x69,0x00,0x1C,0xC7,0x24,0x7E,
+        0x3A,0x04,0x13,0xCC,0xC1,0xBC,0x34,0xFB,
+        0xFF,0xEF,0xFD,0x94,0x43,0xCF,0x86,0x80,
+        0x75,0x49,0x07,0x43,0x94,0x88,0xB3,0x21,
+        0x20,0xFD,0xFF,0x7F,0x36,0xC4,0x20,0xC4,
+        0x09,0xFC,0x12,0xD1,0xDC,0xD9,0x90,0xAE,
+        0xD8,0x67,0x43,0x80,0xE1,0xFF,0xFF,0x23,
+        0x00,0xF6,0x7C,0x04,0x38,0x3D,0x64,0x83,
+        0xE7,0x14,0x08,0xE3,0xE4,0x03,0x38,0xFE,
+        0xFF,0x8F,0x15,0xE6,0x18,0x78,0xEA,0x97,
+        0x9B,0x8F,0x03,0x54,0xD4,0x2B,0xC2,0x30,
+        0x94,0xC5,0x87,0x05,0x1F,0x11,0xF8,0x61,
+        0xC1,0x23,0xA8,0x78,0x9C,0xF4,0x74,0xE3,
+        0x33,0x21,0x3B,0x24,0x38,0xFC,0x20,0xE9,
+        0x41,0x13,0x3C,0xE7,0x23,0x78,0xB7,0x1E,
+        0x38,0xA7,0x02,0xC0,0x4D,0xAE,0x27,0xA3,
+        0x4E,0x17,0x0E,0x70,0x8E,0x92,0x8D,0x63,
+        0x08,0xE5,0x70,0xCC,0xB7,0x87,0xA6,0xC9,
+        0x4E,0x56,0x30,0x63,0x41,0xEA,0x24,0xE0,
+        0x01,0x38,0x10,0x8C,0xB4,0x93,0x68,0x34,
+        0x86,0xB3,0x5A,0x18,0xC1,0x19,0xC4,0xC7,
+        0x11,0xE7,0x3A,0x19,0xA1,0x3F,0x07,0x3E,
+        0x15,0x61,0x82,0xDC,0x4B,0xE8,0xBC,0x7D,
+        0x37,0xE0,0x57,0x61,0x8F,0xC5,0xFF,0x7F,
+        0x60,0xDF,0x4E,0xC0,0x31,0x17,0xAB,0x01,
+        0x45,0x0D,0xC0,0x68,0x98,0x53,0xC0,0x53,
+        0x09,0xB8,0x82,0xCD,0x0D,0x7D,0x61,0xB1,
+        0xD6,0xA9,0xE8,0x14,0xF4,0x3E,0x70,0x70,
+        0xC0,0x63,0xF6,0x1E,0x1C,0x2C,0x34,0x0F,
+        0x0E,0x6C,0xD9,0x06,0x87,0x56,0x72,0x17,
+        0x21,0x87,0x0F,0xFC,0xEC,0x80,0x03,0xA0,
+        0x67,0x07,0x0B,0xC9,0xB3,0x03,0x9B,0xBE,
+        0xB3,0x08,0x28,0x70,0xFE,0xFF,0x11,0xDE,
+        0x3B,0x7C,0x6E,0x79,0xF6,0x60,0x63,0x78,
+        0x74,0x31,0x9A,0xD1,0xB9,0xA6,0xDB,0x04,
+        0x4A,0xC5,0x6D,0x82,0x82,0xF8,0x06,0xE0,
+        0x84,0x34,0xBA,0x75,0xE2,0x66,0x62,0xFC,
+        0x47,0x0C,0x1F,0x11,0x0E,0xE9,0x6C,0x4D,
+        0x30,0x0F,0xA4,0x9E,0x81,0xBE,0xB3,0xE1,
+        0x67,0x1F,0xF2,0xC1,0xC5,0xD3,0xF0,0xF5,
+        0x86,0xDC,0x3B,0xE8,0xB4,0x7D,0x66,0xC0,
+        0x1C,0x74,0x7D,0x9D,0x7A,0x83,0x27,0x57,
+        0x09,0xEA,0xE1,0x02,0x42,0x2F,0x34,0xBE,
+        0xDC,0x25,0x78,0xE0,0xF4,0xE9,0xEE,0xBD,
+        0x84,0x9D,0xF1,0x12,0xBC,0xE0,0x25,0x98,
+        0x77,0x10,0xA8,0x51,0x79,0x10,0x98,0xAB,
+        0x3C,0xCB,0x37,0x06,0x54,0xB2,0x8B,0x16,
+        0x3D,0xC3,0xBC,0xC3,0xF8,0x92,0xE0,0xEB,
+        0x87,0xCF,0x2D,0x5E,0xC0,0xEB,0x16,0x0C,
+        0x82,0x67,0xA0,0x57,0x17,0xDF,0xD9,0x0D,
+        0xFC,0x2A,0xF0,0x46,0x13,0x22,0x98,0x61,
+        0x0F,0xFF,0xDD,0xDD,0xA8,0xBE,0xE9,0x18,
+        0xEB,0x75,0xC4,0x23,0xE5,0xC7,0x96,0x03,
+        0x8A,0xF4,0xF2,0xE6,0x09,0xF8,0x2C,0xE3,
+        0x53,0xDD,0x49,0xF9,0x7A,0x68,0xF4,0x57,
+        0x08,0x1F,0x7E,0x8C,0xEC,0x73,0x0E,0x3B,
+        0xDF,0xB1,0x41,0x71,0xC4,0x07,0x86,0x97,
+        0x1A,0x4F,0x85,0x9D,0xBB,0x60,0x1C,0x1C,
+        0xD8,0xB1,0x08,0x73,0x7C,0x05,0xD7,0xC9,
+        0xE6,0xFF,0xFF,0xE4,0x00,0x6E,0x78,0xCC,
+        0xC1,0xD7,0xE7,0x0D,0xDF,0x0C,0x3C,0x2E,
+        0x7E,0xE4,0xF0,0x49,0xE3,0xA5,0xD3,0xD8,
+        0xA7,0xE9,0xA3,0xD1,0xCB,0x9B,0x4F,0x2F,
+        0x18,0x58,0x5F,0x1A,0x38,0xAC,0xD1,0xC2,
+        0x3E,0x06,0x9C,0xB9,0x2F,0x44,0xB8,0xC3,
+        0x23,0x58,0x00,0xF1,0xB7,0x92,0x47,0x0E,
+        0x4F,0xC0,0x80,0x4C,0xD3,0xBA,0x74,0x20,
+        0xE2,0xA7,0x3C,0x2B,0x5F,0x99,0x2E,0x43,
+        0x0C,0xE3,0xA9,0xF2,0xF1,0xC3,0xB3,0xF1,
+        0x51,0xC0,0xC7,0x28,0xCF,0xFC,0x8C,0x22,
+        0xBD,0x32,0x10,0x50,0x9D,0x88,0xB8,0x42,
+        0x18,0x89,0xA1,0xD1,0x9D,0x83,0xC7,0x1F,
+        0x22,0x05,0x31,0xA0,0x6F,0x2E,0xC0,0xF4,
+        0x4C,0x04,0x5C,0xFE,0xFF,0x37,0x17,0x80,
+        0xFF,0xFF,0xFF,0x9B,0x0B,0xE0,0xE6,0xFE,
+        0xE0,0x9B,0x0B,0x70,0x8D,0xB4,0x2A,0x7A,
+        0x61,0x77,0x08,0x18,0xD4,0x9D,0x1D,0x70,
+        0x78,0x2B,0x78,0x67,0x87,0xF5,0xFF,0xBF,
+        0xB3,0xC3,0xC3,0x8C,0x13,0xE5,0x85,0x21,
+        0xC6,0x3B,0x3B,0x0B,0xF0,0x26,0xD0,0x51,
+        0xC6,0x77,0x76,0x80,0x1F,0x67,0xD8,0x77,
+        0x69,0xF0,0x5E,0x75,0x81,0xF5,0xFF,0xFF,
+        0xAA,0x0B,0x3C,0x04,0xDF,0xA7,0x41,0x3E,
+        0x5E,0x30,0x8C,0x83,0x2B,0x27,0xA1,0xC7,
+        0x02,0x6B,0x85,0x41,0xDD,0xA9,0xC1,0xA5,
+        0x09,0x5C,0x17,0x5F,0x1F,0x6A,0x7C,0xA4,
+        0xC5,0x9F,0x2F,0x70,0x01,0x86,0x4C,0x4F,
+        0x65,0x30,0xAE,0x29,0x3E,0x95,0x61,0xEE,
+        0x0E,0x1E,0x90,0x8F,0x18,0xC0,0x67,0x15,
+        0x1E,0x18,0xEE,0xB4,0xE0,0x9B,0x92,0x41,
+        0xCF,0x31,0xA8,0x8F,0x3C,0x27,0xEF,0x7B,
+        0xC2,0xE3,0x84,0xA3,0x9E,0x83,0xE8,0xD8,
+        0xC0,0x71,0xDC,0xC0,0xFD,0xFF,0xC7,0x06,
+        0xEF,0x70,0x83,0x3B,0xE8,0xF8,0x62,0x70,
+        0x5C,0x18,0xB8,0xE7,0x02,0x0F,0xC3,0x37,
+        0x1D,0x8F,0x08,0x33,0xFE,0xD7,0x3F,0x23,
+        0x04,0xC4,0x5F,0x8C,0xD8,0x80,0xC1,0x78,
+        0x6B,0xF3,0xF5,0x0D,0x37,0x60,0x5F,0x1D,
+        0x7C,0xC1,0xF0,0x09,0xCC,0xE8,0x2F,0x30,
+        0x4F,0x62,0x3E,0x36,0x90,0x0B,0x1C,0x1D,
+        0x30,0x38,0x00,0x3D,0x60,0xF8,0x87,0x8B,
+        0x77,0x39,0x30,0x5C,0x05,0x7D,0x5C,0xF0,
+        0xB1,0xC7,0x8A,0xEE,0x72,0xE8,0x9B,0x9C,
+        0x61,0xE2,0x18,0xE2,0x0D,0x8C,0xDD,0x25,
+        0xC8,0x61,0x0E,0xEA,0x5D,0xC2,0x73,0xE0,
+        0x67,0x0B,0x9F,0xE0,0x7C,0xF3,0x09,0x71,
+        0xAA,0x8F,0x56,0xEF,0x01,0x3E,0x7A,0xBC,
+        0x77,0xF9,0xEC,0xC4,0x2E,0x02,0x3E,0x72,
+        0x19,0xC7,0xD3,0xF4,0x15,0xD0,0x43,0x36,
+        0xD8,0xAB,0x86,0x4F,0x60,0x3E,0xBA,0xE1,
+        0x8E,0x51,0x9E,0x89,0xA7,0xEF,0x3B,0x08,
+        0x3B,0x92,0x1C,0x75,0xA8,0x6B,0x7A,0x44,
+        0xF9,0xFF,0x9F,0xD0,0x81,0xF8,0xD6,0x06,
+        0xCE,0x68,0xF7,0x0F,0xF4,0x36,0x3D,0x32,
+        0xCC,0xD1,0x00,0xD6,0x25,0x04,0x5C,0x77,
+        0x0C,0x5F,0x42,0x80,0x4F,0xD0,0x4B,0x04,
+        0xFA,0x9A,0xE1,0xD1,0x3D,0x02,0x60,0xAE,
+        0x18,0xEC,0x58,0xE0,0xC3,0x86,0xAF,0x01,
+        0xEC,0x5E,0xE0,0x30,0xF7,0x08,0x50,0x81,
+        0x7A,0x78,0xF0,0xD5,0xDE,0x23,0x40,0x71,
+        0xB2,0xF4,0xA1,0xC1,0x03,0xB5,0xAA,0x33,
+        0x26,0x94,0x23,0x26,0x3F,0x9B,0xF9,0x26,
+        0x81,0xB9,0x5D,0xFA,0x26,0x01,0x37,0xCF,
+        0x2C,0x50,0x49,0x20,0xF4,0xFF,0xBF,0x49,
+        0xC0,0x85,0xE9,0xF2,0x32,0x43,0xE7,0x7F,
+        0xE0,0xBE,0xD5,0x79,0x84,0x3E,0x44,0x30,
+        0x94,0xF7,0x3C,0x9F,0xC2,0xF8,0x19,0xC2,
+        0x07,0x4C,0x76,0xA6,0xE0,0x67,0x4D,0xDC,
+        0x1D,0xC0,0x28,0x6F,0x9E,0x9E,0x00,0x3B,
+        0x7F,0x1A,0xF9,0xDD,0xE0,0x5D,0xC0,0xD3,
+        0xF7,0xBD,0x88,0x9F,0x28,0xC0,0x17,0xEC,
+        0x4E,0x07,0x05,0xFA,0x84,0x3C,0x22,0xA3,
+        0xFA,0x88,0xC0,0x2F,0x49,0x60,0x3C,0x92,
+        0xF8,0x40,0x01,0x84,0xEE,0x05,0xA8,0xD3,
+        0x07,0x47,0x3D,0xE3,0x17,0x54,0x63,0xBE,
+        0x5B,0x3D,0xC2,0x79,0x72,0x98,0xCB,0x01,
+        0x8B,0x73,0x4D,0x02,0xD5,0x71,0x97,0x8F,
+        0x0E,0xEE,0xB5,0x15,0xFB,0xFF,0x27,0x38,
+        0xB8,0x77,0x96,0x77,0x3E,0x43,0x79,0x90,
+        0xE0,0xBB,0xB6,0x82,0xE3,0xAA,0x06,0xE3,
+        0xD8,0xC2,0x2F,0x79,0x80,0x9D,0x61,0x71,
+        0xC1,0x7F,0x0F,0x03,0x51,0x89,0x30,0x28,
+        0x02,0xCB,0xBB,0xB7,0x52,0xF8,0x43,0x06,
+        0xE3,0x4D,0x81,0x4F,0x1A,0x3B,0x6A,0xE0,
+        0xFB,0xFF,0x1F,0x35,0xD8,0x86,0x8A,0xBB,
+        0x29,0x82,0x75,0xAA,0x98,0x21,0xF0,0x60,
+        0x0F,0x00,0x9F,0xAF,0x7C,0x06,0x50,0x14,
+        0x18,0xD4,0xA1,0x1D,0xCE,0x6D,0x18,0x70,
+        0x30,0x62,0xDC,0xA5,0x10,0xEE,0x94,0xDF,
+        0x51,0x62,0x3F,0x97,0xB3,0xE9,0xE2,0xAE,
+        0xE6,0x3E,0x9D,0xB0,0x0B,0x32,0x8C,0xB3,
+        0xC0,0x23,0xC0,0xAB,0x39,0xBF,0x20,0x3F,
+        0x17,0xBF,0x10,0x3C,0x26,0x85,0x78,0x53,
+        0x7A,0x25,0x36,0xC6,0x93,0x71,0x73,0xB7,
+        0x62,0x72,0xDE,0x79,0x41,0x36,0xC6,0xD1,
+        0x44,0x8C,0x72,0x6E,0x0F,0x03,0x91,0x5F,
+        0x90,0x7D,0x3F,0x79,0x21,0x88,0x18,0xCD,
+        0x10,0x41,0x9F,0x97,0x8D,0x15,0x28,0xDE,
+        0x0B,0x32,0x13,0xF8,0x56,0xD0,0xC1,0xC5,
+        0x17,0x64,0xEC,0xFF,0xFF,0x82,0x0C,0x30,
+        0xE2,0x64,0x04,0xF8,0x3C,0x71,0xE0,0xCE,
+        0x35,0x30,0xFE,0xFF,0x97,0x6A,0xD8,0x27,
+        0x1B,0xC0,0xD9,0xD0,0x7D,0xB2,0x01,0xF7,
+        0x68,0xE1,0x1D,0x4D,0x10,0x27,0x1B,0x0A,
+        0xE4,0xE0,0xEB,0xA2,0x70,0x3C,0xF4,0x49,
+        0x84,0x1E,0x9D,0x7C,0x94,0xC4,0x9D,0x19,
+        0x3C,0x91,0x77,0x16,0x8F,0xE2,0x65,0xD0,
+        0xF7,0x82,0x13,0x79,0x7D,0xB0,0x9C,0x63,
+        0x24,0xA8,0x46,0xE2,0xE3,0x03,0xFC,0xEB,
+        0x8B,0x8F,0x91,0xF0,0xF9,0xFC,0xC3,0xF2,
+        0x60,0x0C,0xF9,0xFF,0x7F,0x8A,0xC4,0x80,
+        0x3C,0xBB,0x3C,0x86,0xF0,0x0B,0x24,0xDC,
+        0xD3,0xCC,0x01,0x60,0x64,0x5D,0x1E,0xD1,
+        0x67,0x47,0x8E,0x11,0xD7,0x17,0x45,0x5F,
+        0x81,0x7D,0x10,0x38,0x9F,0xE7,0x44,0xB0,
+        0x8E,0x9A,0x1F,0x6D,0xF8,0xF8,0x39,0xF8,
+        0x5B,0xC1,0x03,0xA5,0x8F,0x45,0x21,0x1E,
+        0x91,0xF8,0x39,0x11,0x5C,0x26,0xCE,0x89,
+        0x40,0xE2,0xD0,0x0B,0xE3,0xB4,0x80,0x1B,
+        0x88,0xCF,0x94,0xD8,0x29,0x9F,0x08,0x3B,
+        0x97,0x60,0x46,0x07,0xAE,0xCB,0xBD,0x47,
+        0x07,0xFE,0x93,0x00,0x1E,0xEB,0xFF,0xFF,
+        0x78,0x07,0xBE,0x93,0xBA,0xEF,0x26,0xBE,
+        0xC8,0xF8,0x50,0xF4,0x7C,0x07,0xF8,0x0F,
+        0x77,0xB8,0x43,0xC5,0x39,0xDF,0x01,0xD2,
+        0xFE,0xFF,0xE7,0x3B,0x60,0x79,0xB6,0x7E,
+        0xBE,0x03,0xBB,0xC8,0xF3,0x1D,0x40,0xAC,
+        0xFF,0xFF,0xF9,0x0E,0xB0,0x73,0x46,0xC3,
+        0x9D,0xEF,0xC0,0x76,0xB4,0x01,0xCC,0x4D,
+        0xE3,0xD1,0x06,0xDC,0xC3,0x85,0x3D,0x0C,
+        0xAE,0xD0,0xA6,0x4F,0x8D,0x46,0xAD,0x1A,
+        0x94,0xA9,0x51,0xE6,0xFF,0xDF,0xA0,0x56,
+        0x9F,0x4A,0x8D,0x19,0xCB,0x0E,0xA5,0x80,
+        0x8F,0x0A,0x8D,0xCD,0xF2,0x28,0x04,0x62,
+        0x31,0xAF,0x06,0x81,0x38,0x2C,0x08,0x8D,
+        0xF4,0xCA,0x11,0x88,0x25,0x3F,0xFB,0x05,
+        0x62,0xB9,0x6F,0x06,0x81,0x38,0xE0,0x1B,
+        0x4C,0xE0,0xE4,0x61,0x25,0x70,0xF2,0x6E,
+        0x10,0x88,0x23,0x83,0x50,0xA1,0x3A,0x40,
+        0x58,0x4C,0x10,0x1A,0xCA,0x07,0x08,0x93,
+        0xFE,0x48,0x10,0x20,0x31,0x02,0xC2,0xC2,
+        0xBD,0xBF,0x04,0x62,0x69,0xEF,0x09,0x81,
+        0x58,0x88,0x15,0x10,0x16,0x17,0x84,0x86,
+        0xD3,0x02,0xC2,0x24,0x99,0x01,0x61,0x81,
+        0x40,0xA8,0x7C,0x35,0x20,0x4C,0xA4,0x1B,
+        0x40,0xBA,0x7A,0x81,0x38,0x88,0x1E,0x10,
+        0x26,0xC3,0x0F,0x08,0x0B,0x0D,0x42,0xA3,
+        0x3D,0x30,0x04,0x48,0x0C,0x81,0xB0,0xF8,
+        0x8E,0x40,0x98,0xF8,0x57,0x91,0x40,0x9C,
+        0xDF,0x12,0xC4,0x4D,0x69,0x88,0x35,0x01,
+        0x31,0x0D,0x9E,0x80,0x98,0x22,0x10,0x01,
+        0x39,0xF6,0xD3,0x43,0x40,0xD6,0x60,0x0A,
+        0x88,0x45,0x07,0x11,0x90,0x85,0xA8,0x02,
+        0x62,0x79,0x5D,0x01,0xB1,0xF0,0x20,0x02,
+        0x72,0xE6,0x97,0x9F,0x80,0xAC,0xE0,0xA5,
+        0xF3,0x10,0xC0,0xDE,0x10,0x81,0x48,0x72,
+        0x10,0x01,0x39,0xB0,0x2F,0x20,0x16,0x1F,
+        0x44,0x40,0xCE,0xFA,0x28,0x14,0x90,0x83,
+        0x83,0x68,0x10,0xE4,0x6B,0x26,0x20,0xA7,
+        0x07,0x11,0x10,0xF9,0x04,0x05,0x21,0x6A,
+        0xBD,0x81,0x30,0x3D,0x8F,0x42,0x0D,0x85,
+        0x80,0x50,0xE5,0xEA,0xCE,0x31,0x2C,0x07,
+        0x08,0xCD,0x05,0x22,0x30,0xAB,0x70,0x07,
+        0xC4,0x54,0x81,0x08,0xC8,0x09,0x80,0xC8,
+        0xFF,0x9F,0x60,0x2A,0x10,0x9A,0x12,0x8C,
+        0xEA,0x92,0x07,0xC4,0x12,0x80,0xD0,0x54,
+        0x20,0x34,0x25,0x88,0x00,0xAD,0xCA,0x1E,
+        0x10,0x53,0x0A,0x42,0x95,0x83,0xD0,0x74,
+        0x20,0x54,0xB6,0xBE,0xC3,0x02,0x05,0x11,
+        0x90,0xA3,0x83,0x50,0xE1,0xFE,0x40,0x98,
+        0xDE,0x97,0x86,0x00,0x9D,0x0E,0x44,0x40,
+        0x4E,0x0C,0x42,0x15,0x7C,0x32,0x82,0x10,
+        0xB1,0x20,0x54,0xC1,0x27,0x23,0x28,0xD1,
+        0xF2,0xB2,0x13,0x90,0xF5,0x81,0x50,0xBD,
+        0x20,0x02,0x73,0x36,0x20,0x9A,0x17,0x84,
+        0xE6,0x07,0xA3,0x5A,0x8D,0x02,0x31,0xFD,
+        0x20,0x34,0x0F,0x88,0xC0,0xAC,0xE0,0xF9,
+        0x71,0xC0,0x0C,0x84,0xAA,0x04,0x11,0x98,
+        0x73,0x01,0xD1,0xAC,0x20,0x34,0x3B,0x18,
+        0xD5,0xFE,0x0F,0xD1,0x00,0x08,0x08,0xCD,
+        0x07,0xA2,0xC3,0x00,0x79,0x96,0x09,0xC8,
+        0x1A,0x41,0xA8,0x66,0x10,0x81,0x39,0x27,
+        0x10,0xCD,0x0E,0x42,0x95,0xFD,0x4D,0x82,
+        0x91,0x8C,0x0F,0xD0,0x40,0x24,0x37,0x08,
+        0xD5,0xF1,0x0C,0x0A,0x46,0x74,0x83,0x08,
+        0xC8,0x59,0x40,0x68,0x36,0x30,0x9A,0x4C,
+        0xED,0x91,0x80,0xBA,0x05,0x61,0xE9,0x41,
+        0x68,0x3A,0xBB,0x83,0xA7,0x20,0x54,0x81,
+        0x5E,0x30,0xA6,0x19,0x44,0x87,0x05,0x02,
+        0x42,0x73,0x81,0x51,0x1D,0xAF,0x96,0x40,
+        0x44,0x1B,0x08,0xD5,0x0A,0xA2,0x81,0x93,
+        0x1F,0x53,0x10,0x92,0x14,0x84,0xFC,0xFF,
+        0x07,0xAA,0xC7,0x9C,0x40,0xAC,0xFA,0x5B,
+        0x25,0x50,0x27,0x01,0xA1,0xC9,0x40,0x74,
+        0x7C,0x20,0x0F,0xB8,0x83,0x64,0x20,0x54,
+        0x29,0x88,0xC0,0xAC,0xF4,0x63,0xA4,0x23,
+        0x05,0x51,0x7D,0xBC,0xA0,0x20,0x34,0xD1,
+        0x3B,0x2C,0x08,0x7B,0xB8,0x69,0xA8,0xE4,
+        0x59,0xA5,0xA1,0x12,0x10,0x9A,0x0D,0x44,
+        0xC7,0x04,0xF2,0xAA,0x79,0x4C,0x60,0x20,
+        0x54,0x2F,0x08,0xCD,0x01,0x42,0x13,0x83,
+        0x08,0xD4,0xA9,0xBF,0x37,0x1A,0x2A,0xF9,
+        0x5B,0x09,0xC4,0xCA,0x5E,0x69,0x02,0xB1,
+        0xDE,0xA7,0x4E,0x20,0xE6,0x1D,0x98,0xA9,
+        0x05,0xA1,0xEA,0x41,0x04,0xE6,0xB4,0x40,
+        0x54,0x81,0x78,0x10,0xA6,0x08,0x44,0x60,
+        0x4E,0x02,0x44,0xD3,0x81,0xD0,0xEC,0x60,
+        0x54,0xE7,0xA3,0x4D,0x40,0xD6,0x0E,0x42,
+        0xB3,0x80,0x08,0xCC,0x59,0x1E,0x69,0x02,
+        0xB1,0x92,0x2F,0x9D,0x0E,0x24,0x04,0x84,
+        0x26,0xD3,0x7F,0x68,0xA1,0x05,0x80,0x99,
+        0x84,0x04,0x20,0x4C,0x16,0x88,0x0E,0x27,
+        0xD6,0x08,0x22,0x40,0xC7,0x01,0xA3,0xD1,
+        0x40,0x68,0x5C,0x40,0x9A,0x1D,0x90,0x2A,
+        0x6D,0x00,0xC6,0x54,0x83,0xD0,0x24,0x20,
+        0x02,0x74,0x2C,0x10,0x01,0x5A,0x74,0x04,
+        0x30,0x16,0x01,0x84,0x46,0x05,0xA1,0xC9,
+        0x2A,0x80,0xB2,0x9C,0x20,0x1A,0x20,0xC9,
+        0x30,0x60,0x0A,0x42,0x33,0x81,0xD0,0x8C,
+        0x20,0x54,0x7C,0x07,0x10,0x16,0x04,0x84,
+        0x86,0x03,0xD1,0x00,0xFE,0xFF,0x8F,0x0C,
+        0x02,0xD1,0x00,0x9C,0x23,0xC4,0x61,0x85,
+        0x82,0xD0,0xF4,0x20,0x34,0x6C,0x09,0x50,
+        0x16,0x1D,0x44,0xC7,0x23,0x92,0x02,0x8C,
+        0x05,0x02,0xA1,0x31,0x41,0x68,0x6C,0x10,
+        0x1A,0x29,0x06,0x28,0x13,0x54,0xE3,0x50,
+        0x44,0x7B,0x80,0x31,0x99,0x20,0x54,0x36,
+        0x88,0xC0,0x1C,0x14,0x88,0x86,0x07,0xA1,
+        0x62,0x82,0x00,0x52,0x10,0x01,0x12,0x20,
+        0x1A,0x1E,0x84,0x8A,0x29,0x32,0x74,0x0A,
+        0x42,0x55,0x24,0x39,0x9A,0x50,0x10,0x1D,
+        0x4D,0x08,0x08,0xCD,0x07,0x46,0x75,0x35,
+        0x39,0x6E,0x50,0x10,0xAA,0x1D,0x84,0x06,
+        0x05,0xA1,0x39,0xA2,0x80,0xB2,0xEC,0x20,
+        0x02,0xB2,0x9E,0x2A,0x87,0x0A,0x0A,0x22,
+        0x30,0xA7,0x02,0xA2,0x49,0x41,0xA8,0x8E,
+        0x2C,0x47,0x0A,0x9A,0x06,0x84,0x25,0x06,
+        0xA1,0xC9,0xDA,0x80,0xB0,0x0C,0x75,0x0E,
+        0x24,0x14,0x84,0xE6,0x04,0xA1,0x4A,0xF2,
+        0x0C,0x8F,0x82,0xE8,0x38,0x42,0x80,0x68,
+        0x7A,0x10,0xAA,0xA6,0xCF,0x00,0x28,0x88,
+        0x06,0x40,0x40,0x68,0x4E,0x30,0xAA,0xA8,
+        0xD1,0xD1,0x84,0x82,0x50,0xDD,0x2F,0x4E,
+        0x81,0xF8,0xFF,0x0F,
+    })  // END MBUF
+
+} //end DefinitionBlock
+