/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20090521
 *
 * Disassembly of DSDT.dat, Tue Jun  8 09:36:22 2010
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00009755 (38741)
 *     Revision         0x01 **** ACPI 1.0, no 64-bit math support
 *     Checksum         0x6B
 *     OEM ID           "NVIDIA"
 *     OEM Table ID     "MCP79"
 *     OEM Revision     0x06040000 (100925440)
 *     Compiler ID      "MSFT"
 *     Compiler Version 0x03000001 (50331649)
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "NVIDIA", "MCP79", 0x06040000)
{
    External (\_PR_.CPU0._PPC)

    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
    })
    Name (SX, 0x00)
    Method (Z000, 0, NotSerialized)
    {
        Store (\_SB.PCI0.GP40, Local0)
        And (Local0, 0x01, Local0)
        Store (Local0, \_SB.WWSU)
    }

    Method (Z001, 0, NotSerialized)
    {
        Store (\_SB.WWSU, Local0)
        If (LEqual (Local0, One))
        {
            Store (0x65, \_SB.PCI0.GP40)
        }

        If (LEqual (Local0, Zero))
        {
            Store (0x44, \_SB.PCI0.GP40)
        }
    }

    Method (\_PTS, 1, NotSerialized)
    {
        Store (Arg0, DBUG)
        If (LEqual (Arg0, 0x03))
        {
            Z000 ()
        }
        Else
        {
            If (LEqual (Arg0, 0x04))
            {
                Z000 ()
            }
        }
    }

    Method (\_WAK, 1, NotSerialized)
    {
        Or (Arg0, 0x50, DBUG)
        If (LEqual (Arg0, 0x03))
        {
            Z001 ()
            Notify (\_SB.PWRB, 0x02)
        }
        Else
        {
            If (LEqual (Arg0, 0x04))
            {
                Z001 ()
                Notify (\_SB.PWRB, 0x02)
            }
        }
    }

    Scope (_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
        Processor (CPU1, 0x01, 0x00001010, 0x06) {}
        Processor (CPU2, 0x02, 0x00001010, 0x06) {}
        Processor (CPU3, 0x03, 0x00001010, 0x06) {}
        Processor (CPU4, 0x04, 0x00001010, 0x06) {}
        Processor (CPU5, 0x05, 0x00001010, 0x06) {}
        Processor (CPU6, 0x06, 0x00001010, 0x06) {}
        Processor (CPU7, 0x07, 0x00001010, 0x06) {}
    }

    Scope (\_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            Store ("==== SST Working ====", Debug)
        }

        Method (_MSG, 1, NotSerialized)
        {
        }
    }

    Scope (\_GPE)
    {
        Method (_L00, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.P2P0, 0x02)
        }

        Method (_L17, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB3, 0x02)
        }

        Method (_L18, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB2, 0x02)
        }

        Method (_L0B, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.MAC0, 0x02)
        }

        Method (_L05, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
        }

        Method (_L0D, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB0, 0x02)
        }

        Method (_L11, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.XVR0, 0x02)
            Notify (\_SB.PCI0.XVR1, 0x02)
            Notify (\_SB.PCI0.XVR2, 0x02)
            Notify (\_SB.PCI0.XVR3, 0x02)
            Notify (\_SB.PCI0.XVR4, 0x02)
            Notify (\_SB.PCI0.XVR5, 0x02)
            Notify (\_SB.PCI0.XVR6, 0x02)
        }

        Method (_L14, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.XVR3, 0x00)
        }
    }

    Scope (\_SB)
    {
        Scope (\_SB)
        {
            Name (TOOS, 0x00)
            Method (_INI, 0, NotSerialized)
            {
                If (CondRefOf (_OSI, Local0))
                {
                    If (\_OSI ("Windows 2006"))
                    {
                        Store (0x06, TOOS)
                    }
                    Else
                    {
                        If (\_OSI ("Windows 2001.1 SP1"))
                        {
                            Store (0x05, TOOS)
                        }
                        Else
                        {
                            If (\_OSI ("Windows 2001.1"))
                            {
                                Store (0x04, TOOS)
                            }
                            Else
                            {
                                If (\_OSI ("Windows 2001 SP2"))
                                {
                                    Store (0x03, TOOS)
                                }
                                Else
                                {
                                    If (\_OSI ("Windows 2001 SP1"))
                                    {
                                        Store (0x02, TOOS)
                                    }
                                    Else
                                    {
                                        If (\_OSI ("Windows 2001"))
                                        {
                                            Store (0x01, TOOS)
                                        }
                                        Else
                                        {
                                            Store (0x00, TOOS)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                If (\_OSI ("Windows 2009"))
                {
                    \_SB.PCI0.LPC0.PHS2 (0x80, 0x10)
                }
            }
        }

        Device (AMW0)
        {
            Mutex (WMIX, 0x01)
            Name (_HID, "PNP0C14")
            Name (_UID, 0x00)
            Method (STBY, 3, NotSerialized)
            {
                CreateByteField (Arg0, Arg1, TMP)
                Store (Arg2, TMP)
            }

            Method (STWD, 3, NotSerialized)
            {
                CreateWordField (Arg0, Arg1, TMP)
                Store (Arg2, TMP)
            }

            Method (STDW, 3, NotSerialized)
            {
                CreateDWordField (Arg0, Arg1, TMP)
                Store (Arg2, TMP)
            }

            Method (CLBY, 1, NotSerialized)
            {
                Store (0x00, Local0)
                While (LLess (Local0, SizeOf (Arg0)))
                {
                    STBY (Arg0, Local0, 0x00)
                    Increment (Local0)
                }
            }

            Name (_WDG, Buffer (0x8C)
            {
                /* 0000 */    0xBC, 0xDC, 0x9D, 0x8D, 0x97, 0xA9, 0xDA, 0x11, 
                /* 0008 */    0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, 
                /* 0010 */    0x41, 0x41, 0x01, 0x00, 0x6C, 0x0F, 0xBC, 0xAB, 
                /* 0018 */    0xA1, 0x8E, 0xD1, 0x11, 0x00, 0xA0, 0xC9, 0x06, 
                /* 0020 */    0x29, 0x10, 0x00, 0x00, 0x41, 0x42, 0x01, 0x00, 
                /* 0028 */    0xCE, 0x93, 0x05, 0xA8, 0x97, 0xA9, 0xDA, 0x11, 
                /* 0030 */    0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, 
                /* 0038 */    0x42, 0x41, 0x01, 0x02, 0x6D, 0x0F, 0xBC, 0xAB, 
                /* 0040 */    0xA1, 0x8E, 0xD1, 0x11, 0x00, 0xA0, 0xC9, 0x06, 
                /* 0048 */    0x29, 0x10, 0x00, 0x00, 0x42, 0x42, 0x01, 0x02, 
                /* 0050 */    0x94, 0x59, 0xBB, 0x9D, 0x97, 0xA9, 0xDA, 0x11, 
                /* 0058 */    0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, 
                /* 0060 */    0xD0, 0x00, 0x01, 0x08, 0xE0, 0x6C, 0x77, 0xA3, 
                /* 0068 */    0x88, 0x1E, 0xDB, 0x11, 0xA9, 0x8B, 0x08, 0x00, 
                /* 0070 */    0x20, 0x0C, 0x9A, 0x66, 0x42, 0x43, 0x01, 0x00, 
                /* 0078 */    0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, 
                /* 0080 */    0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, 
                /* 0088 */    0x4D, 0x4F, 0x01, 0x00
            })
            Name (INFO, Buffer (0x80) {})
            CreateByteField (INFO, 0x00, INF0)
            CreateByteField (INFO, 0x01, INF1)
            CreateByteField (INFO, 0x02, INF2)
            CreateByteField (INFO, 0x03, INF3)
            CreateByteField (INFO, 0x04, INF4)
            CreateByteField (INFO, 0x05, INF5)
            Name (ECD0, 0x00)
            Name (Z002, Buffer (0x08)
            {
                /* 0000 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
            })
            CreateByteField (Z002, 0x00, Z003)
            CreateByteField (Z002, 0x01, Z004)
            CreateByteField (Z002, 0x02, Z005)
            CreateByteField (Z002, 0x03, Z006)
            CreateByteField (Z002, 0x04, Z007)
            CreateByteField (Z002, 0x05, Z008)
            CreateByteField (Z002, 0x06, Z009)
            CreateByteField (Z002, 0x07, Z00A)
            Method (WED0, 1, NotSerialized)
            {
                Store (Arg0, ECD0)
                Return (Arg0)
            }

            Method (WCAA, 1, NotSerialized)
            {
                Return (Arg0)
            }

            Method (WQAA, 1, NotSerialized)
            {
                Acquire (WMIX, 0xFFFF)
                CLBY (INFO)
                If (LNotEqual (Arg0, 0x00))
                {
                    Store (INFO, Local1)
                }
                Else
                {
                    STDW (INFO, 0x00, 0x4C4C4544)
                    STDW (INFO, 0x04, 0x494D5720)
                    STDW (INFO, 0x08, 0x00)
                    STDW (INFO, 0x0C, 0x1000)
                    Store (INFO, Local1)
                }

                Release (WMIX)
                Return (Local1)
            }

            Method (WQAB, 1, NotSerialized)
            {
                Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                Store (\_SB.PCI0.LPC0.EC0.TOPT, Z003)
                Store (\_SB.PCI0.LPC0.EC0.TVGA, Z004)
                Store (\_SB.PCI0.LPC0.EC0.TCPT, Z005)
                Store (\_SB.PCI0.LPC0.EC0.TCPU, Z006)
                Store (\_SB.PCI0.LPC0.EC0.TSYS, Z007)
                Store (\_SB.PCI0.LPC0.EC0.FANH, Z008)
                Store (\_SB.PCI0.LPC0.EC0.FANL, Z009)
                Store (\_SB.PCI0.LPC0.EC0.TDTS, Z00A)
                Release (\_SB.PCI0.LPC0.EC0.MUT0)
                Return (Z002)
            }

            Method (WSAA, 2, NotSerialized)
            {
                Return (Arg1)
            }

            Method (WMI, 2, NotSerialized)
            {
                Return (\_SB.PHWM (Arg0, Arg1))
            }

            Method (WMBA, 3, NotSerialized)
            {
                CreateDWordField (Arg2, 0x28, WBUF)
                Add (WBUF, 0x2C, Local1)
                If (LLessEqual (Local1, 0x1000))
                {
                    Store (WMI (Arg2, Local1), Local0)
                }

                Return (Local0)
            }

            OperationRegion (PRGA, SystemIO, 0x66, 0x01)
            Field (PRGA, ByteAcc, NoLock, Preserve)
            {
                PT66,   8
            }

            OperationRegion (PRGB, SystemIO, 0x62, 0x01)
            Field (PRGB, ByteAcc, NoLock, Preserve)
            {
                PT62,   8
            }

            OperationRegion (PRGC, SystemIO, 0x68, 0x01)
            Field (PRGC, ByteAcc, NoLock, Preserve)
            {
                PT68,   8
            }

            OperationRegion (PRGD, SystemIO, 0x6C, 0x01)
            Field (PRGD, ByteAcc, NoLock, Preserve)
            {
                PT6C,   8
            }

            Method (WMBB, 3, NotSerialized)
            {
                If (LEqual (Arg1, 0x01))
                {
                    Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                    And (\_SB.PCI0.LPC0.EC0.FANM, 0xFD, Local1)
                    Or (Local1, 0x02, Local2)
                    Store (Local2, \_SB.PCI0.LPC0.EC0.FANM)
                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                    Z00B (Arg2)
                    Return (Arg2)
                }

                If (LEqual (Arg1, 0x02))
                {
                    Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                    And (\_SB.PCI0.LPC0.EC0.FANM, 0xFD, Local1)
                    Store (Local1, \_SB.PCI0.LPC0.EC0.FANM)
                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                    Return (Arg2)
                }
            }

            Method (Z00C, 0, NotSerialized)
            {
                Z00D ()
                Z00E ()
                Store (0x92, PT66)
                Z00E ()
                Store (0x18, PT66)
                Z00E ()
                Store (0x1F, PT66)
                Z00F ()
                Store (PT62, Local0)
                Return (Local0)
            }

            Method (Z00G, 0, NotSerialized)
            {
                Z00D ()
                Z00E ()
                Store (0x92, PT66)
                Z00E ()
                Store (0x18, PT66)
                Z00E ()
                Store (0x1E, PT66)
                Z00F ()
                Store (PT62, Local0)
                Return (Local0)
            }

            Method (Z00B, 1, NotSerialized)
            {
                CreateByteField (Arg0, 0x00, TMP0)
                Z00D ()
                Z00E ()
                Store (0x93, PT66)
                Z00E ()
                Store (0x18, PT62)
                Z00E ()
                Store (0x04, PT62)
                Z00E ()
                Store (TMP0, PT62)
                Z00E ()
            }

            Method (Z00D, 0, NotSerialized)
            {
                While (Z00H ())
                {
                    Store (PT62, Local0)
                }
            }

            Method (Z00I, 0, NotSerialized)
            {
                While (Z00J ())
                {
                    Store (PT68, Local0)
                }
            }

            Method (Z00H, 0, NotSerialized)
            {
                Store (PT66, Local0)
                And (Local0, 0x01, Local1)
                Return (Local1)
            }

            Method (Z00J, 0, NotSerialized)
            {
                Store (PT6C, Local0)
                And (Local0, 0x01, Local1)
                Return (Local1)
            }

            Method (Z00E, 0, NotSerialized)
            {
                While (Z00K ()) {}
            }

            Method (Z00L, 0, NotSerialized)
            {
                While (Z00M ()) {}
            }

            Method (Z00K, 0, NotSerialized)
            {
                Store (PT66, Local0)
                And (Local0, 0x02, Local1)
                Return (Local1)
            }

            Method (Z00M, 0, NotSerialized)
            {
                Store (PT6C, Local0)
                And (Local0, 0x02, Local1)
                Return (Local1)
            }

            Method (Z00F, 0, NotSerialized)
            {
                While (LEqual (Z00N (), 0x00)) {}
            }

            Method (Z00N, 0, NotSerialized)
            {
                Store (PT66, Local0)
                And (Local0, 0x01, Local1)
                Return (Local1)
            }

            Method (_WED, 1, NotSerialized)
            {
                CLBY (INFO)
                If (LEqual (Arg0, 0xD0))
                {
                    Store (0x03, INF0)
                    Store (0xE0, INF5)
                    Store (0x09, INF4)
                    Return (INFO)
                }

                CLBY (INFO)
                Store (Arg0, INFO)
                Return (INFO)
            }

            Name (WQMO, Buffer (0x079B)
            {
                /* 0000 */    0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
                /* 0008 */    0x8B, 0x07, 0x00, 0x00, 0x60, 0x2C, 0x00, 0x00, 
                /* 0010 */    0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
                /* 0018 */    0x28, 0xD1, 0x95, 0x00, 0x01, 0x06, 0x18, 0x42, 
                /* 0020 */    0x10, 0x13, 0x10, 0x22, 0x21, 0x04, 0x12, 0x01, 
                /* 0028 */    0xA1, 0xC8, 0x2C, 0x0C, 0x86, 0x10, 0x38, 0x2E, 
                /* 0030 */    0x84, 0x1C, 0x40, 0x48, 0x1C, 0x14, 0x4A, 0x08, 
                /* 0038 */    0x84, 0xFA, 0x13, 0xC8, 0xAF, 0x00, 0x84, 0x0E, 
                /* 0040 */    0x05, 0xC8, 0x14, 0x60, 0x50, 0x80, 0x53, 0x04, 
                /* 0048 */    0x11, 0xF4, 0x2A, 0xC0, 0xA6, 0x00, 0x93, 0x02, 
                /* 0050 */    0x2C, 0x0A, 0xD0, 0x2E, 0xC0, 0xB2, 0x00, 0xDD, 
                /* 0058 */    0x02, 0xA4, 0xC3, 0x12, 0x91, 0xE0, 0x28, 0x31, 
                /* 0060 */    0xE0, 0x28, 0x9D, 0xD8, 0xC2, 0x0D, 0x1B, 0xBC, 
                /* 0068 */    0x50, 0x14, 0xCD, 0x20, 0x4A, 0x82, 0x72, 0x11, 
                /* 0070 */    0xA4, 0x0B, 0x42, 0xCA, 0x05, 0xF8, 0x46, 0xD0, 
                /* 0078 */    0x00, 0xA2, 0xF4, 0x2E, 0xC0, 0xB6, 0x00, 0xD3, 
                /* 0080 */    0xF0, 0x44, 0xEA, 0x10, 0x50, 0x72, 0x86, 0x80, 
                /* 0088 */    0x1A, 0x40, 0xAB, 0x13, 0x10, 0x7E, 0xA5, 0x53, 
                /* 0090 */    0x42, 0x12, 0x84, 0x33, 0x56, 0xF1, 0x33, 0xD0, 
                /* 0098 */    0x1C, 0x4E, 0xE0, 0x9C, 0x3A, 0xC7, 0x90, 0xE3, 
                /* 00A0 */    0x71, 0xA1, 0x07, 0xC1, 0x03, 0x29, 0x00, 0x61, 
                /* 00A8 */    0xE1, 0x21, 0x14, 0x01, 0x06, 0x25, 0x61, 0x2C, 
                /* 00B0 */    0xD4, 0xC5, 0xA8, 0x51, 0x23, 0x65, 0x03, 0x32, 
                /* 00B8 */    0x44, 0x69, 0xA3, 0x46, 0x0F, 0xE8, 0xEC, 0x8E, 
                /* 00C0 */    0xA4, 0x61, 0x01, 0xB2, 0x47, 0x22, 0x02, 0xA3, 
                /* 00C8 */    0x1E, 0xD3, 0x11, 0x16, 0x36, 0x23, 0xA1, 0xC6, 
                /* 00D0 */    0x68, 0x0E, 0x8A, 0x40, 0xE3, 0x06, 0x6D, 0x89, 
                /* 00D8 */    0xB0, 0x1A, 0x57, 0xEC, 0x33, 0xB3, 0xF0, 0x61, 
                /* 00E0 */    0x09, 0xE3, 0x08, 0x0E, 0x2C, 0x41, 0xA3, 0x68, 
                /* 00E8 */    0x9A, 0xE3, 0xD9, 0x86, 0x48, 0x70, 0x10, 0xA1, 
                /* 00F0 */    0x31, 0x32, 0x20, 0xE4, 0x59, 0x80, 0x75, 0x50, 
                /* 00F8 */    0x49, 0x06, 0x22, 0xEE, 0x11, 0xA5, 0x10, 0x41, 
                /* 0100 */    0xF3, 0x3D, 0x91, 0x1A, 0x05, 0x68, 0xC3, 0x90, 
                /* 0108 */    0xAD, 0xB3, 0x81, 0x86, 0x1A, 0xAB, 0x31, 0x14, 
                /* 0110 */    0x41, 0x44, 0x08, 0x1A, 0xC5, 0x60, 0x11, 0x42, 
                /* 0118 */    0x85, 0xF8, 0xFF, 0x47, 0x89, 0x7A, 0x4A, 0x41, 
                /* 0120 */    0xA2, 0x56, 0x06, 0x22, 0xB4, 0x60, 0x46, 0x60, 
                /* 0128 */    0xF6, 0x07, 0x41, 0x62, 0x9C, 0x19, 0x74, 0x58, 
                /* 0130 */    0xB0, 0x0C, 0x10, 0x19, 0x11, 0x34, 0x1A, 0x76, 
                /* 0138 */    0x16, 0xF0, 0x70, 0x3C, 0x93, 0xE6, 0x27, 0xA6, 
                /* 0140 */    0xC1, 0x99, 0x60, 0x6C, 0x08, 0x69, 0x80, 0x90, 
                /* 0148 */    0xA8, 0x83, 0x03, 0x25, 0xB0, 0x94, 0x81, 0x93, 
                /* 0150 */    0xCB, 0x81, 0xC7, 0x77, 0xC6, 0x51, 0x43, 0x9C, 
                /* 0158 */    0xFA, 0x99, 0xF9, 0x1F, 0xE1, 0x2D, 0xF8, 0x08, 
                /* 0160 */    0xC0, 0xC7, 0xE0, 0xC1, 0x1E, 0x42, 0xC0, 0x23, 
                /* 0168 */    0x64, 0x67, 0x00, 0x03, 0xE2, 0xAF, 0x0B, 0x27, 
                /* 0170 */    0xED, 0xB9, 0xF8, 0x2C, 0x00, 0x63, 0xF8, 0x70, 
                /* 0178 */    0x8D, 0x8F, 0x42, 0xE3, 0x61, 0xE7, 0x03, 0x36, 
                /* 0180 */    0x2E, 0x0E, 0xEF, 0x43, 0xC1, 0x09, 0x17, 0x0B, 
                /* 0188 */    0xA2, 0x00, 0x10, 0x92, 0x75, 0x3E, 0x40, 0xCF, 
                /* 0190 */    0xFA, 0xD8, 0x02, 0x3E, 0x0C, 0x34, 0x7B, 0x87, 
                /* 0198 */    0x20, 0x04, 0x2F, 0x02, 0x3E, 0x3A, 0xF8, 0xB8, 
                /* 01A0 */    0xE1, 0x71, 0x3F, 0x6F, 0x80, 0xE1, 0x70, 0xE0, 
                /* 01A8 */    0xE1, 0xF8, 0xB4, 0x01, 0x5C, 0x46, 0xC0, 0xA5, 
                /* 01B0 */    0x3D, 0x29, 0x4C, 0x20, 0xC9, 0x4F, 0x00, 0x89, 
                /* 01B8 */    0x81, 0x41, 0x1D, 0x08, 0x7C, 0xB0, 0x80, 0x2B, 
                /* 01C0 */    0x09, 0x0E, 0x35, 0x3C, 0x4F, 0xEC, 0x01, 0xE1, 
                /* 01C8 */    0xFF, 0x7F, 0x94, 0x67, 0x76, 0x20, 0x9E, 0xFE, 
                /* 01D0 */    0x63, 0x00, 0x8C, 0x03, 0x82, 0xA7, 0x75, 0x4A, 
                /* 01D8 */    0xBE, 0x79, 0x3C, 0x48, 0xF8, 0x22, 0x10, 0x26, 
                /* 01E0 */    0x81, 0x4F, 0x09, 0x0C, 0x8D, 0x1F, 0x37, 0xC0, 
                /* 01E8 */    0x3A, 0x6A, 0xFC, 0x01, 0x01, 0xDE, 0x49, 0xE2, 
                /* 01F0 */    0xFC, 0xFA, 0x1C, 0x80, 0x0E, 0x0D, 0xA7, 0xC8, 
                /* 01F8 */    0x40, 0x5E, 0x03, 0x9E, 0x09, 0x4E, 0xC9, 0xE3, 
                /* 0200 */    0x4B, 0xE0, 0x33, 0x07, 0xEC, 0xBB, 0xC1, 0x61, 
                /* 0208 */    0x1C, 0x4C, 0x88, 0x08, 0xEF, 0x01, 0x4F, 0x1D, 
                /* 0210 */    0xBE, 0x6B, 0x3C, 0x0A, 0x04, 0x8A, 0xD0, 0xDB, 
                /* 0218 */    0x99, 0x83, 0x9E, 0x42, 0x8C, 0x12, 0xED, 0xAC, 
                /* 0220 */    0xC2, 0x3C, 0x70, 0x44, 0xF1, 0x91, 0xC3, 0x08, 
                /* 0228 */    0xEF, 0x1E, 0xBE, 0x13, 0x3C, 0x80, 0xB4, 0x36, 
                /* 0230 */    0x39, 0xE1, 0x06, 0x7A, 0xE6, 0x60, 0xD1, 0xCE, 
                /* 0238 */    0x2C, 0xB2, 0x00, 0xA2, 0x48, 0xA3, 0x41, 0x9D, 
                /* 0240 */    0x11, 0x7C, 0x1A, 0xF0, 0xB4, 0x9E, 0x62, 0x7C, 
                /* 0248 */    0x94, 0x30, 0xC8, 0x19, 0x1E, 0xD8, 0x73, 0xC2, 
                /* 0250 */    0x63, 0x80, 0x07, 0xCC, 0x6E, 0x0C, 0x3E, 0x4E, 
                /* 0258 */    0xF8, 0x5C, 0x80, 0x77, 0x0D, 0xA8, 0x19, 0xFA, 
                /* 0260 */    0xB0, 0x01, 0xE7, 0xD0, 0x81, 0x3F, 0x4D, 0xE0, 
                /* 0268 */    0x0F, 0x16, 0xF8, 0xF1, 0xF8, 0x9A, 0xC3, 0x26, 
                /* 0270 */    0x9C, 0xC0, 0xF2, 0x07, 0x81, 0x1A, 0x99, 0xA1, 
                /* 0278 */    0x3D, 0xCB, 0xD3, 0x7A, 0x0D, 0xF0, 0x69, 0xC7, 
                /* 0280 */    0x04, 0x3E, 0x6F, 0xF8, 0xFF, 0xFF, 0xCF, 0xF1, 
                /* 0288 */    0x78, 0xC0, 0xAF, 0xF8, 0x6C, 0x41, 0xEE, 0x0A, 
                /* 0290 */    0x9E, 0xAF, 0xCF, 0x2E, 0xCC, 0xC6, 0x78, 0x50, 
                /* 0298 */    0xA3, 0xF0, 0x01, 0x07, 0x77, 0x76, 0xF1, 0x11, 
                /* 02A0 */    0xC0, 0x67, 0x17, 0xE0, 0x39, 0x89, 0x67, 0x09, 
                /* 02A8 */    0xF0, 0x1E, 0x02, 0xAC, 0x19, 0x4F, 0x87, 0x2D, 
                /* 02B0 */    0x18, 0x23, 0xC6, 0x43, 0x9E, 0x71, 0xD5, 0xC3, 
                /* 02B8 */    0xD0, 0x45, 0xC0, 0xEA, 0xEE, 0x2B, 0xA8, 0xA3, 
                /* 02C0 */    0x17, 0x98, 0xA0, 0x5E, 0x33, 0x70, 0xA7, 0x17, 
                /* 02C8 */    0xE0, 0x73, 0xCA, 0x82, 0xF7, 0xFF, 0x3F, 0x65, 
                /* 02D0 */    0x01, 0xF7, 0xAB, 0x02, 0x3F, 0xA2, 0x80, 0x01, 
                /* 02D8 */    0xB2, 0xB3, 0xD3, 0x89, 0x10, 0xDE, 0x4B, 0x9E, 
                /* 02E0 */    0x43, 0x7C, 0xBB, 0xF2, 0xC1, 0x24, 0xC8, 0x73, 
                /* 02E8 */    0x40, 0x84, 0xA7, 0x2C, 0x7E, 0x1F, 0x88, 0x12, 
                /* 02F0 */    0xF3, 0x80, 0x22, 0x45, 0x31, 0x62, 0x90, 0x27, 
                /* 02F8 */    0x2C, 0x5F, 0x4F, 0x62, 0x18, 0x3A, 0x58, 0xB8, 
                /* 0300 */    0xF0, 0x11, 0x9E, 0xB2, 0x00, 0x8B, 0x97, 0x2C, 
                /* 0308 */    0xCC, 0x29, 0x0B, 0xE6, 0xDB, 0xC0, 0xA7, 0x2C, 
                /* 0310 */    0x70, 0xFC, 0xFF, 0x4F, 0x59, 0xE0, 0x1A, 0xF7, 
                /* 0318 */    0x53, 0x16, 0x30, 0x93, 0xFE, 0x14, 0xF0, 0xA9, 
                /* 0320 */    0xC6, 0x4F, 0x00, 0x45, 0x3F, 0x58, 0x50, 0x18, 
                /* 0328 */    0x9F, 0xB2, 0x00, 0x57, 0xF2, 0x0E, 0x08, 0xA0, 
                /* 0330 */    0x39, 0x3B, 0xF9, 0xB6, 0x60, 0xB0, 0xE7, 0x98, 
                /* 0338 */    0x93, 0x78, 0xC9, 0xF0, 0x29, 0x11, 0x0C, 0x87, 
                /* 0340 */    0x0C, 0xDF, 0xA9, 0x0E, 0xE5, 0x91, 0xE3, 0x29, 
                /* 0348 */    0xC0, 0x47, 0x2C, 0xB0, 0xC7, 0x39, 0x06, 0xE8, 
                /* 0350 */    0xB8, 0xE2, 0x23, 0x96, 0xFF, 0xFF, 0x47, 0x2C, 
                /* 0358 */    0x80, 0x1B, 0x07, 0x10, 0xFC, 0xA9, 0x03, 0xD6, 
                /* 0360 */    0x3D, 0x20, 0xAC, 0x0F, 0x1D, 0xC0, 0x43, 0xF6, 
                /* 0368 */    0x43, 0x40, 0x67, 0x18, 0x4B, 0x06, 0x91, 0x8D, 
                /* 0370 */    0x73, 0x0D, 0x1D, 0xA3, 0xC5, 0x2F, 0x54, 0x37, 
                /* 0378 */    0x85, 0xB8, 0x07, 0xC3, 0x65, 0x03, 0x09, 0xD4, 
                /* 0380 */    0xC3, 0xB5, 0x60, 0x0A, 0x89, 0xA2, 0xD1, 0x68, 
                /* 0388 */    0x0C, 0x4C, 0x60, 0x04, 0x67, 0x10, 0x03, 0x3A, 
                /* 0390 */    0x23, 0x84, 0x0E, 0x65, 0x38, 0x15, 0xE7, 0x21, 
                /* 0398 */    0xD4, 0xFF, 0x9F, 0x60, 0xA8, 0x1B, 0x13, 0x9D, 
                /* 03A0 */    0x9D, 0xE7, 0xCF, 0x6F, 0x23, 0x3E, 0x11, 0x18, 
                /* 03A8 */    0xD8, 0x57, 0x88, 0xB7, 0x0C, 0xB0, 0x0C, 0xCB, 
                /* 03B0 */    0x8B, 0x7B, 0x02, 0x78, 0xBC, 0x78, 0xCB, 0x48, 
                /* 03B8 */    0x50, 0xCD, 0xB1, 0x06, 0x35, 0x07, 0x5F, 0x05, 
                /* 03C0 */    0xDE, 0xC8, 0x4C, 0xE0, 0x2B, 0x18, 0xD8, 0x4E, 
                /* 03C8 */    0x33, 0x18, 0x7D, 0x77, 0x02, 0x50, 0x00, 0xF9, 
                /* 03D0 */    0x28, 0xE0, 0xFB, 0xF2, 0xDB, 0x00, 0x9B, 0xC5, 
                /* 03D8 */    0x2B, 0xB3, 0xD1, 0x7C, 0xFE, 0x44, 0x0C, 0x1D, 
                /* 03E0 */    0x25, 0x66, 0xE8, 0x14, 0xC4, 0x43, 0x77, 0xD0, 
                /* 03E8 */    0xA1, 0xA3, 0x8F, 0x03, 0x3E, 0x59, 0xE1, 0x82, 
                /* 03F0 */    0x1D, 0xBE, 0xA0, 0x4D, 0xEE, 0x68, 0x4F, 0xCC, 
                /* 03F8 */    0xB3, 0xF0, 0x3C, 0x71, 0x73, 0x07, 0xD3, 0x11, 
                /* 0400 */    0x09, 0xC6, 0xE0, 0x31, 0x93, 0x07, 0xB3, 0xC0, 
                /* 0408 */    0xC9, 0x83, 0xE2, 0xFF, 0x3F, 0x79, 0x98, 0xF0, 
                /* 0410 */    0x98, 0xB0, 0x87, 0x43, 0x7A, 0xE8, 0xF0, 0xC8, 
                /* 0418 */    0xF8, 0x38, 0x7D, 0xFA, 0x61, 0xD8, 0xA7, 0x73, 
                /* 0420 */    0x2E, 0x45, 0xCF, 0x48, 0x57, 0x91, 0x67, 0x2E, 
                /* 0428 */    0x0C, 0xAC, 0x47, 0xCE, 0x61, 0x8D, 0x16, 0xF6, 
                /* 0430 */    0x80, 0x9F, 0x43, 0x7C, 0x87, 0xF1, 0x81, 0x87, 
                /* 0438 */    0xC1, 0xFA, 0xF4, 0x02, 0x8E, 0xE3, 0x17, 0xFC, 
                /* 0440 */    0xD3, 0x00, 0x78, 0x0E, 0x20, 0x1E, 0xC3, 0x0B, 
                /* 0448 */    0x08, 0x3F, 0xBE, 0xE8, 0xFC, 0x4B, 0x85, 0x2E, 
                /* 0450 */    0x4E, 0xF2, 0x60, 0x50, 0xA7, 0x29, 0xC0, 0xD5, 
                /* 0458 */    0xE9, 0x0D, 0x3C, 0x57, 0x7D, 0xDC, 0x59, 0x0A, 
                /* 0460 */    0xF7, 0xFF, 0x3F, 0x4B, 0xC1, 0x38, 0xFC, 0xFA, 
                /* 0468 */    0x02, 0xEF, 0xBB, 0x94, 0x11, 0x0E, 0xE4, 0x59, 
                /* 0470 */    0x0A, 0xEC, 0xB1, 0x9F, 0x21, 0x3A, 0x04, 0xF8, 
                /* 0478 */    0x2C, 0x05, 0xF0, 0xE3, 0xF5, 0xE1, 0xF3, 0x0C, 
                /* 0480 */    0xDC, 0xC0, 0xA7, 0x5F, 0xA0, 0xF5, 0xFF, 0x3F, 
                /* 0488 */    0x85, 0x80, 0xFF, 0x18, 0xE1, 0x23, 0x0E, 0xEE, 
                /* 0490 */    0xE8, 0x0B, 0xDC, 0x0E, 0xC6, 0xFC, 0x8C, 0x81, 
                /* 0498 */    0x3B, 0x8E, 0x01, 0x8F, 0x93, 0x33, 0xEE, 0x34, 
                /* 04A0 */    0xE1, 0x21, 0xF0, 0x01, 0xB4, 0x3A, 0x3D, 0x72, 
                /* 04A8 */    0xEA, 0x39, 0x25, 0xDC, 0x71, 0x80, 0x4F, 0x09, 
                /* 04B0 */    0x37, 0x00, 0x4C, 0x80, 0x33, 0x26, 0xA0, 0xEA, 
                /* 04B8 */    0xFF, 0x7F, 0xC6, 0x04, 0xC6, 0x20, 0x11, 0xDE, 
                /* 04C0 */    0x15, 0xA2, 0xBE, 0x23, 0x1B, 0xE2, 0x19, 0x99, 
                /* 04C8 */    0xE1, 0xBC, 0x35, 0x3C, 0xBE, 0x3C, 0x23, 0x83, 
                /* 04D0 */    0xF3, 0x8C, 0x09, 0xF0, 0xE7, 0xFF, 0x7F, 0xA4, 
                /* 04D8 */    0xC7, 0xDE, 0x14, 0x82, 0x3F, 0x85, 0x00, 0x13, 
                /* 04E0 */    0xF1, 0x67, 0x4C, 0x2A, 0xFC, 0x8C, 0x09, 0x6D, 
                /* 04E8 */    0x2E, 0x9E, 0xB6, 0xCF, 0x98, 0x00, 0xF7, 0xFE, 
                /* 04F0 */    0xFF, 0x67, 0x4C, 0xC0, 0x77, 0xE4, 0x33, 0x26, 
                /* 04F8 */    0xA0, 0xE7, 0x48, 0x85, 0x3B, 0x63, 0x82, 0x61, 
                /* 0500 */    0x9C, 0xEF, 0x4F, 0x06, 0x79, 0x5E, 0xF2, 0x81, 
                /* 0508 */    0xC0, 0x47, 0x19, 0x16, 0xE3, 0x8C, 0x49, 0xCF, 
                /* 0510 */    0x3D, 0x16, 0x0E, 0x83, 0x3A, 0x50, 0xC1, 0xF9, 
                /* 0518 */    0xFF, 0x1F, 0xA8, 0x00, 0x2F, 0x01, 0x86, 0x0C, 
                /* 0520 */    0x9A, 0x03, 0xC3, 0x19, 0x9C, 0x42, 0xB4, 0x08, 
                /* 0528 */    0x67, 0x7C, 0xC0, 0x31, 0x5E, 0x09, 0x8C, 0x12, 
                /* 0530 */    0xF0, 0xBC, 0x0D, 0x11, 0xF5, 0xA8, 0x7C, 0x81, 
                /* 0538 */    0x30, 0x48, 0xA0, 0x77, 0x03, 0xDF, 0x13, 0x38, 
                /* 0540 */    0xB0, 0x27, 0x60, 0x8C, 0x78, 0x21, 0x82, 0x3E, 
                /* 0548 */    0x5F, 0xF9, 0xBC, 0x14, 0xE3, 0x05, 0xE0, 0xA8, 
                /* 0550 */    0xD8, 0x09, 0x0B, 0xF6, 0x41, 0xE2, 0xC5, 0xD3, 
                /* 0558 */    0xE3, 0x39, 0xB7, 0xE7, 0x8D, 0xA7, 0x98, 0x20, 
                /* 0560 */    0x6F, 0x56, 0x8F, 0x19, 0xCF, 0x12, 0x2F, 0x9C, 
                /* 0568 */    0x3E, 0x61, 0x71, 0x14, 0x1F, 0xAE, 0x0C, 0xF5, 
                /* 0570 */    0xA2, 0x65, 0xC4, 0xB3, 0x0C, 0xF2, 0xE8, 0x69, 
                /* 0578 */    0x90, 0x68, 0xC1, 0x8C, 0xC0, 0x4E, 0x58, 0x2C, 
                /* 0580 */    0xEA, 0xE3, 0x44, 0xA7, 0x0A, 0x9F, 0xB0, 0x80, 
                /* 0588 */    0xF3, 0xFF, 0xFF, 0x84, 0x05, 0xB8, 0x92, 0x73, 
                /* 0590 */    0xC2, 0x90, 0x91, 0x23, 0x14, 0x3D, 0xE5, 0x70, 
                /* 0598 */    0xDC, 0x37, 0x12, 0x1F, 0x10, 0x12, 0x38, 0xFE, 
                /* 05A0 */    0xC1, 0x88, 0x9E, 0x3C, 0x81, 0xE7, 0xD9, 0x04, 
                /* 05A8 */    0x3C, 0x23, 0x7B, 0x9A, 0x78, 0xA4, 0xF0, 0x8C, 
                /* 05B0 */    0x9E, 0x36, 0x3C, 0x8B, 0x77, 0x00, 0x5F, 0x7D, 
                /* 05B8 */    0xC2, 0x3D, 0xFB, 0xC0, 0x19, 0xF0, 0x3B, 0xC0, 
                /* 05C0 */    0x03, 0x80, 0x61, 0x7C, 0x3A, 0xC3, 0x0F, 0x1C, 
                /* 05C8 */    0x7F, 0xA9, 0xF0, 0x7D, 0xC6, 0xA7, 0x20, 0x9F, 
                /* 05D0 */    0xCE, 0x70, 0x07, 0x35, 0x98, 0x67, 0x15, 0x43, 
                /* 05D8 */    0x1D, 0x14, 0xEE, 0xFF, 0x3F, 0xA8, 0x27, 0xD2, 
                /* 05E0 */    0x43, 0x88, 0xE3, 0xCB, 0x83, 0xCF, 0x6B, 0xC0, 
                /* 05E8 */    0xE4, 0x30, 0x84, 0x78, 0x98, 0xF9, 0x40, 0x43, 
                /* 05F0 */    0xC5, 0x2E, 0x95, 0x9E, 0x69, 0x00, 0x6E, 0x8D, 
                /* 05F8 */    0xEB, 0x99, 0x06, 0x6C, 0xFF, 0xFF, 0x33, 0x0D, 
                /* 0600 */    0x3E, 0xDE, 0x21, 0x14, 0xA0, 0xC9, 0xF1, 0xE1, 
                /* 0608 */    0x61, 0x04, 0x4C, 0xC7, 0x82, 0xD0, 0x46, 0x7A, 
                /* 0610 */    0x61, 0xF0, 0xA9, 0xC1, 0x90, 0xEF, 0x0A, 0x1E, 
                /* 0618 */    0xA3, 0x27, 0xE1, 0xC3, 0x28, 0x50, 0xF1, 0x30, 
                /* 0620 */    0x56, 0x96, 0xED, 0x30, 0x8A, 0x3A, 0x14, 0x38, 
                /* 0628 */    0x0F, 0x95, 0x6E, 0xD8, 0x0F, 0x15, 0xC6, 0x3E, 
                /* 0630 */    0x86, 0xC7, 0x09, 0x8F, 0xE1, 0x24, 0x22, 0x1D, 
                /* 0638 */    0x96, 0xFF, 0xFF, 0x63, 0x74, 0x82, 0x03, 0x29, 
                /* 0640 */    0x4A, 0x3B, 0x85, 0x94, 0x1D, 0x23, 0x51, 0x5A, 
                /* 0648 */    0x8E, 0x91, 0x14, 0xC4, 0xC7, 0x48, 0xAE, 0xE4, 
                /* 0650 */    0x34, 0x80, 0xD2, 0x71, 0xEC, 0x21, 0xE3, 0xC4, 
                /* 0658 */    0x10, 0xCC, 0x75, 0x22, 0x85, 0x3E, 0x9B, 0xB7, 
                /* 0660 */    0x48, 0xF0, 0xCC, 0xCB, 0x87, 0x8B, 0xE3, 0xC0, 
                /* 0668 */    0x6C, 0xF2, 0x05, 0x13, 0x73, 0x2A, 0x85, 0x39, 
                /* 0670 */    0xEF, 0xB7, 0x1F, 0xB0, 0x9C, 0x37, 0xDE, 0x59, 
                /* 0678 */    0x7D, 0x25, 0x05, 0x16, 0x02, 0x27, 0x8F, 0x92, 
                /* 0680 */    0x34, 0x79, 0x0A, 0xE2, 0xC9, 0x3B, 0xEE, 0xE4, 
                /* 0688 */    0xD1, 0x33, 0xF1, 0xE4, 0xB1, 0x04, 0xC3, 0xDD, 
                /* 0690 */    0x49, 0x41, 0x71, 0x73, 0xC0, 0x0F, 0x1F, 0xAC, 
                /* 0698 */    0x97, 0x29, 0xFC, 0xFF, 0xFF, 0x5E, 0x8A, 0xBD, 
                /* 06A0 */    0x71, 0xC0, 0x1F, 0x3F, 0xF6, 0x56, 0x0A, 0x4C, 
                /* 06A8 */    0x24, 0x8C, 0x5D, 0xB7, 0x52, 0xC0, 0x0D, 0xAA, 
                /* 06B0 */    0xCF, 0x03, 0xE0, 0xB8, 0x87, 0xB0, 0xD3, 0x92, 
                /* 06B8 */    0x2F, 0x62, 0x06, 0x89, 0xF8, 0xAA, 0xC2, 0x06, 
                /* 06C0 */    0xC5, 0x8E, 0x4A, 0xEC, 0xBA, 0xF6, 0xA8, 0x04, 
                /* 06C8 */    0x2B, 0xDD, 0xED, 0x04, 0x35, 0x12, 0xA7, 0x79, 
                /* 06D0 */    0x3F, 0x68, 0xEA, 0xAF, 0x00, 0x2F, 0x27, 0xC0, 
                /* 06D8 */    0xEE, 0xFF, 0x7F, 0x39, 0x01, 0xF8, 0xFF, 0xFF, 
                /* 06E0 */    0xBF, 0x9C, 0x80, 0x57, 0xC6, 0xE5, 0x04, 0x74, 
                /* 06E8 */    0xC7, 0x00, 0x5F, 0x4E, 0x80, 0xEB, 0xE9, 0x0F, 
                /* 06F0 */    0x77, 0x1E, 0x80, 0x3B, 0xCC, 0x53, 0xF3, 0xCC, 
                /* 06F8 */    0x83, 0x3D, 0x10, 0xFA, 0x78, 0x02, 0x4E, 0x82, 
                /* 0700 */    0x0A, 0x6D, 0xFA, 0xD4, 0x68, 0xD4, 0xAA, 0x41, 
                /* 0708 */    0x99, 0x1A, 0x65, 0x1A, 0xD4, 0xEA, 0x53, 0xA9, 
                /* 0710 */    0x31, 0x63, 0x86, 0xC6, 0xE3, 0x55, 0x6B, 0xD8, 
                /* 0718 */    0x0E, 0xB5, 0x72, 0x81, 0x58, 0xD2, 0x67, 0x43, 
                /* 0720 */    0x20, 0x16, 0x75, 0x32, 0x13, 0x88, 0xE3, 0x9A, 
                /* 0728 */    0x00, 0x61, 0xC2, 0xD7, 0x27, 0x10, 0xC7, 0x06, 
                /* 0730 */    0xA1, 0x62, 0xFF, 0x25, 0x32, 0x32, 0x58, 0x83, 
                /* 0738 */    0x08, 0xC8, 0x21, 0x7C, 0x00, 0xB1, 0x48, 0x20, 
                /* 0740 */    0x02, 0x27, 0xCF, 0x0A, 0x81, 0x12, 0x27, 0x20, 
                /* 0748 */    0x4C, 0xE8, 0x73, 0x53, 0x20, 0x96, 0xE7, 0x05, 
                /* 0750 */    0x84, 0x85, 0x03, 0xA1, 0x92, 0xCC, 0x80, 0x33, 
                /* 0758 */    0x7D, 0x20, 0x02, 0xB2, 0xD4, 0xFF, 0x88, 0x80, 
                /* 0760 */    0x2C, 0x1C, 0x44, 0x87, 0x03, 0xA2, 0x07, 0x84, 
                /* 0768 */    0xFD, 0xFF, 0xE5, 0x83, 0xD0, 0x38, 0x7E, 0x40, 
                /* 0770 */    0x58, 0x0C, 0x45, 0x20, 0x4C, 0x84, 0xA3, 0x41, 
                /* 0778 */    0xD0, 0x27, 0xA9, 0xC0, 0x9D, 0x14, 0x44, 0x40, 
                /* 0780 */    0x4E, 0x6E, 0x09, 0x88, 0xE9, 0xD0, 0x04, 0xC4, 
                /* 0788 */    0x54, 0xBF, 0x85, 0x05, 0xE4, 0x08, 0x20, 0x02, 
                /* 0790 */    0x72, 0x24, 0x53, 0x40, 0x2C, 0x20, 0x88, 0x80, 
                /* 0798 */    0xFC, 0xFF, 0x07
            })
        }

        OperationRegion (SMI2, SystemMemory, 0x8FEE3C57, 0x00001096)
        Field (SMI2, AnyAcc, NoLock, Preserve)
        {
            WCMD,   8, 
            TPID,   8, 
            WDID,   32, 
            DI00,   32768
        }

        Field (SMI2, AnyAcc, NoLock, Preserve)
        {
                    AccessAs (ByteAcc, 0x00), 
                    Offset (0x06), 
            WCCL,   16, 
            WCSE,   16, 
            WCA1,   32, 
            WCA2,   32, 
            WCA3,   32, 
            WCA4,   32, 
            WCR1,   32, 
            WCR2,   32, 
            WCR3,   32, 
            WCR4,   32
        }

        Mutex (PSMX, 0x00)
        Method (PHWM, 2, NotSerialized)
        {
            Acquire (\_SB.PSMX, 0xFFFF)
            Store (0xE0, WCMD)
            Store (0x57, TPID)
            Store (Arg1, WDID)
            Store (Arg0, DI00)
            Store (Zero, \_SB.PCI0.LPC0.SMIC)
            Release (\_SB.PSMX)
            Name (RETB, Buffer (0x1000) {})
            Store (DI00, RETB)
            Return (RETB)
        }

        OperationRegion (EXCO, SystemIO, 0x72, 0x02)
        Field (EXCO, ByteAcc, NoLock, Preserve)
        {
            INDX,   8, 
            DATA,   8
        }

        IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
        {
                    Offset (0x90), 
            BRND,   4, 
            BRNS,   4, 
            WLEN,   1, 
            BTEN,   1, 
            WWEN,   1, 
            UWEN,   1, 
            USBC,   1, 
            MMBO,   1, 
            WLAK,   1, 
            WPAK,   1, 
            WWAK,   1, 
            WWSU,   1
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Method (_STA, 0, NotSerialized)
            {
                Return (0x0B)
            }
        }

        Device (MEM0)
        {
            Name (_HID, EisaId ("PNP0C01"))
            Method (_CRS, 0, Serialized)
            {
                Name (MEMR, ResourceTemplate ()
                {
                    Memory32Fixed (ReadOnly,
                        0xFFC00000,         // Address Base
                        0x00400000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEC00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEE00000,         // Address Base
                        0x00100000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00000000,         // Address Length
                        _Y00)
                })
                CreateDWordField (MEMR, \_SB.MEM0._CRS._Y00._BAS, MBAS)
                CreateDWordField (MEMR, \_SB.MEM0._CRS._Y00._LEN, MBLE)
                If (\_SB.PCI0.LPC0.MTBA)
                {
                    Store (\_SB.PCI0.LPC0.MTBA, MBAS)
                    Store (0x1000, MBLE)
                }

                Return (MEMR)
            }
        }

        Device (PCI0)
        {
            Name (_ADR, 0x00)
            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, EisaId ("PNP0A03"))
            Name (_UID, 0x01)
            Method (_S3D, 0, NotSerialized)
            {
                Return (0x01)
            }

            Method (_STA, 0, NotSerialized)
            {
                Return (0x0F)
            }

            Scope (\_SB)
            {
                OperationRegion (ASLD, SystemMemory, 0x8FECF5CA, 0x00000100)
                Field (ASLD, AnyAcc, NoLock, Preserve)
                {
                    TOM,    32, 
                    R_ST,   1, 
                        ,   3, 
                    R_P0,   4, 
                    R_S0,   4, 
                    R_S1,   4, 
                    RSS0,   4, 
                    RSS1,   4
                }
            }

            Method (_CRS, 0, NotSerialized)
            {
                Name (CBUF, ResourceTemplate ()
                {
                    WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x00FF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0100,             // Length
                        ,, )
                    IO (Decode16,
                        0x0CF8,             // Range Minimum
                        0x0CF8,             // Range Maximum
                        0x01,               // Alignment
                        0x08,               // Length
                        )
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x0CF7,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0CF8,             // Length
                        ,, , TypeStatic)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0D00,             // Range Minimum
                        0xFFFF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0xF300,             // Length
                        ,, , TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000A0000,         // Range Minimum
                        0x000BFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00020000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000C0000,         // Range Minimum
                        0x000C3FFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000C4000,         // Range Minimum
                        0x000C7FFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000C8000,         // Range Minimum
                        0x000CBFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000CC000,         // Range Minimum
                        0x000CFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000D0000,         // Range Minimum
                        0x000D3FFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000D4000,         // Range Minimum
                        0x000D7FFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000D8000,         // Range Minimum
                        0x000DBFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000DC000,         // Range Minimum
                        0x000DFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000E0000,         // Range Minimum
                        0x000E3FFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000E4000,         // Range Minimum
                        0x000E7FFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000E8000,         // Range Minimum
                        0x000EBFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000EC000,         // Range Minimum
                        0x000EFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00004000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000F0000,         // Range Minimum
                        0x000FFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00010000,         // Length
                        0x00,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x00100000,         // Range Minimum
                        0xFEBFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0xFFF00000,         // Length
                        ,, _Y01, AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (CBUF, \_SB.PCI0._CRS._Y01._MIN, PMMN)
                CreateDWordField (CBUF, \_SB.PCI0._CRS._Y01._LEN, PMLN)
                Multiply (\_SB.TOM, 0x00100000, PMMN)
                Subtract (0xFEC00000, PMMN, PMLN)
                Return (CBUF)
            }

            Name (_PRW, Package (0x02)
            {
                0x00, 
                0x05
            })
            Name (SUPP, 0x00)
            Name (CTRL, 0x00)
            Method (_OSC, 4, NotSerialized)
            {
                CreateDWordField (Arg3, 0x00, CDW1)
                CreateDWordField (Arg3, 0x04, CDW2)
                CreateDWordField (Arg3, 0x08, CDW3)
                If (LEqual (Arg0, Buffer (0x10)
                        {
                            /* 0000 */    0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 
                            /* 0008 */    0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66
                        }))
                {
                    Store (CDW2, SUPP)
                    Store (CDW3, CTRL)
                    And (CTRL, 0x0C, CTRL)
                    If (LNotEqual (Arg1, 0x01))
                    {
                        Or (CDW1, 0x0A, CDW1)
                    }

                    If (LNotEqual (CDW3, CTRL))
                    {
                        Or (CDW1, 0x10, CDW1)
                    }

                    Store (CTRL, CDW3)
                }
                Else
                {
                    Or (CDW1, 0x06, CDW1)
                }

                Return (Arg3)
            }

            Name (_PRT, Package (0x25)
            {
                Package (0x04)
                {
                    0x0003FFFF, 
                    0x00, 
                    \_SB.PCI0.LSMB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0003FFFF, 
                    0x01, 
                    \_SB.PCI0.LPMU, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x00, 
                    \_SB.PCI0.LUS0, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x01, 
                    \_SB.PCI0.LUS2, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x00, 
                    \_SB.PCI0.Z00O, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x01, 
                    \_SB.PCI0.Z00P, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    \_SB.PCI0.LMAC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    \_SB.PCI0.LAZA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x00, 
                    \_SB.PCI0.LSI0, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    \_SB.PCI0.Z00Q, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x01, 
                    \_SB.PCI0.Z00R, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x02, 
                    \_SB.PCI0.Z00S, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x03, 
                    \_SB.PCI0.Z00T, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x00, 
                    \_SB.PCI0.Z00U, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x01, 
                    \_SB.PCI0.Z00V, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x02, 
                    \_SB.PCI0.Z00W, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x03, 
                    \_SB.PCI0.Z00X, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x00, 
                    \_SB.PCI0.Z00Y, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x01, 
                    \_SB.PCI0.Z00Z, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x02, 
                    \_SB.PCI0.Z010, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x03, 
                    \_SB.PCI0.Z011, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x00, 
                    \_SB.PCI0.Z012, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x01, 
                    \_SB.PCI0.Z013, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x02, 
                    \_SB.PCI0.Z014, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x03, 
                    \_SB.PCI0.Z015, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x00, 
                    \_SB.PCI0.Z016, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x01, 
                    \_SB.PCI0.Z017, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x02, 
                    \_SB.PCI0.Z018, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x03, 
                    \_SB.PCI0.Z019, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0017FFFF, 
                    0x00, 
                    \_SB.PCI0.Z01A, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0017FFFF, 
                    0x01, 
                    \_SB.PCI0.Z01B, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0017FFFF, 
                    0x02, 
                    \_SB.PCI0.Z01C, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0017FFFF, 
                    0x03, 
                    \_SB.PCI0.Z01D, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0018FFFF, 
                    0x00, 
                    \_SB.PCI0.Z01E, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0018FFFF, 
                    0x01, 
                    \_SB.PCI0.Z01F, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0018FFFF, 
                    0x02, 
                    \_SB.PCI0.Z01G, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0018FFFF, 
                    0x03, 
                    \_SB.PCI0.Z01H, 
                    0x00
                }
            })
            Device (SMB0)
            {
                Name (_ADR, 0x00030002)
                OperationRegion (SMCF, PCI_Config, 0x48, 0x04)
                Field (SMCF, AnyAcc, NoLock, Preserve)
                {
                    SMPM,   4
                }

                OperationRegion (SBA0, PCI_Config, 0x20, 0x04)
                Field (SBA0, AnyAcc, NoLock, Preserve)
                {
                    SB20,   16
                }

                OperationRegion (SBA1, PCI_Config, 0x24, 0x04)
                Field (SBA1, AnyAcc, NoLock, Preserve)
                {
                    SB24,   16
                }

                OperationRegion (SM74, PCI_Config, 0x74, 0x04)
                Field (SM74, AnyAcc, NoLock, Preserve)
                {
                    SMUB,   32
                }

                OperationRegion (SM6C, PCI_Config, 0x6C, 0x04)
                Field (SM6C, AnyAcc, NoLock, Preserve)
                {
                    WDTA,   32
                }

                OperationRegion (SM80, PCI_Config, 0x80, 0x04)
                Field (SM80, AnyAcc, NoLock, Preserve)
                {
                    NVAM,   32
                }

                OperationRegion (P60, PCI_Config, 0x60, 0x02)
                Field (P60, AnyAcc, NoLock, Preserve)
                {
                    PMBR,   16
                }

                OperationRegion (P64, PCI_Config, 0x64, 0x02)
                Field (P64, AnyAcc, NoLock, Preserve)
                {
                    NVSB,   16
                }

                OperationRegion (P68, PCI_Config, 0x68, 0x02)
                Field (P68, AnyAcc, NoLock, Preserve)
                {
                    ANLG,   16
                }
            }

            Device (IMAP)
            {
                Name (_ADR, 0x00030001)
            }

            Device (USB0)
            {
                Name (_ADR, 0x00040000)
                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x01)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Store (\_SB.UWEN, Local0)
                    If (Local0)
                    {
                        Return (Package (0x02)
                        {
                            0x0D, 
                            0x03
                        })
                    }
                    Else
                    {
                        Return (Package (0x02)
                        {
                            0x0D, 
                            0x00
                        })
                    }
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x00040001)
                Method (_PRW, 0, NotSerialized)
                {
                    Store (\_SB.UWEN, Local0)
                    If (Local0)
                    {
                        Return (Package (0x02)
                        {
                            0x05, 
                            0x03
                        })
                    }
                    Else
                    {
                        Return (Package (0x02)
                        {
                            0x05, 
                            0x00
                        })
                    }
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x00060000)
                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x01)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Store (\_SB.UWEN, Local0)
                    If (Local0)
                    {
                        Return (Package (0x02)
                        {
                            0x18, 
                            0x03
                        })
                    }
                    Else
                    {
                        Return (Package (0x02)
                        {
                            0x18, 
                            0x00
                        })
                    }
                }
            }

            Device (USB3)
            {
                Name (_ADR, 0x00060001)
                Method (_PRW, 0, NotSerialized)
                {
                    Store (\_SB.UWEN, Local0)
                    If (Local0)
                    {
                        Return (Package (0x02)
                        {
                            0x17, 
                            0x03
                        })
                    }
                    Else
                    {
                        Return (Package (0x02)
                        {
                            0x17, 
                            0x00
                        })
                    }
                }

                Device (RHUB)
                {
                    Name (_ADR, 0x00)
                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                        Name (_UPC, Package (0x04)
                        {
                            0x00, 
                            0xFF, 
                            0x00, 
                            0x00
                        })
                    }
                }
            }

            Device (MAC0)
            {
                Name (_ADR, 0x000A0000)
                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x05
                })
            }

            Device (AZA)
            {
                Name (_ADR, 0x00080000)
                Name (SCID, 0x01)
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, PMDS)
                    Store (0x00, PMEN)
                    Store (SCID, CDID)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (CDID, SCID)
                    Store (0x01, PMST)
                    Store (0x03, PMDS)
                    Store (0x01, PMEN)
                }

                OperationRegion (PMCF, PCI_Config, 0x48, 0x02)
                Field (PMCF, ByteAcc, NoLock, Preserve)
                {
                    PMDS,   2, 
                            Offset (0x01), 
                    PMEN,   1, 
                        ,   6, 
                    PMST,   1
                }

                OperationRegion (DCF2, PCI_Config, 0xE6, 0x01)
                Field (DCF2, ByteAcc, NoLock, Preserve)
                {
                    CDID,   8
                }

                Name (_PRW, Package (0x02)
                {
                    0x15, 
                    0x05
                })
            }

            Device (WMI0)
            {
                Name (_HID, "*pnp0c14")
                Name (_UID, "NVIF")
                Name (_WDG, Buffer (0xC8)
                {
                    /* 0000 */    0xF2, 0x9A, 0x79, 0xA1, 0x29, 0x94, 0x29, 0x45, 
                    /* 0008 */    0x92, 0x7E, 0xDF, 0xE1, 0x37, 0x36, 0xEE, 0xBA, 
                    /* 0010 */    0x4E, 0x56, 0x01, 0x02, 0x85, 0x9A, 0x79, 0xA1, 
                    /* 0018 */    0x29, 0x94, 0x29, 0x45, 0x92, 0x7E, 0xDF, 0xE1, 
                    /* 0020 */    0x37, 0x36, 0xEE, 0xBA, 0x85, 0x00, 0x00, 0x08, 
                    /* 0028 */    0x86, 0x9A, 0x79, 0xA1, 0x29, 0x94, 0x29, 0x45, 
                    /* 0030 */    0x92, 0x7E, 0xDF, 0xE1, 0x37, 0x36, 0xEE, 0xBA, 
                    /* 0038 */    0x86, 0x00, 0x00, 0x08, 0x87, 0x9A, 0x79, 0xA1, 
                    /* 0040 */    0x29, 0x94, 0x29, 0x45, 0x92, 0x7E, 0xDF, 0xE1, 
                    /* 0048 */    0x37, 0x36, 0xEE, 0xBA, 0x87, 0x00, 0x00, 0x08, 
                    /* 0050 */    0x88, 0x9A, 0x79, 0xA1, 0x29, 0x94, 0x29, 0x45, 
                    /* 0058 */    0x92, 0x7E, 0xDF, 0xE1, 0x37, 0x36, 0xEE, 0xBA, 
                    /* 0060 */    0x88, 0x00, 0x00, 0x08, 0xC3, 0x9A, 0x79, 0xA1, 
                    /* 0068 */    0x29, 0x94, 0x29, 0x45, 0x92, 0x7E, 0xDF, 0xE1, 
                    /* 0070 */    0x37, 0x36, 0xEE, 0xBA, 0xC3, 0x00, 0x00, 0x08, 
                    /* 0078 */    0xC5, 0x9A, 0x79, 0xA1, 0x29, 0x94, 0x29, 0x45, 
                    /* 0080 */    0x92, 0x7E, 0xDF, 0xE1, 0x37, 0x36, 0xEE, 0xBA, 
                    /* 0088 */    0xC5, 0x00, 0x00, 0x08, 0xCA, 0x9A, 0x79, 0xA1, 
                    /* 0090 */    0x29, 0x94, 0x29, 0x45, 0x92, 0x7E, 0xDF, 0xE1, 
                    /* 0098 */    0x37, 0x36, 0xEE, 0xBA, 0xCA, 0x00, 0x00, 0x08, 
                    /* 00A0 */    0xCB, 0x9A, 0x79, 0xA1, 0x29, 0x94, 0x29, 0x45, 
                    /* 00A8 */    0x92, 0x7E, 0xDF, 0xE1, 0x37, 0x36, 0xEE, 0xBA, 
                    /* 00B0 */    0xCB, 0x00, 0x00, 0x08, 0x21, 0x12, 0x90, 0x05, 
                    /* 00B8 */    0x66, 0xD5, 0xD1, 0x11, 0xB2, 0xF0, 0x00, 0xA0, 
                    /* 00C0 */    0xC9, 0x06, 0x29, 0x10, 0x42, 0x41, 0x01, 0x00
                })
                Method (WMNV, 3, NotSerialized)
                {
                    Store ("WMNV: ", Debug)
                    If (LGreaterEqual (SizeOf (Arg2), 0x08))
                    {
                        CreateDWordField (Arg2, 0x00, FUNC)
                        CreateDWordField (Arg2, 0x04, SUBF)
                        If (LGreater (SizeOf (Arg2), 0x08))
                        {
                            Subtract (SizeOf (Arg2), 0x08, Local2)
                            ShiftLeft (Local2, 0x03, Local2)
                        }

                        CreateField (Arg2, 0x40, Local2, ARGS)
                        Store (FUNC, Debug)
                        Store (SUBF, Debug)
                        Store (ARGS, Debug)
                        Return (\_SB.PCI0.IXVE.IGPU.NVIF (FUNC, SUBF, ARGS))
                    }
                }

                Name (WQBA, Buffer (0x038C)
                {
                    /* 0000 */    0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
                    /* 0008 */    0x7C, 0x03, 0x00, 0x00, 0x54, 0x24, 0x00, 0x00, 
                    /* 0010 */    0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
                    /* 0018 */    0x28, 0xDA, 0x91, 0x00, 0x01, 0x06, 0x18, 0x42, 
                    /* 0020 */    0x10, 0x13, 0x10, 0x8A, 0xE6, 0x80, 0x42, 0x04, 
                    /* 0028 */    0x92, 0x43, 0xA4, 0x30, 0x30, 0x28, 0x0B, 0x20, 
                    /* 0030 */    0x86, 0x90, 0x0B, 0x26, 0x26, 0x40, 0x04, 0x84, 
                    /* 0038 */    0xBC, 0x0A, 0xB0, 0x29, 0xC0, 0x24, 0x88, 0xFA, 
                    /* 0040 */    0xF7, 0x87, 0x28, 0x09, 0x0E, 0x25, 0x04, 0x42, 
                    /* 0048 */    0x12, 0x05, 0x98, 0x17, 0xA0, 0x5B, 0x80, 0x61, 
                    /* 0050 */    0x01, 0xB6, 0x05, 0x98, 0x16, 0xE0, 0x18, 0x92, 
                    /* 0058 */    0x4A, 0x03, 0xA7, 0x04, 0x96, 0x02, 0x21, 0xA1, 
                    /* 0060 */    0x02, 0x94, 0x0B, 0xF0, 0x2D, 0x40, 0x3B, 0xA2, 
                    /* 0068 */    0x24, 0x0B, 0xB0, 0x0C, 0x23, 0x02, 0x8F, 0x82, 
                    /* 0070 */    0xA1, 0x71, 0x68, 0xEC, 0x30, 0x2C, 0x13, 0x4C, 
                    /* 0078 */    0x83, 0x38, 0x8C, 0xB2, 0x91, 0x45, 0x60, 0xDC, 
                    /* 0080 */    0x4E, 0x05, 0xC8, 0x15, 0x20, 0x4C, 0x80, 0x78, 
                    /* 0088 */    0x54, 0x61, 0x34, 0x07, 0x45, 0xE0, 0x42, 0x63, 
                    /* 0090 */    0x64, 0x40, 0xC8, 0xA3, 0x00, 0xAB, 0xA3, 0xD0, 
                    /* 0098 */    0xA4, 0x12, 0xD8, 0xBD, 0x00, 0x83, 0x02, 0x8C, 
                    /* 00A0 */    0x09, 0xF0, 0x86, 0x2A, 0x84, 0x28, 0x35, 0x0A, 
                    /* 00A8 */    0x50, 0x26, 0xC0, 0x16, 0x8A, 0xE0, 0x83, 0xC4, 
                    /* 00B0 */    0x88, 0x12, 0xA4, 0x35, 0x14, 0x0A, 0x11, 0x24, 
                    /* 00B8 */    0x66, 0x8B, 0x28, 0x02, 0x8F, 0x19, 0x24, 0x74, 
                    /* 00C0 */    0x67, 0x40, 0x82, 0xA8, 0x0D, 0x46, 0x08, 0x15, 
                    /* 00C8 */    0xC2, 0xCB, 0xFE, 0x20, 0x88, 0x7C, 0x05, 0xE3, 
                    /* 00D0 */    0x66, 0x91, 0x46, 0x83, 0x1A, 0x6B, 0x82, 0x63, 
                    /* 00D8 */    0xF7, 0x68, 0x4E, 0xB8, 0x73, 0x01, 0xD2, 0xE7, 
                    /* 00E0 */    0x26, 0x90, 0xA3, 0x3B, 0xB8, 0x3A, 0x07, 0x4D, 
                    /* 00E8 */    0x86, 0xC7, 0xB0, 0x12, 0xFC, 0x07, 0xF8, 0x14, 
                    /* 00F0 */    0x80, 0x77, 0x0D, 0xA8, 0xE9, 0x1F, 0x3C, 0x13, 
                    /* 00F8 */    0x04, 0x87, 0x1A, 0xA2, 0x47, 0x1D, 0xEE, 0x04, 
                    /* 0100 */    0x8E, 0xFD, 0x48, 0x18, 0xC4, 0xC1, 0x1E, 0x37, 
                    /* 0108 */    0xD6, 0xE1, 0x64, 0x34, 0xE8, 0x52, 0x05, 0x98, 
                    /* 0110 */    0x3D, 0x00, 0x68, 0x64, 0x09, 0x4E, 0xFB, 0x4C, 
                    /* 0118 */    0x42, 0xBF, 0x07, 0x9C, 0x4F, 0xCF, 0x63, 0x63, 
                    /* 0120 */    0x83, 0x40, 0x8D, 0xCC, 0xFF, 0x7F, 0x68, 0x0F, 
                    /* 0128 */    0xF1, 0xB4, 0x62, 0x86, 0x7C, 0x16, 0x38, 0x2C, 
                    /* 0130 */    0x26, 0x16, 0x42, 0x9B, 0xD4, 0x78, 0x80, 0xC0, 
                    /* 0138 */    0xC4, 0x1F, 0x0D, 0x22, 0xBC, 0x19, 0x78, 0xBE, 
                    /* 0140 */    0x26, 0x18, 0x14, 0x42, 0x4E, 0xC6, 0x83, 0x12, 
                    /* 0148 */    0x03, 0xA2, 0x41, 0xD7, 0x8A, 0xAD, 0x7B, 0x40, 
                    /* 0150 */    0xF0, 0x98, 0x47, 0x54, 0x34, 0xB0, 0x06, 0xC2, 
                    /* 0158 */    0xCE, 0x00, 0x1E, 0xB7, 0x65, 0x81, 0x50, 0x02, 
                    /* 0160 */    0x03, 0xFB, 0xDC, 0xF0, 0x0E, 0x61, 0x5C, 0x1C, 
                    /* 0168 */    0x7E, 0x64, 0x9F, 0x2F, 0x2C, 0x70, 0x50, 0x28, 
                    /* 0170 */    0x58, 0xDF, 0x0E, 0x62, 0x3E, 0x0F, 0x1C, 0xE7, 
                    /* 0178 */    0x01, 0x5B, 0xF8, 0x44, 0x09, 0xF0, 0x21, 0x79, 
                    /* 0180 */    0x34, 0xF0, 0x06, 0x09, 0xDF, 0xFA, 0x11, 0x80, 
                    /* 0188 */    0x20, 0xBF, 0x30, 0x3C, 0x36, 0x24, 0xB0, 0x3C, 
                    /* 0190 */    0x60, 0xF4, 0x28, 0xED, 0x57, 0x00, 0x42, 0xF0, 
                    /* 0198 */    0x17, 0x8B, 0xA7, 0x80, 0xD7, 0x81, 0x08, 0xC7, 
                    /* 01A0 */    0x02, 0x53, 0xE4, 0xD8, 0xD0, 0xF0, 0x1C, 0x38, 
                    /* 01A8 */    0x7A, 0xD8, 0x73, 0x09, 0x7F, 0x34, 0x51, 0x4E, 
                    /* 01B0 */    0xE1, 0x70, 0x7C, 0xE4, 0x30, 0x42, 0xFC, 0x27, 
                    /* 01B8 */    0x8D, 0x27, 0x0F, 0x6B, 0xBE, 0x03, 0x68, 0x4A, 
                    /* 01C0 */    0x6F, 0x01, 0xEF, 0x0F, 0x1E, 0x01, 0x26, 0xFA, 
                    /* 01C8 */    0xD1, 0x04, 0x15, 0xF6, 0x74, 0x02, 0xAA, 0xFF, 
                    /* 01D0 */    0xFF, 0xE9, 0x04, 0xB0, 0x26, 0xEE, 0x64, 0xA2, 
                    /* 01D8 */    0xD3, 0x09, 0xD8, 0xE3, 0x3D, 0x34, 0xA4, 0xE1, 
                    /* 01E0 */    0x74, 0x02, 0x50, 0xE0, 0xFF, 0x7F, 0x3A, 0x81, 
                    /* 01E8 */    0x1F, 0xF3, 0x74, 0x02, 0x15, 0xF8, 0x7C, 0x7C, 
                    /* 01F0 */    0xE9, 0xF0, 0xA1, 0xC0, 0x04, 0x03, 0x8D, 0x9B, 
                    /* 01F8 */    0x8A, 0x3A, 0x9D, 0xA0, 0x0E, 0x0F, 0x3E, 0x9D, 
                    /* 0200 */    0xB0, 0x43, 0xC1, 0x49, 0x3C, 0x05, 0xF8, 0x70, 
                    /* 0208 */    0x02, 0xE6, 0xC1, 0xE0, 0x0F, 0x27, 0xC0, 0x6D, 
                    /* 0210 */    0x2C, 0xF8, 0xC3, 0x09, 0xF0, 0xB8, 0x63, 0x78, 
                    /* 0218 */    0x08, 0xFC, 0x04, 0xE1, 0x21, 0xF0, 0x01, 0x3C, 
                    /* 0220 */    0x6B, 0x9C, 0x9D, 0x95, 0xCE, 0x09, 0x79, 0x0C, 
                    /* 0228 */    0xE1, 0x73, 0xC2, 0x9C, 0x56, 0x80, 0xCF, 0xFF, 
                    /* 0230 */    0xFF, 0xB4, 0x02, 0xB8, 0x3A, 0xA1, 0x3C, 0xAD, 
                    /* 0238 */    0x00, 0x8C, 0xFA, 0xFF, 0x9F, 0x56, 0xC0, 0x7D, 
                    /* 0240 */    0x10, 0x78, 0x5A, 0x01, 0xB6, 0x83, 0xF1, 0x69, 
                    /* 0248 */    0x05, 0x78, 0x8E, 0xC5, 0xA7, 0x15, 0xC0, 0xF1, 
                    /* 0250 */    0xFF, 0xFF, 0xB4, 0x02, 0xF8, 0x41, 0x79, 0x5A, 
                    /* 0258 */    0x01, 0xD8, 0xF5, 0xFF, 0x3F, 0xAD, 0x80, 0xEF, 
                    /* 0260 */    0x24, 0xF0, 0xB4, 0x02, 0x6C, 0x07, 0xE3, 0xD3, 
                    /* 0268 */    0x0A, 0xF0, 0x1C, 0x8B, 0x4F, 0x2B, 0x80, 0xEF, 
                    /* 0270 */    0xFF, 0xFF, 0x69, 0x05, 0x70, 0x82, 0xF0, 0xB4, 
                    /* 0278 */    0x02, 0x30, 0xED, 0xFF, 0x7F, 0x5A, 0x01, 0x07, 
                    /* 0280 */    0xC2, 0xD3, 0x0A, 0xB0, 0x1D, 0x8C, 0x4F, 0x2B, 
                    /* 0288 */    0xC0, 0x73, 0x2C, 0x3E, 0xAD, 0x00, 0xEE, 0xFF, 
                    /* 0290 */    0xFF, 0xA7, 0x15, 0xC0, 0xC2, 0xB0, 0x1F, 0x11, 
                    /* 0298 */    0x9E, 0x56, 0x00, 0xD6, 0xFD, 0xFF, 0x4F, 0x2B, 
                    /* 02A0 */    0xB0, 0x0E, 0x05, 0x3E, 0xAD, 0x00, 0xD7, 0xC1, 
                    /* 02A8 */    0xB0, 0xD3, 0x0A, 0xB0, 0x1C, 0x0B, 0x3B, 0xAD, 
                    /* 02B0 */    0x00, 0x3C, 0xF8, 0xFF, 0x9F, 0x56, 0x80, 0xFB, 
                    /* 02B8 */    0x49, 0xE5, 0x69, 0x05, 0x60, 0xE0, 0xFF, 0xFF, 
                    /* 02C0 */    0xD8, 0x81, 0x3B, 0x10, 0x3C, 0xAD, 0x00, 0xDB, 
                    /* 02C8 */    0xC1, 0xF8, 0xB4, 0x02, 0x3C, 0xC7, 0xE2, 0xD3, 
                    /* 02D0 */    0x0A, 0xC0, 0x89, 0xFF, 0xFF, 0x69, 0x05, 0xF8, 
                    /* 02D8 */    0x42, 0x3C, 0xAD, 0x00, 0x6C, 0xFC, 0xFF, 0x0F, 
                    /* 02E0 */    0xEA, 0x69, 0x05, 0xD8, 0x0E, 0xC6, 0xA7, 0x15, 
                    /* 02E8 */    0xE0, 0x39, 0x16, 0x9F, 0x56, 0x00, 0x7E, 0xFC, 
                    /* 02F0 */    0xFF, 0x4F, 0x2B, 0xC0, 0xF1, 0x5C, 0xF1, 0xB4, 
                    /* 02F8 */    0x02, 0xB0, 0x11, 0xFC, 0x69, 0x05, 0xF3, 0xFF, 
                    /* 0300 */    0x3F, 0xAD, 0x00, 0xC7, 0xC1, 0xF8, 0xB4, 0x02, 
                    /* 0308 */    0x3C, 0xC7, 0xE2, 0xD3, 0x0A, 0xE0, 0x44, 0xA1, 
                    /* 0310 */    0x4D, 0x9F, 0x1A, 0x8D, 0x5A, 0x35, 0x28, 0x53, 
                    /* 0318 */    0xA3, 0x4C, 0x83, 0x5A, 0x7D, 0x2A, 0x35, 0x66, 
                    /* 0320 */    0xCC, 0x0D, 0x94, 0x02, 0x3E, 0x03, 0x74, 0x1E, 
                    /* 0328 */    0xB0, 0xBC, 0x37, 0x83, 0x40, 0x2C, 0x83, 0x42, 
                    /* 0330 */    0x20, 0x96, 0xFE, 0x64, 0x11, 0x88, 0x83, 0x83, 
                    /* 0338 */    0xD0, 0x78, 0xEF, 0x0D, 0x81, 0x58, 0xB4, 0x09, 
                    /* 0340 */    0x10, 0x16, 0x19, 0x84, 0x06, 0x53, 0x01, 0xC2, 
                    /* 0348 */    0xE4, 0xDA, 0x00, 0x61, 0x61, 0x41, 0x68, 0x24, 
                    /* 0350 */    0x1D, 0x20, 0x4C, 0xA8, 0x11, 0x10, 0x16, 0x13, 
                    /* 0358 */    0x84, 0x86, 0x51, 0x02, 0xC2, 0x24, 0x5A, 0x01, 
                    /* 0360 */    0x61, 0x01, 0x41, 0xF4, 0xFF, 0x07, 0x71, 0x0C, 
                    /* 0368 */    0x2D, 0x20, 0x4C, 0x9C, 0x19, 0x10, 0x16, 0x0D, 
                    /* 0370 */    0x84, 0x06, 0x50, 0x03, 0xC2, 0x64, 0xD9, 0x01, 
                    /* 0378 */    0x61, 0xA1, 0x40, 0xA8, 0x74, 0x3D, 0x20, 0x4C, 
                    /* 0380 */    0x90, 0x21, 0x10, 0x16, 0x07, 0x84, 0x8A, 0x56, 
                    /* 0388 */    0x04, 0xC2, 0xFE, 0xFF
                })
            }

            Device (WMI1)
            {
                Name (_HID, "*pnp0c14")
                Name (_UID, "MXM2")
                Name (_WDG, Buffer (0x3C)
                {
                    /* 0000 */    0x3C, 0x5C, 0xCB, 0xF6, 0xAE, 0x9C, 0xBD, 0x4E, 
                    /* 0008 */    0xB5, 0x77, 0x93, 0x1E, 0xA3, 0x2A, 0x2C, 0xC0, 
                    /* 0010 */    0x4D, 0x58, 0x01, 0x02, 0x57, 0x93, 0x8A, 0xF2, 
                    /* 0018 */    0x4B, 0xCF, 0x1A, 0x4A, 0x88, 0x93, 0xBB, 0x1F, 
                    /* 0020 */    0x58, 0xEE, 0xA1, 0xAF, 0xD1, 0x00, 0x01, 0x08, 
                    /* 0028 */    0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, 
                    /* 0030 */    0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, 
                    /* 0038 */    0x58, 0x4D, 0x01, 0x00
                })
                Method (WMMX, 3, NotSerialized)
                {
                    If (LGreaterEqual (SizeOf (Arg2), 0x04))
                    {
                        CreateDWordField (Arg2, 0x00, FUNC)
                        CreateDWordField (Arg2, 0x04, ARGS)
                        If (LEqual (FUNC, 0x494D584D))
                        {
                            Return (\_SB.PCI0.XVR0.Z01I.MXMI (ARGS))
                        }
                        Else
                        {
                            If (LEqual (FUNC, 0x534D584D))
                            {
                                Return (\_SB.PCI0.XVR0.Z01I.MXMS (ARGS))
                            }
                            Else
                            {
                                If (LEqual (FUNC, 0x584D584D))
                                {
                                    If (LGreaterEqual (SizeOf (Arg1), 0x08))
                                    {
                                        CreateDWordField (Arg1, 0x08, SARG)
                                        If (LEqual (ARGS, 0x80000100))
                                        {
                                            Return (\_SB.PCI0.XVR0.Z01I.CRT0.MXMX (SARG))
                                        }
                                        Else
                                        {
                                            If (LEqual (ARGS, 0x0110))
                                            {
                                                Return (\_SB.PCI0.XVR0.Z01I.LCD0.MXMX (SARG))
                                            }
                                            Else
                                            {
                                                If (LEqual (ARGS, 0x80000200))
                                                {
                                                    Return (\_SB.PCI0.XVR0.Z01I.SVD0.MXMX (SARG))
                                                }
                                                Else
                                                {
                                                    If (LEqual (ARGS, 0x80006341))
                                                    {
                                                        Return (\_SB.PCI0.XVR0.Z01I.DPV0.MXMX (SARG))
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Return (0x00)
                }

                Method (_WED, 0, NotSerialized)
                {
                    Return ("Fired")
                }

                Name (WQXM, Buffer (0x029C)
                {
                    /* 0000 */    0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
                    /* 0008 */    0x8B, 0x02, 0x00, 0x00, 0x0C, 0x08, 0x00, 0x00, 
                    /* 0010 */    0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
                    /* 0018 */    0x18, 0xD2, 0x83, 0x00, 0x01, 0x06, 0x18, 0x42, 
                    /* 0020 */    0x10, 0x05, 0x10, 0x8A, 0xE6, 0x80, 0x42, 0x04, 
                    /* 0028 */    0x92, 0x43, 0xA4, 0x30, 0x30, 0x28, 0x0B, 0x20, 
                    /* 0030 */    0x86, 0x90, 0x0B, 0x26, 0x26, 0x40, 0x04, 0x84, 
                    /* 0038 */    0xBC, 0x0A, 0xB0, 0x29, 0xC0, 0x24, 0x88, 0xFA, 
                    /* 0040 */    0xF7, 0x87, 0x28, 0x09, 0x0E, 0x25, 0x04, 0x42, 
                    /* 0048 */    0x12, 0x05, 0x98, 0x17, 0xA0, 0x5B, 0x80, 0x61, 
                    /* 0050 */    0x01, 0xB6, 0x05, 0x98, 0x16, 0xE0, 0x18, 0x92, 
                    /* 0058 */    0x4A, 0x03, 0xA7, 0x04, 0x96, 0x02, 0x21, 0xA1, 
                    /* 0060 */    0x02, 0x94, 0x0B, 0xF0, 0x2D, 0x40, 0x3B, 0xA2, 
                    /* 0068 */    0x24, 0x0B, 0xB0, 0x0C, 0x23, 0x02, 0x8F, 0x82, 
                    /* 0070 */    0xA1, 0x71, 0x68, 0xEC, 0x30, 0x2C, 0x13, 0x4C, 
                    /* 0078 */    0x83, 0x38, 0x8C, 0xB2, 0x91, 0x45, 0x60, 0xDC, 
                    /* 0080 */    0x4E, 0x05, 0xC8, 0x15, 0x20, 0x4C, 0x80, 0x78, 
                    /* 0088 */    0x54, 0x61, 0x34, 0x07, 0x45, 0xE0, 0x42, 0x63, 
                    /* 0090 */    0x64, 0x40, 0xC8, 0xA3, 0x00, 0xAB, 0xA3, 0xD0, 
                    /* 0098 */    0xA4, 0x12, 0xD8, 0xBD, 0x00, 0x8D, 0x02, 0xB4, 
                    /* 00A0 */    0x09, 0x70, 0x28, 0x40, 0xA1, 0x00, 0x6B, 0x18, 
                    /* 00A8 */    0x72, 0x06, 0x21, 0x5B, 0xD8, 0xC2, 0x68, 0x50, 
                    /* 00B0 */    0x80, 0x45, 0x14, 0x8D, 0xE0, 0x2C, 0x2A, 0x9E, 
                    /* 00B8 */    0x93, 0x50, 0x02, 0xDA, 0x1B, 0x82, 0xF0, 0x8C, 
                    /* 00C0 */    0xD9, 0x18, 0x9E, 0x10, 0x83, 0x54, 0x86, 0x21, 
                    /* 00C8 */    0x88, 0xB8, 0x11, 0x8E, 0xA5, 0xFD, 0x41, 0x10, 
                    /* 00D0 */    0xF9, 0xAB, 0xD7, 0xB8, 0x1D, 0x69, 0x34, 0xA8, 
                    /* 00D8 */    0xB1, 0x26, 0x38, 0x76, 0x8F, 0xE6, 0x84, 0x3B, 
                    /* 00E0 */    0x17, 0x20, 0x7D, 0x6E, 0x02, 0x39, 0xBA, 0xD3, 
                    /* 00E8 */    0xA8, 0x73, 0xD0, 0x64, 0x78, 0x0C, 0x2B, 0xC1, 
                    /* 00F0 */    0x7F, 0x80, 0x4F, 0x01, 0x78, 0xD7, 0x80, 0x9A, 
                    /* 00F8 */    0xFE, 0xC1, 0x33, 0x41, 0x70, 0xA8, 0x21, 0x7A, 
                    /* 0100 */    0xD4, 0xE1, 0x4E, 0xE0, 0xBC, 0x8E, 0x84, 0x41, 
                    /* 0108 */    0x1C, 0xD1, 0x71, 0x63, 0x67, 0x75, 0x32, 0x07, 
                    /* 0110 */    0x5D, 0xAA, 0x00, 0xB3, 0x07, 0x00, 0x0D, 0x2E, 
                    /* 0118 */    0xC1, 0x69, 0x9F, 0x49, 0xE8, 0xF7, 0x80, 0xF3, 
                    /* 0120 */    0xE9, 0x79, 0x6C, 0x6C, 0x10, 0xA8, 0x91, 0xF9, 
                    /* 0128 */    0xFF, 0x0F, 0xED, 0x41, 0x9E, 0x56, 0xCC, 0x90, 
                    /* 0130 */    0xCF, 0x02, 0x87, 0xC5, 0xC4, 0x1E, 0x19, 0xE8, 
                    /* 0138 */    0x78, 0xC0, 0x7F, 0x00, 0x78, 0x34, 0x88, 0xF0, 
                    /* 0140 */    0x66, 0xE0, 0xF9, 0x9A, 0x60, 0x50, 0x08, 0x39, 
                    /* 0148 */    0x19, 0x0F, 0x4A, 0xCC, 0xF9, 0x80, 0xCC, 0x25, 
                    /* 0150 */    0xC4, 0x43, 0xC0, 0x31, 0xC4, 0x08, 0x7A, 0x46, 
                    /* 0158 */    0x45, 0x23, 0x6B, 0x22, 0x3E, 0x03, 0x78, 0xDC, 
                    /* 0160 */    0x96, 0x05, 0x42, 0x09, 0x0C, 0xEC, 0x73, 0xC3, 
                    /* 0168 */    0x3B, 0x84, 0x61, 0x71, 0xA3, 0x09, 0xEC, 0xF3, 
                    /* 0170 */    0x85, 0x05, 0x0E, 0x0A, 0x05, 0xEB, 0xBB, 0x42, 
                    /* 0178 */    0xCC, 0xE7, 0x81, 0xE3, 0x3C, 0x60, 0x0B, 0x9F, 
                    /* 0180 */    0x28, 0x01, 0x3E, 0x24, 0x8F, 0x06, 0xDE, 0x20, 
                    /* 0188 */    0xE1, 0x5B, 0x3F, 0x02, 0x10, 0xE0, 0x27, 0x06, 
                    /* 0190 */    0x13, 0x58, 0x1E, 0x30, 0x7A, 0x94, 0xF6, 0x2B, 
                    /* 0198 */    0x00, 0x21, 0xF8, 0x8B, 0xC5, 0x53, 0xC0, 0xEB, 
                    /* 01A0 */    0x40, 0x84, 0x63, 0x81, 0x29, 0x72, 0x6C, 0x68, 
                    /* 01A8 */    0x78, 0x7E, 0x70, 0x88, 0x1E, 0xF5, 0x5C, 0xC2, 
                    /* 01B0 */    0x1F, 0x4D, 0x94, 0x53, 0x38, 0x1C, 0x1F, 0x39, 
                    /* 01B8 */    0x8C, 0x10, 0xFE, 0x49, 0xE3, 0xC9, 0xC3, 0x9A, 
                    /* 01C0 */    0xEF, 0x00, 0x9A, 0xD2, 0x5B, 0xC0, 0xFB, 0x83, 
                    /* 01C8 */    0x47, 0x80, 0x11, 0x20, 0xE1, 0x68, 0x82, 0x89, 
                    /* 01D0 */    0x7C, 0x3A, 0x01, 0xD5, 0xFF, 0xFF, 0x74, 0x02, 
                    /* 01D8 */    0xB8, 0xBA, 0x01, 0x14, 0x37, 0x6A, 0x9D, 0x49, 
                    /* 01E0 */    0x7C, 0x2C, 0xF1, 0xAD, 0xE4, 0xBC, 0x43, 0xC5, 
                    /* 01E8 */    0x7F, 0x93, 0x78, 0x3A, 0xF1, 0x34, 0x1E, 0x4C, 
                    /* 01F0 */    0x42, 0x44, 0x89, 0x18, 0x21, 0xA2, 0xEF, 0x27, 
                    /* 01F8 */    0x46, 0x08, 0x15, 0x31, 0x6C, 0xA4, 0x37, 0x80, 
                    /* 0200 */    0xE7, 0x13, 0xE3, 0x84, 0x08, 0xF4, 0x74, 0xC2, 
                    /* 0208 */    0x42, 0x3E, 0x34, 0xA4, 0xE1, 0x74, 0x02, 0x50, 
                    /* 0210 */    0xE0, 0xFF, 0x7F, 0x3A, 0x81, 0x1F, 0xF5, 0x74, 
                    /* 0218 */    0x82, 0x1E, 0xAE, 0x4F, 0x19, 0x18, 0xE4, 0x03, 
                    /* 0220 */    0xF2, 0xA9, 0xC3, 0xF7, 0x1F, 0x13, 0xF8, 0x78, 
                    /* 0228 */    0xC2, 0x45, 0x1D, 0x4F, 0x50, 0xA7, 0x07, 0x1F, 
                    /* 0230 */    0x4F, 0xD8, 0x19, 0xE1, 0x2C, 0x1E, 0x03, 0x7C, 
                    /* 0238 */    0x3A, 0xC1, 0xDC, 0x13, 0x7C, 0x3A, 0x01, 0xDB, 
                    /* 0240 */    0x68, 0x60, 0x1C, 0x4F, 0xC0, 0x77, 0x74, 0xC1, 
                    /* 0248 */    0x1D, 0x4F, 0xC0, 0x30, 0x18, 0x18, 0xE7, 0x13, 
                    /* 0250 */    0xE0, 0x31, 0x5E, 0xDC, 0x31, 0xC0, 0x43, 0xE0, 
                    /* 0258 */    0x03, 0x78, 0xDC, 0x38, 0x3D, 0x2B, 0x9D, 0x14, 
                    /* 0260 */    0xF2, 0x24, 0xC2, 0x07, 0x85, 0x39, 0xB0, 0xE0, 
                    /* 0268 */    0x14, 0xDA, 0xF4, 0xA9, 0xD1, 0xA8, 0x55, 0x83, 
                    /* 0270 */    0x32, 0x35, 0xCA, 0x34, 0xA8, 0xD5, 0xA7, 0x52, 
                    /* 0278 */    0x63, 0xC6, 0xCE, 0x19, 0x0E, 0xF8, 0x10, 0xD0, 
                    /* 0280 */    0x89, 0xC0, 0xF2, 0x9E, 0x0D, 0x02, 0xB1, 0x0C, 
                    /* 0288 */    0x0A, 0x81, 0x58, 0xFA, 0xAB, 0x45, 0x20, 0x0E, 
                    /* 0290 */    0x0E, 0xA2, 0xFF, 0x3F, 0x88, 0x23, 0xD2, 0x0A, 
                    /* 0298 */    0xC4, 0xFF, 0x7F, 0x7F
                })
            }

            Device (IXVE)
            {
                Name (_ADR, 0x00100000)
                Name (_UID, 0x0B)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Name (_PRT, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.LGPU, 
                        0x00
                    }
                })
                Device (IGPU)
                {
                    Name (_ADR, 0x00)
                    Scope (\_SB.PCI0)
                    {
                        OperationRegion (HDCP, SystemMemory, 0x8FEE4D5C, 0x00000260)
                        Field (HDCP, AnyAcc, NoLock, Preserve)
                        {
                            SIGN,   48, 
                            CHKS,   8, 
                            RESR,   8, 
                            GLOB,   4800
                        }

                        OperationRegion (P4MR, SystemMemory, 0xE001B000, 0xFF)
                        Field (P4MR, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x44), 
                            BPLM,   8, 
                                ,   1, 
                            BPLN,   8, 
                                ,   9, 
                            BPLP,   2, 
                                    Offset (0x74), 
                                ,   18, 
                            VCO2,   1, 
                                ,   8, 
                            ASYC,   1, 
                                    Offset (0x78), 
                            CPLM,   8, 
                            CPLN,   8, 
                                    Offset (0xC8), 
                            MPLM,   4, 
                            MPLN,   4
                        }

                        OperationRegion (OA8D, SystemMemory, 0xE000B000, 0xFF)
                        Field (OA8D, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x50), 
                            NIST,   10, 
                                ,   2, 
                            NSB1,   4, 
                            NSB2,   4, 
                                    Offset (0x8C), 
                            TRFC,   10, 
                                    Offset (0x8F), 
                            TRCD,   4, 
                            WRRC,   4, 
                                    Offset (0x91), 
                            TR2P,   4, 
                                    Offset (0x9C), 
                                    Offset (0x9D), 
                            TRP,    4, 
                                    Offset (0xA0), 
                                    Offset (0xA2), 
                            TRC,    6, 
                                    Offset (0xA8), 
                            TROE,   1, 
                                ,   3, 
                            TROI,   3, 
                                    Offset (0xF4), 
                            BWCP,   7, 
                                    Offset (0xF5), 
                            BWIS,   7, 
                                    Offset (0xF6), 
                            BWWB,   7, 
                                    Offset (0xF7), 
                            BWHP,   7, 
                            HPCR,   1
                        }

                        OperationRegion (O8ER, SystemMemory, 0xE000C000, 0xFF)
                        Field (O8ER, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x70), 
                            CDP0,   1, 
                                    Offset (0x71), 
                            CDS0,   8, 
                                ,   4, 
                            CDC0,   4, 
                                ,   5, 
                            CDB0,   2, 
                                    Offset (0x74), 
                            CDP1,   1, 
                                    Offset (0x75), 
                            CDS1,   8, 
                                ,   4, 
                            CDC1,   4, 
                                ,   5, 
                            CDB1,   2, 
                                    Offset (0x78), 
                            CDP2,   1, 
                                    Offset (0x79), 
                            CDS2,   8, 
                                ,   4, 
                            CDC2,   4, 
                                ,   5, 
                            CDB2,   2, 
                                    Offset (0x7C), 
                            CDP3,   1, 
                                    Offset (0x7D), 
                            CDS3,   8, 
                                ,   4, 
                            CDC3,   4, 
                                ,   5, 
                            CDB3,   2, 
                                    Offset (0x80), 
                            INTL,   2, 
                            RCBD,   2, 
                                    Offset (0x81), 
                            PCIH,   5, 
                                    Offset (0x88), 
                            TOM1,   8, 
                            TOM2,   9, 
                                    Offset (0x90), 
                            P0P0,   1, 
                            P1P0,   1, 
                            P0N0,   1, 
                            P1N0,   1, 
                            PCR0,   1, 
                                    Offset (0x91), 
                            PCB0,   9, 
                                    Offset (0x93), 
                            PCS0,   8, 
                            P0P1,   1, 
                            P1P1,   1, 
                            P0N1,   1, 
                            P1N1,   1, 
                            PCR1,   1, 
                                    Offset (0x95), 
                            PCB1,   9, 
                                    Offset (0x97), 
                            PCS1,   8, 
                            P0P2,   1, 
                            P1P2,   1, 
                            P0N2,   1, 
                            P1N2,   1, 
                            PCR2,   1, 
                                    Offset (0x99), 
                            PCB2,   9, 
                                    Offset (0x9B), 
                            PCS2,   8, 
                            P0P3,   1, 
                            P1P3,   1, 
                            P0N3,   1, 
                            P1N3,   1, 
                            PCR3,   1, 
                                    Offset (0x9D), 
                            PCB3,   9, 
                                    Offset (0x9F), 
                            PCS3,   8, 
                            P0P4,   1, 
                            P1P4,   1, 
                            P0N4,   1, 
                            P1N4,   1, 
                            PCR4,   1, 
                                    Offset (0xA1), 
                            PCB4,   9, 
                                    Offset (0xA3), 
                            PCS4,   8, 
                                    Offset (0xC4), 
                            REFP,   16, 
                            REFB,   4
                        }
                    }

                    Name (ERR0, Buffer (0x04)
                    {
                        0x00, 0x00, 0x00, 0x00
                    })
                    Name (ERR1, Buffer (0x04)
                    {
                        0x01, 0x00, 0x00, 0x80
                    })
                    Name (ERR2, Buffer (0x04)
                    {
                        0x02, 0x00, 0x00, 0x80
                    })
                    Name (VER1, Buffer (0x04)
                    {
                        0x01, 0x00, 0x00, 0x00
                    })
                    Method (NVIF, 3, NotSerialized)
                    {
                        Store (ERR1, Local0)
                        If (LEqual (Arg0, 0x01))
                        {
                            Concatenate (ERR0, VER1, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x0D))
                            {
                                If (LEqual (Arg1, 0x00))
                                {
                                    Store (ERR0, Local0)
                                }
                                Else
                                {
                                    If (LEqual (Arg1, 0x02))
                                    {
                                        Name (BU2A, Buffer (0x04)
                                        {
                                            0x00
                                        })
                                        CreateField (BU2A, 0x10, 0x04, BF03)
                                        CreateField (BU2A, 0x14, 0x04, BF04)
                                        Name (BU2B, Buffer (0x04)
                                        {
                                            0x00
                                        })
                                        CreateField (BU2B, 0x00, 0x0B, BF07)
                                        CreateField (BU2B, 0x0B, 0x0E, BF08)
                                        Name (BU2C, Buffer (0x0A)
                                        {
                                            0x00
                                        })
                                        CreateField (BU2C, 0x00, 0x03, BF0A)
                                        CreateField (BU2C, 0x03, 0x04, BF0B)
                                        CreateField (BU2C, 0x07, 0x04, BF0C)
                                        CreateField (BU2C, 0x0B, 0x04, BF0D)
                                        CreateField (BU2C, 0x0F, 0x04, BF0E)
                                        CreateField (BU2C, 0x13, 0x26, BF0F)
                                        Name (BU2D, Buffer (0x0A)
                                        {
                                            0x00
                                        })
                                        CreateField (BU2D, 0x00, 0x10, BF1A)
                                        CreateField (BU2D, 0x10, 0x0B, TAVN)
                                        CreateField (BU2D, 0x1B, 0x0A, BASL)
                                        CreateField (BU2D, 0x25, 0x0B, LBWF)
                                        CreateField (BU2D, 0x30, 0x0C, ATBW)
                                        CreateField (BU2D, 0x3C, 0x0A, CLTF)
                                        CreateField (BU2D, 0x46, 0x0A, PMPF)
                                        Name (BNKN, 0x00)
                                        Name (BNKX, 0x00)
                                        Name (COLN, 0x00)
                                        Name (COLX, 0x00)
                                        Store (0x10, Index (BU2A, 0x00))
                                        Store (0x08, Index (BU2A, 0x01))
                                        Store (0x12, Index (BU2A, 0x02))
                                        Store (0xAA, Index (BU2A, 0x03))
                                        Store (0x02, BF04)
                                        Name (M2CL, 0x00)
                                        Store (GM2C (), M2CL)
                                        Multiply (M2CL, 0x02, BF08)
                                        Store (BU2B, Local2)
                                        If (LEqual (\_SB.PCI0.RCBD, 0x00))
                                        {
                                            Store (One, BF03)
                                            Multiply (0x08000000, \_SB.PCI0.TOM1, BF0F)
                                            Store (0x01, BF0A)
                                            If (\_SB.PCI0.INTL)
                                            {
                                                Store (0x02, BF0A)
                                            }

                                            If (\_SB.PCI0.CDP0)
                                            {
                                                Store (\_SB.PCI0.CDC0, BF0D)
                                                Store (\_SB.PCI0.CDB0, BF0B)
                                            }
                                            Else
                                            {
                                                If (\_SB.PCI0.CDP1)
                                                {
                                                    Store (\_SB.PCI0.CDC1, BF0D)
                                                    Store (\_SB.PCI0.CDB1, BF0B)
                                                }
                                                Else
                                                {
                                                    If (\_SB.PCI0.CDP2)
                                                    {
                                                        Store (\_SB.PCI0.CDC2, BF0D)
                                                        Store (\_SB.PCI0.CDB2, BF0B)
                                                    }
                                                    Else
                                                    {
                                                        If (\_SB.PCI0.CDP3)
                                                        {
                                                            Store (\_SB.PCI0.CDC3, BF0D)
                                                            Store (\_SB.PCI0.CDB3, BF0B)
                                                        }
                                                    }
                                                }
                                            }

                                            Store (BF0D, BF0E)
                                            Store (BF0B, BF0C)
                                            Store (Local2, Local1)
                                            Concatenate (Local1, BU2C, Local2)
                                            If (\_SB.PCI0.PCIH)
                                            {
                                                Store (0x02, BF03)
                                                Subtract (\_SB.PCI0.TOM2, 0x20, Local1)
                                                Multiply (0x08000000, Local1, BF0F)
                                                Store (Local2, Local1)
                                                Concatenate (Local1, BU2C, Local2)
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (\_SB.PCI0.RCBD, 0x02))
                                            {
                                                Store (Zero, BF03)
                                                Store (Zero, Local6)
                                                While (One)
                                                {
                                                    If (LEqual (Local6, 0x05))
                                                    {
                                                        Break
                                                    }

                                                    If (LOr (MP0P (Local6), MP1P (Local6)))
                                                    {
                                                        Store (MCRS (Local6), BF0F)
                                                        Store (0x01, BF0A)
                                                        If (MPCR (Local6))
                                                        {
                                                            If (MP0P (Local6))
                                                            {
                                                                If (MP1P (Local6))
                                                                {
                                                                    Store (0x02, BF0A)
                                                                }
                                                            }
                                                        }

                                                        Store (0x03, BNKN)
                                                        Store (0x02, BNKX)
                                                        Store (0x0C, COLN)
                                                        Store (0x08, COLX)
                                                        If (MP0P (Local6))
                                                        {
                                                            Store (MP0N (Local6), Local5)
                                                        }
                                                        Else
                                                        {
                                                            If (MP1P (Local6))
                                                            {
                                                                Store (MP1N (Local6), Local5)
                                                            }
                                                        }

                                                        If (LGreater (BNKN, MCDB (Local5)))
                                                        {
                                                            Store (MCDB (Local5), BNKN)
                                                        }

                                                        If (LLess (BNKX, MCDB (Local5)))
                                                        {
                                                            Store (MCDB (Local5), BNKX)
                                                        }

                                                        If (LGreater (COLN, MCDC (Local5)))
                                                        {
                                                            Store (MCDC (Local5), COLN)
                                                        }

                                                        If (LLess (COLX, MCDC (Local5)))
                                                        {
                                                            Store (MCDC (Local5), COLX)
                                                        }

                                                        Store (BNKN, BF0B)
                                                        Store (BNKX, BF0C)
                                                        Store (COLN, BF0D)
                                                        Store (COLX, BF0E)
                                                        Add (BF03, 0x01, BF03)
                                                        Store (Local2, Local1)
                                                        Concatenate (Local1, BU2C, Local2)
                                                    }

                                                    Increment (Local6)
                                                }
                                            }
                                            Else
                                            {
                                                Store (Zero, Local5)
                                            }
                                        }

                                        Store (BASM (M2CL), BASL)
                                        Store (BASL, BF07)
                                        Store (BASL, TAVN)
                                        Store (PMPM (M2CL), PMPF)
                                        Store (CLTM (M2CL), CLTF)
                                        Store (ATBM (M2CL), ATBW)
                                        Store (0x0FFF, LBWF)
                                        Store (0x3E, BF1A)
                                        Store (Local2, Local1)
                                        Concatenate (Local1, BU2D, Local2)
                                        Store (0xFFFF, BF1A)
                                        Store (ATBM (M2CL), ATBW)
                                        Store (0x0FFF, LBWF)
                                        Store (Local2, Local1)
                                        Concatenate (Local1, BU2D, Local2)
                                        Concatenate (ERR0, BU2A, Local1)
                                        Concatenate (Local1, Local2, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg1, 0x03))
                                        {
                                            Name (BFD1, Buffer (0x06)
                                            {
                                                0x10, 0x06, 0x01, 0x06, 0x00, 0x00
                                            })
                                            CreateField (BFD1, 0x20, 0x10, SVMS)
                                            Store (0x40, SVMS)
                                            Concatenate (ERR0, BFD1, Local0)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x0C))
                                {
                                    If (LEqual (Arg1, 0x00))
                                    {
                                        Store (ERR0, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg1, 0x01))
                                        {
                                            Store (GLOB, Local1)
                                            Concatenate (ERR0, Local1, Local0)
                                        }
                                    }
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x0B))
                                    {
                                        If (LEqual (Arg1, 0x00))
                                        {
                                            Store (ERR0, Local0)
                                        }
                                        Else
                                        {
                                            If (LEqual (Arg1, 0x03))
                                            {
                                                Store (Arg2, \_SB.PCI0.IXVE.IGPU.DDDS)
                                                Store (ERR0, Local0)
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Store (Zero, \_SB.PCI0.IXVE.IGPU.Z01J)
                        Return (Local0)
                    }

                    Method (MP0P, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.P0P0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.P0P1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.P0P2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.P0P3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.P0P4)
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MP1P, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.P1P0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.P1P1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.P1P2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.P1P3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.P1P4)
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MPCR, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.PCR0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.PCR1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.PCR2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.PCR3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.PCR4)
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MP0N, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.P0N0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.P0N1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.P0N2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.P0N3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.P0N4)
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MP1N, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.P1N0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.P1N1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.P1N2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.P1N3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.P1N4)
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MCRB, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.PCB0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.PCB1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.PCB2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.PCB3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.PCB4)
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MCRS, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.PCS0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.PCS1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.PCS2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.PCS3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.PCS4)
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MCDB, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.CDB0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.CDB1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.CDB2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.CDB3)
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (MCDC, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg0, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (\_SB.PCI0.CDC0)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (\_SB.PCI0.CDC1)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (\_SB.PCI0.CDC2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.CDC3)
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }

                    Method (NOCH, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.INTL, 0x03))
                        {
                            Store (0x02, Local6)
                        }
                        Else
                        {
                            If (LEqual (\_SB.PCI0.INTL, 0x00))
                            {
                                Store (0x01, Local6)
                            }
                            Else
                            {
                                If (LEqual (\_SB.PCI0.INTL, 0x02))
                                {
                                    Multiply (\_SB.PCI0.CDP0, \_SB.PCI0.CDS0, Local0)
                                    Multiply (\_SB.PCI0.CDP1, \_SB.PCI0.CDS1, Local1)
                                    Multiply (\_SB.PCI0.CDP2, \_SB.PCI0.CDS2, Local2)
                                    Multiply (\_SB.PCI0.CDP3, \_SB.PCI0.CDS3, Local3)
                                    Add (Local0, Local1, Local0)
                                    Add (Local2, Local3, Local2)
                                    If (LEqual (Local0, Local2))
                                    {
                                        Store (0x02, Local6)
                                    }
                                    Else
                                    {
                                        Store (0x01, Local6)
                                    }
                                }
                            }
                        }

                        Return (Local6)
                    }

                    Method (ATBM, 1, NotSerialized)
                    {
                        Multiply (Arg0, 0x02, Local0)
                        Multiply (Local0, NOCH (), Local0)
                        Multiply (0x08, Local0, Local0)
                        Multiply (Local0, \_SB.PCI0.BWHP, Local0)
                        Add (\_SB.PCI0.BWCP, \_SB.PCI0.BWIS, Local1)
                        Add (Local1, \_SB.PCI0.BWWB, Local1)
                        Add (Local1, \_SB.PCI0.BWHP, Local1)
                        Divide (Local0, Local1, Local1, Local0)
                        Multiply (Local0, 0x03, Local0)
                        Divide (Local0, 0x28, Local1, Local0)
                        Return (Local0)
                    }

                    Method (GM2C, 0, NotSerialized)
                    {
                        Multiply (\_SB.PCI0.CPLN, 0x19, Local1)
                        Multiply (\_SB.PCI0.BPLN, Local1, Local1)
                        Add (\_SB.PCI0.BPLP, 0x01, Local2)
                        Multiply (Local2, \_SB.PCI0.CPLM, Local2)
                        Multiply (Local2, \_SB.PCI0.BPLM, Local2)
                        Store (Local1, Local3)
                        Multiply (Local3, \_SB.PCI0.MPLN, Local1)
                        Multiply (Local2, \_SB.PCI0.MPLM, Local2)
                        Divide (Local1, Local2, , Local3)
                        If (LEqual (\_SB.PCI0.VCO2, 0x00))
                        {
                            Multiply (Local3, 0x02, Local3)
                        }

                        Return (Local3)
                    }

                    Method (PMPM, 1, NotSerialized)
                    {
                        Multiply (0x0F, 0x03E8, Local0)
                        Divide (Local0, Arg0, Local0, Local1)
                        Return (Local1)
                    }

                    Method (CLTM, 1, NotSerialized)
                    {
                        Divide (0x04, NOCH (), Local0, Local1)
                        Multiply (0x03E8, Local1, Local0)
                        Divide (Local0, Arg0, Local0, Local1)
                        Return (Local1)
                    }

                    Method (BASM, 1, NotSerialized)
                    {
                        Name (M2CK, 0x00)
                        Name (NPAR, 0x00)
                        Store (NOCH (), NPAR)
                        Store (Arg0, M2CK)
                        Name (TPAR, 0x04)
                        Divide (TPAR, NPAR, , TPAR)
                        Subtract (TPAR, 0x02, TPAR)
                        Name (BUCO, 0x00)
                        Add (TPAR, \_SB.PCI0.TRCD, BUCO)
                        Add (BUCO, \_SB.PCI0.TR2P, BUCO)
                        Add (BUCO, \_SB.PCI0.TRP, BUCO)
                        Name (B2CO, 0x00)
                        Store (MAX (\_SB.PCI0.TRC, BUCO), B2CO)
                        Store (CEIL (B2CO, 0x02), B2CO)
                        Name (TBM2, 0x00)
                        If (LEqual (\_SB.PCI0.TROE, 0x01))
                        {
                            Store (\_SB.PCI0.TROI, TBM2)
                        }

                        Name (TMAX, 0x00)
                        Add (TMAX, TBM2, TMAX)
                        Add (TMAX, BUCO, TMAX)
                        Add (TMAX, TPAR, TMAX)
                        Store (MAX (TMAX, B2CO), TMAX)
                        Name (SWBC, 0x00)
                        Multiply (TMAX, \_SB.PCI0.BWWB, SWBC)
                        Multiply (SWBC, NPAR, SWBC)
                        Divide (SWBC, 0x02, , SWBC)
                        Name (SCPU, 0x00)
                        Multiply (TMAX, \_SB.PCI0.BWCP, SCPU)
                        Multiply (SCPU, NPAR, SCPU)
                        Divide (SCPU, 0x02, , SCPU)
                        Name (SISO, 0x00)
                        Add (TBM2, BUCO, Local1)
                        Add (Local1, NPAR, Local1)
                        Subtract (Local1, 0x02, Local1)
                        Store (MAX (Local1, B2CO), Local1)
                        Multiply (Local1, \_SB.PCI0.BWIS, SISO)
                        Name (RCBZ, 0x10)
                        Name (CBHP, 0x02)
                        Name (SHIS, 0x00)
                        Multiply (RCBZ, 0x04, SHIS)
                        Divide (SHIS, NPAR, , SHIS)
                        Subtract (SHIS, 0x02, SHIS)
                        Add (SHIS, BUCO, SHIS)
                        Add (SHIS, TBM2, SHIS)
                        Store (MAX (SHIS, B2CO), SHIS)
                        Multiply (SHIS, CBHP, SHIS)
                        Name (BIDH, 0x01)
                        Name (BWCO, 0x00)
                        Add (SWBC, SCPU, BWCO)
                        Add (BWCO, SISO, BWCO)
                        Add (BWCO, SHIS, BWCO)
                        Multiply (BWCO, BIDH, BWCO)
                        Name (NISB, 0x00)
                        Store (\_SB.PCI0.NSB1, NISB)
                        ShiftLeft (\_SB.PCI0.NSB2, 0x04, Local1)
                        Or (Local1, NISB, NISB)
                        Name (NICO, 0x00)
                        Divide (BWCO, \_SB.PCI0.NIST, Local2, Local1)
                        If (LNotEqual (Local2, 0x00))
                        {
                            Add (Local1, 0x01, Local1)
                        }

                        Multiply (NISB, NPAR, Local2)
                        Add (TBM2, NPAR, Local3)
                        If (LGreater (Local3, 0x02))
                        {
                            Subtract (Local3, 0x02, Local3)
                        }
                        Else
                        {
                            Store (0x00, Local3)
                        }

                        Store (MAX (Local3, B2CO), Local3)
                        Multiply (Local2, Local3, NICO)
                        Multiply (NICO, Local1, NICO)
                        Divide (NICO, 0x02, , NICO)
                        Name (RECO, 0x00)
                        Add (BWCO, NICO, RECO)
                        Divide (RECO, \_SB.PCI0.REFP, Local2, RECO)
                        If (LNotEqual (Local2, 0x00))
                        {
                            Add (RECO, 0x01, RECO)
                        }

                        Multiply (RECO, \_SB.PCI0.TRFC, RECO)
                        Multiply (RECO, \_SB.PCI0.REFB, RECO)
                        Name (MELA, 0x00)
                        Add (BWCO, RECO, MELA)
                        Add (MELA, NICO, MELA)
                        Multiply (MELA, 0x03E8, MELA)
                        Divide (MELA, M2CK, , MELA)
                        Name (WALA, 0x00)
                        Divide (0x00030D40, M2CK, , WALA)
                        Name (SWLA, 0x00)
                        Name (M73L, 0x64)
                        Name (PADD, 0x00)
                        Add (MELA, WALA, Local1)
                        Add (Local1, SWLA, Local1)
                        Add (Local1, M73L, Local1)
                        Add (Local1, PADD, Local1)
                        Divide (Local1, 0x64, , Local0)
                        Return (Local0)
                    }

                    Method (MAX, 2, NotSerialized)
                    {
                        Store (Arg0, Local0)
                        If (LGreater (Arg1, Arg0))
                        {
                            Store (Arg1, Local0)
                        }

                        Return (Local0)
                    }

                    Method (CEIL, 2, NotSerialized)
                    {
                        Store (Arg0, Local0)
                        Divide (Local0, Arg1, Local1, Local3)
                        If (LNotEqual (Local1, 0x00))
                        {
                            Subtract (Local0, Local1, Local0)
                            Add (Local0, Arg1, Local0)
                        }

                        Return (Local0)
                    }

                    Name (SWIT, 0x00)
                    Name (Z01J, 0x00)
                    Name (DDDS, Buffer (0x14) {})
                    CreateWordField (DDDS, 0x00, D0ID)
                    CreateBitField (DDDS, 0x12, D0EN)
                    CreateBitField (DDDS, 0x14, D0CN)
                    CreateWordField (DDDS, 0x04, D1ID)
                    CreateBitField (DDDS, 0x32, D1EN)
                    CreateBitField (DDDS, 0x34, D1CN)
                    CreateWordField (DDDS, 0x08, D2ID)
                    CreateBitField (DDDS, 0x52, D2EN)
                    CreateBitField (DDDS, 0x54, D2CN)
                    CreateWordField (DDDS, 0x0C, D3ID)
                    CreateBitField (DDDS, 0x72, D3EN)
                    CreateBitField (DDDS, 0x74, D3CN)
                    CreateWordField (DDDS, 0x10, D4ID)
                    CreateBitField (DDDS, 0x92, D4EN)
                    CreateBitField (DDDS, 0x94, D4CN)
                    Method (DDEV, 1, NotSerialized)
                    {
                        And (Arg0, 0xFFFF, Local0)
                        If (LEqual (Local0, D0ID))
                        {
                            Return (D0EN)
                        }
                        Else
                        {
                            If (LEqual (Local0, D1ID))
                            {
                                Return (D1EN)
                            }
                            Else
                            {
                                If (LEqual (Local0, D2ID))
                                {
                                    Return (D2EN)
                                }
                                Else
                                {
                                    If (LEqual (Local0, D3ID))
                                    {
                                        Return (D3EN)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local0, D4ID))
                                        {
                                            Return (D4EN)
                                        }
                                        Else
                                        {
                                            Return (0x00)
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Method (DDCN, 1, NotSerialized)
                    {
                        And (Arg0, 0xFFFF, Local0)
                        If (LEqual (Local0, D0ID))
                        {
                            Return (D0CN)
                        }
                        Else
                        {
                            If (LEqual (Local0, D1ID))
                            {
                                Return (D1CN)
                            }
                            Else
                            {
                                If (LEqual (Local0, D2ID))
                                {
                                    Return (D2CN)
                                }
                                Else
                                {
                                    If (LEqual (Local0, D3ID))
                                    {
                                        Return (D3CN)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local0, D4ID))
                                        {
                                            Return (D4CN)
                                        }
                                        Else
                                        {
                                            Return (0x00)
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Method (DGSM, 0, NotSerialized)
                    {
                        Store (DGS1 (), Local0)
                        Store (GNAD (Local0), Local1)
                        DGS2 (Local1)
                    }

                    Method (DGS1, 0, NotSerialized)
                    {
                        Store (0x00, Local0)
                        If (0x01)
                        {
                            Or (Local0, 0x01, Local0)
                        }

                        If (DDCN (0x80000100))
                        {
                            Or (Local0, 0x02, Local0)
                        }

                        If (DDCN (0x80000200))
                        {
                            Or (Local0, 0x04, Local0)
                        }

                        If (LGreater (\_SB.TOOS, 0x05))
                        {
                            If (DDCN (0x80007330))
                            {
                                Or (Local0, 0x08, Local0)
                            }

                            If (DDCN (0x80006341))
                            {
                                Or (Local0, 0x10, Local0)
                            }
                        }
                        Else
                        {
                            If (DDCN (0x0111))
                            {
                                Or (Local0, 0x08, Local0)
                            }

                            If (DDCN (0x0112))
                            {
                                Or (Local0, 0x10, Local0)
                            }
                        }

                        Store (0x00, Local1)
                        If (DDEV (0x0110))
                        {
                            Or (Local1, 0x01, Local1)
                        }

                        If (DDEV (0x80000100))
                        {
                            Or (Local1, 0x02, Local1)
                        }

                        If (DDEV (0x80000200))
                        {
                            Or (Local1, 0x04, Local1)
                        }

                        If (LGreater (\_SB.TOOS, 0x05))
                        {
                            If (DDEV (0x80007330))
                            {
                                Or (Local1, 0x08, Local1)
                            }

                            If (DDEV (0x80006341))
                            {
                                Or (Local1, 0x10, Local1)
                            }
                        }
                        Else
                        {
                            If (DDEV (0x0111))
                            {
                                Or (Local1, 0x08, Local1)
                            }

                            If (DDEV (0x0112))
                            {
                                Or (Local1, 0x10, Local1)
                            }
                        }

                        Store (Local1, \_SB.PCI0.SR00)
                        Store (Local0, \_SB.PCI0.SR01)
                        Return (Local1)
                    }

                    Method (DGS2, 1, NotSerialized)
                    {
                        Store (\_SB.PCI0.SR00, Local1)
                        Store (\_SB.PCI0.SR01, Local0)
                        Store (Arg0, Local4)
                        Store (0x05, Local3)
                        While (Local3)
                        {
                            Store (Local4, Local1)
                            And (Local0, Local1, Local2)
                            If (LEqual (Local1, Local2))
                            {
                                Store (Local1, SWIT)
                                Break
                            }

                            Decrement (Local3)
                        }
                    }

                    Method (GNAD, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Return (0x03)
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            Return (0x02)
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            Return (0x09)
                        }

                        If (LEqual (Arg0, 0x09))
                        {
                            Return (0x08)
                        }

                        Return (0x01)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        If (LGreater (\_SB.TOOS, 0x05))
                        {
                            Return (Package (0x05)
                            {
                                0x0110, 
                                0x80000100, 
                                0x80000200, 
                                0x80007330, 
                                0x80006341
                            })
                        }
                        Else
                        {
                            Return (Package (0x05)
                            {
                                0x0110, 
                                0x0100, 
                                0x0200, 
                                0x0111, 
                                0x0112
                            })
                        }
                    }

                    Device (LCD0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            If (LGreater (\_SB.TOOS, 0x05))
                            {
                                Return (0x0110)
                            }
                            Else
                            {
                                Return (0x0110)
                            }
                        }

                        Method (MXMX, 1, NotSerialized)
                        {
                            Return (0x01)
                        }

                        Name (BCL0, Package (0x12)
                        {
                            0x0F, 
                            0x07, 
                            0x00, 
                            0x01, 
                            0x02, 
                            0x03, 
                            0x04, 
                            0x05, 
                            0x06, 
                            0x07, 
                            0x08, 
                            0x09, 
                            0x0A, 
                            0x0B, 
                            0x0C, 
                            0x0D, 
                            0x0E, 
                            0x0F
                        })
                        Method (_BCL, 0, NotSerialized)
                        {
                            Return (BCL0)
                        }

                        Method (_BCM, 1, NotSerialized)
                        {
                            CMSB (Arg0)
                            \_SB.PCI0.LPC0.PHS2 (0x80, 0x01)
                        }

                        Method (_BQC, 0, NotSerialized)
                        {
                            Return (CMSR ())
                        }

                        Method (CMSB, 1, NotSerialized)
                        {
                            If (\ECON)
                            {
                                Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                                Store (\_SB.PCI0.LPC0.EC0.ACIN, Local0)
                                Release (\_SB.PCI0.LPC0.EC0.MUT0)
                            }
                            Else
                            {
                                Store (0x01, Local0)
                            }

                            If (Local0)
                            {
                                Store (Arg0, \_SB.BRNS)
                            }
                            Else
                            {
                                Store (Arg0, \_SB.BRND)
                            }
                        }

                        Method (CMSR, 0, NotSerialized)
                        {
                            If (\ECON)
                            {
                                Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                                Store (\_SB.PCI0.LPC0.EC0.ACIN, Local0)
                                Release (\_SB.PCI0.LPC0.EC0.MUT0)
                            }
                            Else
                            {
                                Store (0x01, Local0)
                            }

                            If (Local0)
                            {
                                Return (\_SB.BRNS)
                            }
                            Else
                            {
                                Return (\_SB.BRND)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (SWIT, 0x01, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Device (CRT0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            If (LGreater (\_SB.TOOS, 0x05))
                            {
                                Return (0x80000100)
                            }
                            Else
                            {
                                Return (0x0100)
                            }
                        }

                        Method (MXMX, 1, NotSerialized)
                        {
                            Return (0x01)
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (SWIT, 0x02, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Device (SVD0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            If (LGreater (\_SB.TOOS, 0x05))
                            {
                                Return (0x80000200)
                            }
                            Else
                            {
                                Return (0x0200)
                            }
                        }

                        Method (MXMX, 1, NotSerialized)
                        {
                            Return (0x01)
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (SWIT, 0x04, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Device (DSP0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            If (LGreater (\_SB.TOOS, 0x05))
                            {
                                Return (0x80007330)
                            }
                            Else
                            {
                                Return (0x0111)
                            }
                        }

                        Method (MXMX, 1, NotSerialized)
                        {
                            Return (0x01)
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (SWIT, 0x08, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Device (DSP1)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            If (LGreater (\_SB.TOOS, 0x05))
                            {
                                Return (0x80006341)
                            }
                            Else
                            {
                                Return (0x0112)
                            }
                        }

                        Method (MXMX, 1, NotSerialized)
                        {
                            Return (0x01)
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (SWIT, 0x10, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }
                }
            }

            Device (P2P0)
            {
                Name (_ADR, 0x00090000)
                Name (_UID, 0x02)
                OperationRegion (A080, PCI_Config, 0x19, 0x01)
                Field (A080, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Name (_PRT, Package (0x02)
                {
                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x00, 
                        \_SB.PCI0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x01, 
                        \_SB.PCI0.LNK2, 
                        0x00
                    }
                })
                Name (_PRW, Package (0x02)
                {
                    0x00, 
                    0x05
                })
            }

            Device (XVR0)
            {
                Name (_ADR, 0x000C0000)
                Name (_UID, 0x10)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Device (Z01I)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR1)
            {
                Name (_ADR, 0x000D0000)
                Name (_UID, 0x11)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Device (Z01K)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR2)
            {
                Name (_ADR, 0x000E0000)
                Name (_UID, 0x12)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Device (Z01L)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR3)
            {
                Name (_ADR, 0x00150000)
                Name (_UID, 0x13)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Device (Z01M)
                {
                    Name (_ADR, 0x00)
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (0x01)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR4)
            {
                Name (_ADR, 0x00160000)
                Name (_UID, 0x14)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Device (Z01N)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR5)
            {
                Name (_ADR, 0x00170000)
                Name (_UID, 0x15)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Device (Z01O)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR6)
            {
                Name (_ADR, 0x00180000)
                Name (_UID, 0x16)
                OperationRegion (A1E0, PCI_Config, 0x19, 0x01)
                Field (A1E0, ByteAcc, NoLock, Preserve)
                {
                    SECB,   8
                }

                Method (_BBN, 0, NotSerialized)
                {
                    Return (SECB)
                }

                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Device (Z01P)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Scope (\_SB.PCI0)
            {
                OperationRegion (MXOP, SystemMemory, 0x000F9732, 0x000000C8)
                Field (MXOP, AnyAcc, NoLock, Preserve)
                {
                    MXMB,   1600
                }
            }

            Scope (\_SB.PCI0.XVR0.Z01I)
            {
                Method (_DSM, 4, NotSerialized)
                {
                    If (LEqual (Arg0, Buffer (0x10)
                            {
                                /* 0000 */    0x00, 0xA4, 0x04, 0x40, 0x7D, 0x91, 0xF2, 0x4C, 
                                /* 0008 */    0xB8, 0x9C, 0x79, 0xB6, 0x2F, 0xD5, 0x56, 0x65
                            }))
                    {
                        If (LNotEqual (Arg1, 0x0300))
                        {
                            Return (0x80000002)
                        }

                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg2, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Return (Buffer (0x01)
                                {
                                    0x3F
                                })
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    Return (0x30)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        Return (GMXM (0x03, 0x00))
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            Return (\_SB.PCI0.IXVE.IGPU.PLAT (Arg3))
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (\_SB.PCI0.IXVE.IGPU.DSMS (Arg3))
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_0, 0x05))
                                                {
                                                    Return (Package (0x1A)
                                                    {
                                                        0x0110, 
                                                        0x2C, 
                                                        0x80000100, 
                                                        0x2C, 
                                                        0x80000200, 
                                                        0x2C, 
                                                        0x80006341, 
                                                        0x2C, 
                                                        0x0110, 
                                                        0x80000100, 
                                                        0x2C, 
                                                        0x0110, 
                                                        0x80000200, 
                                                        0x2C, 
                                                        0x0110, 
                                                        0x80006341, 
                                                        0x2C, 
                                                        0x80000100, 
                                                        0x80000200, 
                                                        0x2C, 
                                                        0x80000100, 
                                                        0x80007330, 
                                                        0x2C, 
                                                        0x80000200, 
                                                        0x80006341, 
                                                        0x2C
                                                    })
                                                }
                                                Else
                                                {
                                                    If (LEqual (_T_0, 0x06)) {}
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }
                    }
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Return (Package (0x04)
                    {
                        0x80000100, 
                        0x0110, 
                        0x80000200, 
                        0x80006341
                    })
                }

                Device (CRT0)
                {
                    Name (_ADR, 0x80000100)
                    Method (MXMX, 1, NotSerialized)
                    {
                        Return (0x01)
                    }
                }

                Device (LCD0)
                {
                    Name (_ADR, 0x0110)
                    Method (MXMX, 1, NotSerialized)
                    {
                        Return (0x01)
                    }

                    Alias (\_SB.PCI0.IXVE.IGPU.LCD0._BCL, _BCL)
                    Alias (\_SB.PCI0.IXVE.IGPU.LCD0._BCM, _BCM)
                    Alias (\_SB.PCI0.IXVE.IGPU.LCD0._BQC, _BQC)
                }

                Device (SVD0)
                {
                    Name (_ADR, 0x80000200)
                    Method (MXMX, 1, NotSerialized)
                    {
                        Return (0x01)
                    }
                }

                Device (DPV0)
                {
                    Name (_ADR, 0x80006341)
                    Method (MXMX, 1, NotSerialized)
                    {
                        Return (0x01)
                    }
                }

                Method (GMXM, 2, NotSerialized)
                {
                    Divide (0x0640, 0x08, , Local0)
                    Name (BUMA, Buffer (Local0) {})
                    Store (MXMB, BUMA)
                    Store (Zero, Local1)
                    While (One)
                    {
                        Add (Local1, 0x06, Local2)
                        Store (DerefOf (Index (BUMA, Local2)), Local3)
                        If (Local3)
                        {
                            Add (Local3, 0x08, Local3)
                        }
                        Else
                        {
                            Break
                        }

                        Store (Local1, Local4)
                        Add (Local4, 0x04, Local4)
                        If (LEqual (DerefOf (Index (BUMA, Local4)), Arg0))
                        {
                            Increment (Local4)
                            If (LEqual (DerefOf (Index (BUMA, Local4)), Arg1))
                            {
                                Multiply (Local1, 0x08, Local1)
                                Multiply (Local3, 0x08, Local3)
                                CreateField (BUMA, Local1, Local3, TMPB)
                                Return (TMPB)
                            }
                        }

                        Add (Local1, Local3, Local1)
                        If (LGreater (Local1, Local0))
                        {
                            Break
                        }
                    }

                    Return (Buffer (0x08)
                    {
                        0x00
                    })
                }

                Method (MXMI, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x20))
                    {
                        Return (0x20)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x21))
                        {
                            Return (0x21)
                        }
                        Else
                        {
                            Return (0x30)
                        }
                    }
                }

                Method (MXMS, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x20))
                    {
                        Return (GMXM (0x02, 0x00))
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x21))
                        {
                            Return (GMXM (0x02, 0x01))
                        }
                        Else
                        {
                            Return (GMXM (0x03, 0x00))
                        }
                    }
                }
            }

            Scope (\_SB.PCI0)
            {
                OperationRegion (MM90, SystemMemory, 0xE0060000, 0x1000)
                Field (MM90, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x90), 
                        ,   4, 
                    CSLD,   1, 
                        ,   22, 
                    CSLT,   1, 
                        ,   1, 
                    SDLA,   1, 
                            Offset (0xFC8), 
                    PMAP,   4
                }

                OperationRegion (IONB, SystemIO, 0x1400, 0xFF)
                Field (IONB, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x80), 
                    SR00,   8, 
                    SR01,   8, 
                    SR02,   8, 
                    SR03,   8, 
                            Offset (0xC3), 
                    GP04,   8, 
                    GP05,   8, 
                            Offset (0xD0), 
                    GP17,   8, 
                            Offset (0xE5), 
                    GP38,   8, 
                            Offset (0xE7), 
                    GP40,   8, 
                            Offset (0xEE), 
                    GP47,   8, 
                    GP48,   8, 
                            Offset (0xF3), 
                    GP52,   8, 
                            Offset (0xF5), 
                    GP54,   8
                }

                OperationRegion (IONA, SystemIO, 0x1800, 0xFF)
                Field (IONA, ByteAcc, NoLock, Preserve)
                {
                    NAID,   4, 
                            Offset (0x70), 
                    HPMK,   7
                }

                OperationRegion (IONC, SystemIO, 0x1000, 0xFF)
                Field (IONC, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    THRO,   8
                }

                OperationRegion (RTCO, SystemIO, 0x72, 0x02)
                Field (RTCO, ByteAcc, NoLock, Preserve)
                {
                    CIND,   8, 
                    CDAT,   8
                }

                IndexField (CIND, CDAT, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x61), 
                    HYCM,   1, 
                    HPSP,   2, 
                    HBDP,   4, 
                            Offset (0x62), 
                    TVCC,   4, 
                    PFLG,   2, 
                            Offset (0x63), 
                    TVFC,   5, 
                            Offset (0x6C), 
                    CMO1,   4
                }

                OperationRegion (ROM1, SystemMemory, 0x8FECF6CA, 0x00010000)
                Field (ROM1, AnyAcc, Lock, Preserve)
                {
                    VBF1,   262144, 
                    VBF2,   262144
                }

                Method (GETB, 3, Serialized)
                {
                    Multiply (Arg0, 0x08, Local0)
                    Multiply (Arg1, 0x08, Local1)
                    CreateField (Arg2, Local0, Local1, TBF3)
                    Sleep (0xA0)
                    Return (TBF3)
                }
            }

            Scope (\_SB.PCI0.IXVE.IGPU)
            {
                OperationRegion (IGPU, PCI_Config, 0x40, 0x04)
                Field (IGPU, ByteAcc, NoLock, Preserve)
                {
                    SVID,   32
                }

                Name (DSMF, 0x00)
                Method (_DSM, 4, NotSerialized)
                {
                    Store ("------- DSM --------", Debug)
                    If (LEqual (Arg0, Buffer (0x10)
                            {
                                /* 0000 */    0xA0, 0xA0, 0x95, 0x9D, 0x60, 0x00, 0x48, 0x4D, 
                                /* 0008 */    0xB3, 0x4D, 0x7E, 0x5F, 0xEA, 0x12, 0x9F, 0xD4
                            }))
                    {
                        If (LNotEqual (Arg1, 0x0102))
                        {
                            Return (0x80000002)
                        }

                        While (One)
                        {
                            Name (_T_0, 0x00)
                            Store (Arg2, _T_0)
                            If (LEqual (_T_0, 0x00))
                            {
                                Store (One, DSMF)
                                Return (0x7F)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x01))
                                {
                                    If (HYCM)
                                    {
                                        Return (Buffer (0x04)
                                        {
                                            0x01, 0x00, 0x00, 0x00
                                        })
                                    }
                                    Else
                                    {
                                        Return (Buffer (0x04)
                                        {
                                            0x00
                                        })
                                    }
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x02))
                                    {
                                        CreateByteField (Arg3, 0x00, DSM2)
                                        If (And (DSM2, 0x10))
                                        {
                                            And (DSM2, 0x0F, Local0)
                                            Store (Local0, CMO1)
                                            Notify (\_SB.PCI0.IXVE.IGPU, 0xD9)
                                            Return (Local0)
                                        }
                                        Else
                                        {
                                            Store (CMO1, Local0)
                                            Increment (Local0)
                                            If (LGreater (Local0, 0x02))
                                            {
                                                Store (Zero, Local0)
                                            }

                                            Or (0x10, Local0, Local0)
                                            Return (Local0)
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x03))
                                        {
                                            CreateByteField (Arg3, 0x00, PWFC)
                                            If (LEqual (PWFC, 0x01))
                                            {
                                                \_SB.PCI0.XVR0.Z01I.DGON ()
                                            }
                                            Else
                                            {
                                                If (LEqual (PWFC, 0x02))
                                                {
                                                    \_SB.PCI0.XVR0.Z01I.DGOF ()
                                                }
                                                Else
                                                {
                                                    \_SB.PCI0.XVR0.Z01I.HSTA ()
                                                }
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x04))
                                            {
                                                Return (PLAT (Arg3))
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_0, 0x05))
                                                {
                                                    Return (DSMS (Arg3))
                                                }
                                                Else
                                                {
                                                    If (LEqual (_T_0, 0x06))
                                                    {
                                                        Return (Package (0x11)
                                                        {
                                                            0x0110, 
                                                            0x2C, 
                                                            0x0110, 
                                                            0x80000100, 
                                                            0x2C, 
                                                            0x80000100, 
                                                            0x2C, 
                                                            0x0110, 
                                                            0x80007330, 
                                                            0x2C, 
                                                            0x80007330, 
                                                            0x2C, 
                                                            0x0110, 
                                                            0x80006341, 
                                                            0x2C, 
                                                            0x80006341, 
                                                            0x2C
                                                        })
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (_T_0, 0x07)) {}
                                                        Else
                                                        {
                                                            If (LEqual (_T_0, 0x08)) {}
                                                            Else
                                                            {
                                                                If (LEqual (_T_0, 0x09)) {}
                                                                Else
                                                                {
                                                                    If (LEqual (_T_0, 0x0A)) {}
                                                                    Else
                                                                    {
                                                                        If (LEqual (_T_0, 0x0B)) {}
                                                                        Else
                                                                        {
                                                                            If (LEqual (_T_0, 0x0C)) {}
                                                                            Else
                                                                            {
                                                                                If (LEqual (_T_0, 0x0D)) {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }

                        Return (0x00)
                    }
                }

                Name (HKFL, 0x00)
                Name (CTOI, 0x00)
                Name (NTOI, 0x00)
                Method (DSHK, 0, NotSerialized)
                {
                    If (LAnd (DSMF, HYCM))
                    {
                        Store (One, HKFL)
                        If (CTOI)
                        {
                            Store (CTOI, NTOI)
                            Increment (NTOI)
                            If (LEqual (NTOI, 0x12))
                            {
                                Store (0x01, NTOI)
                            }
                        }

                        Return (One)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (DSMS, 1, NotSerialized)
                {
                    Name (NFBU, Buffer (0x04)
                    {
                        0x00
                    })
                    CreateField (NFBU, 0x00, 0x04, DAVF)
                    CreateField (NFBU, 0x04, 0x01, LIDF)
                    CreateField (NFBU, 0x08, 0x06, DTOG)
                    Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                    Store (\_SB.PCI0.LPC0.EC0.DVSW, Local2)
                    Store (\_SB.PCI0.LPC0.EC0.QSCO, Local3)
                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                    If (LEqual (Local3, 0x00))
                    {
                        If (HKFL)
                        {
                            If (And (DerefOf (Index (Arg0, 0x03)), 0x80))
                            {
                                Store (DerefOf (Index (Arg0, 0x03)), Local0)
                                And (Local0, 0x3E, Local0)
                                ShiftRight (Local0, 0x01, Local0)
                                Store (Local0, CTOI)
                                Store (Zero, HKFL)
                                Store (CTOI, DTOG)
                            }
                            Else
                            {
                                If (And (DerefOf (Index (Arg0, 0x03)), 0x01))
                                {
                                    If (LNot (CTOI))
                                    {
                                        Store (DerefOf (Index (Arg0, 0x01)), Local0)
                                        ShiftRight (Local0, 0x04, Local0)
                                        Store (DerefOf (Index (Arg0, 0x02)), Local1)
                                        ShiftLeft (Local1, 0x04, Local1)
                                        Or (Local0, Local1, Local0)
                                        Store (GATD (Local0), CTOI)
                                    }

                                    Store (CTOI, NTOI)
                                    Increment (NTOI)
                                    Store (NTOI, DTOG)
                                    Store (One, DAVF)
                                }
                            }
                        }
                        Else
                        {
                            If (LNot (CTOI))
                            {
                                If (And (DerefOf (Index (Arg0, 0x03)), 0x01))
                                {
                                    Store (DerefOf (Index (Arg0, 0x01)), Local0)
                                    ShiftRight (Local0, 0x04, Local0)
                                    Store (DerefOf (Index (Arg0, 0x02)), Local1)
                                    ShiftLeft (Local1, 0x04, Local1)
                                    Or (Local0, Local1, Local0)
                                    Store (GATD (Local0), CTOI)
                                }
                            }

                            Store (CTOI, DTOG)
                        }
                    }

                    If (LEqual (Local3, 0x01))
                    {
                        Store (GATD (Local2), CTOI)
                        Store (CTOI, DTOG)
                        Store (One, DAVF)
                    }

                    Return (NFBU)
                }

                Method (GATD, 1, NotSerialized)
                {
                    While (One)
                    {
                        Name (_T_0, 0x00)
                        Store (Arg0, _T_0)
                        If (LEqual (_T_0, 0x01))
                        {
                            Return (0x01)
                        }
                        Else
                        {
                            If (LEqual (_T_0, 0x03))
                            {
                                Return (0x02)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x02))
                                {
                                    Return (0x03)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x09))
                                    {
                                        Return (0x04)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x08))
                                        {
                                            Return (0x05)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x11))
                                            {
                                                Return (0x06)
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_0, 0x10))
                                                {
                                                    Return (0x07)
                                                }
                                                Else
                                                {
                                                    Return (0x01)
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Break
                    }
                }

                Method (PLAT, 1, NotSerialized)
                {
                    Store ("------- PLATPOLICY --------", Debug)
                    Name (NFBU, Buffer (0x04)
                    {
                        0x00, 0x90, 0x10, 0x04
                    })
                    CreateField (NFBU, 0x0C, 0x01, BDOF)
                    CreateField (NFBU, 0x0D, 0x02, PSRF)
                    CreateField (NFBU, 0x0F, 0x01, PSOF)
                    CreateField (NFBU, 0x10, 0x04, PTVF)
                    CreateField (NFBU, 0x14, 0x01, PTVO)
                    CreateField (NFBU, 0x15, 0x05, TVFF)
                    CreateField (NFBU, 0x1A, 0x01, TVOF)
                    If (And (DerefOf (Index (Arg0, 0x01)), 0x10))
                    {
                        Store (DerefOf (Index (Arg0, 0x00)), HBDP)
                        Store (Zero, BDOF)
                        Store (0x02, PFLG)
                    }

                    If (And (DerefOf (Index (Arg0, 0x02)), 0x01))
                    {
                        Store (DerefOf (Index (Arg0, 0x01)), Local0)
                        And (Local0, 0x60, Local0)
                        ShiftRight (Local0, 0x05, HPSP)
                        Store (Zero, PSOF)
                        Store (0x02, PFLG)
                    }

                    If (And (DerefOf (Index (Arg0, 0x02)), 0x20))
                    {
                        Store (DerefOf (Index (Arg0, 0x02)), Local0)
                        And (Local0, 0x1E, Local0)
                        ShiftRight (Local0, 0x01, TVCC)
                        Store (Zero, PTVO)
                        Store (0x02, PFLG)
                    }

                    If (And (DerefOf (Index (Arg0, 0x03)), 0x08))
                    {
                        Store (DerefOf (Index (Arg0, 0x02)), Local0)
                        ShiftRight (Local0, 0x06, Local0)
                        Store (DerefOf (Index (Arg0, 0x03)), Local1)
                        And (Local1, 0x07, Local1)
                        ShiftLeft (Local1, 0x02, Local1)
                        Or (Local1, Local0, TVFC)
                        Store (Zero, TVOF)
                        Store (0x02, PFLG)
                    }

                    Store (HPSP, PSRF)
                    Store (HBDP, Index (NFBU, 0x00))
                    Store (TVCC, PTVF)
                    Store (TVFC, TVFF)
                    Return (NFBU)
                }
            }

            Scope (\_SB.PCI0.XVR0.Z01I)
            {
                Name (MAPV, 0x00)
                Name (MAPF, 0x00)
                OperationRegion (BAR0, SystemMemory, 0xE0200000, 0x0FFF)
                Field (BAR0, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x488), 
                        ,   25, 
                    HDAE,   1
                }

                OperationRegion (MXMA, PCI_Config, 0x00, 0x04)
                Field (MXMA, ByteAcc, NoLock, Preserve)
                {
                    DVID,   32
                }

                OperationRegion (MXMC, PCI_Config, 0x40, 0x04)
                Field (MXMC, ByteAcc, NoLock, Preserve)
                {
                    SVID,   32
                }

                Method (DGON, 0, NotSerialized)
                {
                    Store ("--MXM ON--", Debug)
                    Store (0x65, GP38)
                    Store (0xC8, Local0)
                    While (Local0)
                    {
                        If (And (GP48, 0x20))
                        {
                            Break
                        }

                        Sleep (0x0A)
                        Decrement (Local0)
                    }

                    Sleep (0x64)
                    Store (0x65, GP17)
                    Store (Zero, CSLD)
                    Sleep (0x64)
                    Store (0xC8, Local0)
                    While (Local0)
                    {
                        If (LAnd (LNot (CSLT), SDLA))
                        {
                            Break
                        }

                        Sleep (0x0A)
                        Decrement (Local0)
                    }

                    Store (\_SB.PCI0.IXVE.IGPU.SVID, \_SB.PCI0.XVR0.Z01I.SVID)
                    If (LNotEqual (DVID, 0x06E810DE))
                    {
                        Store (0x00, HDAE)
                        Store (0xAB, DBUG)
                    }

                    Store ("--MXM ON done --", Debug)
                }

                Method (DGOF, 0, NotSerialized)
                {
                    Store ("--MXM OFF--", Debug)
                    Store (Zero, NAID)
                    Or (0x01, HPMK, HPMK)
                    Store (One, CSLD)
                    Store (0xC8, Local0)
                    While (Local0)
                    {
                        If (LNot (SDLA))
                        {
                            Break
                        }

                        Sleep (0x0A)
                        Decrement (Local0)
                    }

                    Store (0x64, GP17)
                    Store (0x64, GP38)
                    Store (0xB2, DBUG)
                    Store ("--MXM OFF done --", Debug)
                }

                Method (HSTA, 0, NotSerialized)
                {
                    If (And (GP38, 0x01))
                    {
                        Return (One)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (_ROM, 2, NotSerialized)
                {
                    If (LGreater (Add (Arg0, Arg1), 0x00010000))
                    {
                        Subtract (Arg0, 0x00010000, Arg0)
                    }

                    If (LGreaterEqual (Arg0, 0x8000))
                    {
                        Return (GETB (Subtract (Arg0, 0x8000), Arg1, VBF2))
                    }

                    If (LGreater (Add (Arg0, Arg1), 0x8000))
                    {
                        Subtract (0x8000, Arg0, Local0)
                        Subtract (Arg1, Local0, Local1)
                        Store (GETB (Arg0, Local0, VBF1), Local3)
                        Store (GETB (0x00, Local1, VBF2), Local4)
                        Concatenate (Local3, Local4, Local5)
                        Return (Local5)
                    }

                    Return (GETB (Arg0, Arg1, VBF1))
                }
            }

            Device (SAT0)
            {
                Name (_ADR, 0x000B0000)
                Device (PRI0)
                {
                    Name (_ADR, 0x00)
                    Name (SPTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0010 */    0x1F, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SPTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SPTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Device (SEC0)
                {
                    Name (_ADR, 0x01)
                    Name (SSTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0010 */    0x1F, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SSTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SSTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Method (DRMP, 0, NotSerialized)
                {
                    Return (\_SB.R_S0)
                }
            }

            Scope (\_SB.PCI0)
            {
                Device (NVRB)
                {
                    Name (_HID, "NVRAIDBUS")
                    Name (FNVR, 0xFF)
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, FNVR)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.R_ST, 0x01))
                        {
                            If (LEqual (FNVR, 0xFF))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x04D2,             // Range Minimum
                            0x04D2,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (0xFF, FNVR)
                    }
                }
            }

            Device (MMTM)
            {
                Name (_HID, EisaId ("PNP0103"))
                Name (_UID, 0x00)
                Name (MTB0, ResourceTemplate ()
                {
                    IRQNoFlags ()
                        {0}
                    IRQNoFlags ()
                        {8}
                    Memory32Fixed (ReadOnly,
                        0x00000000,         // Address Base
                        0x00000400,         // Address Length
                        _Y02)
                })
                CreateDWordField (MTB0, \_SB.PCI0.MMTM._Y02._BAS, TBAS)
                Name (MTB1, ResourceTemplate ()
                {
                })
                Method (_STA, 0, NotSerialized)
                {
                    If (And (\_SB.PCI0.LPC0.MTSE, 0x04))
                    {
                        Return (0x0F)
                    }

                    Return (0x00)
                }

                Method (_CRS, 0, Serialized)
                {
                    If (And (\_SB.PCI0.LPC0.MTSE, 0x04))
                    {
                        Store (\_SB.PCI0.LPC0.MTBA, TBAS)
                        Return (MTB0)
                    }
                    Else
                    {
                        Return (MTB1)
                    }
                }
            }

            Device (LPC0)
            {
                Name (_ADR, 0x00030000)
                OperationRegion (P44, PCI_Config, 0x44, 0x04)
                Field (P44, AnyAcc, NoLock, Preserve)
                {
                    MTBA,   32
                }

                OperationRegion (MMTO, PCI_Config, 0x74, 0x04)
                Field (MMTO, DWordAcc, NoLock, Preserve)
                {
                    MTSE,   32
                }

                Device (MBRD)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x03)
                    Name (RSRC, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y03)
                    })
                    CreateDWordField (RSRC, \_SB.PCI0.LPC0.MBRD._Y03._BAS, MBAS)
                    CreateDWordField (RSRC, \_SB.PCI0.LPC0.MBRD._Y03._LEN, MBLE)
                    Method (_CRS, 0, NotSerialized)
                    {
                        If (\_SB.PCI0.SMB0.SMUB)
                        {
                            Store (\_SB.PCI0.SMB0.SMUB, MBAS)
                            Store (0x8000, MBLE)
                        }

                        Return (RSRC)
                    }
                }

                Device (PMIO)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x05)
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (IODM, ResourceTemplate ()
                        {
                            IO (Decode16,
                                0x0000,             // Range Minimum
                                0x0000,             // Range Maximum
                                0x00,               // Alignment
                                0x00,               // Length
                                )
                        })
                        Name (IORT, ResourceTemplate ()
                        {
                            IO (Decode16,
                                0x0000,             // Range Minimum
                                0x0000,             // Range Maximum
                                0x01,               // Alignment
                                0x80,               // Length
                                _Y04)
                            IO (Decode16,
                                0x0000,             // Range Minimum
                                0x0000,             // Range Maximum
                                0x01,               // Alignment
                                0x80,               // Length
                                _Y05)
                            IO (Decode16,
                                0x0000,             // Range Minimum
                                0x0000,             // Range Maximum
                                0x01,               // Alignment
                                0x80,               // Length
                                _Y06)
                            IO (Decode16,
                                0x0000,             // Range Minimum
                                0x0000,             // Range Maximum
                                0x01,               // Alignment
                                0x80,               // Length
                                _Y07)
                            IO (Decode16,
                                0x0000,             // Range Minimum
                                0x0000,             // Range Maximum
                                0x01,               // Alignment
                                0x80,               // Length
                                _Y08)
                            IO (Decode16,
                                0x0000,             // Range Minimum
                                0x0000,             // Range Maximum
                                0x01,               // Alignment
                                0x80,               // Length
                                _Y09)
                        })
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y04._MIN, I1MN)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y04._MAX, I1MX)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y05._MIN, I2MN)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y05._MAX, I2MX)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y06._MIN, I3MN)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y06._MAX, I3MX)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y07._MIN, I4MN)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y07._MAX, I4MX)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y08._MIN, I5MN)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y08._MAX, I5MX)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y09._MIN, I6MN)
                        CreateWordField (IORT, \_SB.PCI0.LPC0.PMIO._CRS._Y09._MAX, I6MX)
                        And (\_SB.PCI0.SMB0.PMBR, 0xFFFC, I1MN)
                        Store (I1MN, I1MX)
                        Add (I1MN, 0x80, Local0)
                        Store (Local0, I2MN)
                        Store (Local0, I2MX)
                        And (\_SB.PCI0.SMB0.NVSB, 0xFFFC, I3MN)
                        Store (I3MN, I3MX)
                        Add (I3MN, 0x80, Local0)
                        Store (Local0, I4MN)
                        Store (Local0, I4MX)
                        And (\_SB.PCI0.SMB0.ANLG, 0xFFFC, I5MN)
                        Store (I5MN, I5MX)
                        Add (I5MN, 0x80, Local0)
                        Store (Local0, I6MN)
                        Store (Local0, I6MX)
                        If (I1MN)
                        {
                            Store (IORT, Local0)
                        }
                        Else
                        {
                            Store (IODM, Local0)
                        }

                        Return (Local0)
                    }
                }

                Device (KBC0)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Range Minimum
                            0x0060,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0064,             // Range Minimum
                            0x0064,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {1}
                    })
                }

                Device (MSE0)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {12}
                    })
                }

                OperationRegion (SMI0, SystemIO, 0x0000FE00, 0x00000002)
                Field (SMI0, AnyAcc, NoLock, Preserve)
                {
                    SMIC,   8
                }

                OperationRegion (SMI1, SystemMemory, 0x8FEE3C57, 0x00001096)
                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    BCMD,   8, 
                    DID,    32, 
                    INFO,   1024
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                            AccessAs (ByteAcc, 0x00), 
                            Offset (0x05), 
                    INFB,   8
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x05), 
                    INFD,   32
                }

                Mutex (PSMX, 0x00)
                Method (PHS1, 1, NotSerialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x00, DID)
                    Store (Arg0, BCMD)
                    Store (Zero, SMIC)
                    Store (INFD, Local0)
                    Release (PSMX)
                    Return (Local0)
                }

                Method (PHS2, 2, NotSerialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x00, DID)
                    Store (Arg1, INFD)
                    Store (Arg0, BCMD)
                    Store (Zero, SMIC)
                    Store (INFD, Local0)
                    Release (PSMX)
                    Return (Local0)
                }
            }

            Device (SYS0)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x01)
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0010,             // Range Minimum
                        0x0010,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x0022,             // Range Minimum
                        0x0022,             // Range Maximum
                        0x01,               // Alignment
                        0x1E,               // Length
                        )
                    IO (Decode16,
                        0x0044,             // Range Minimum
                        0x0044,             // Range Maximum
                        0x01,               // Alignment
                        0x1C,               // Length
                        )
                    IO (Decode16,
                        0x0072,             // Range Minimum
                        0x0072,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0074,             // Range Minimum
                        0x0074,             // Range Maximum
                        0x01,               // Alignment
                        0x0C,               // Length
                        )
                    IO (Decode16,
                        0x0091,             // Range Minimum
                        0x0091,             // Range Maximum
                        0x01,               // Alignment
                        0x03,               // Length
                        )
                    IO (Decode16,
                        0x0097,             // Range Minimum
                        0x0097,             // Range Maximum
                        0x01,               // Alignment
                        0x09,               // Length
                        )
                    IO (Decode16,
                        0x00A2,             // Range Minimum
                        0x00A2,             // Range Maximum
                        0x01,               // Alignment
                        0x1E,               // Length
                        )
                    IO (Decode16,
                        0x00E0,             // Range Minimum
                        0x00E0,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x04D0,             // Range Minimum
                        0x04D0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0080,             // Range Minimum
                        0x0080,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                    IO (Decode16,
                        0x0910,             // Range Minimum
                        0x0910,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0295,             // Range Minimum
                        0x0295,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                })
            }

            Device (PIC0)
            {
                Name (_HID, EisaId ("PNP0000"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0020,             // Range Minimum
                        0x0020,             // Range Maximum
                        0x04,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00A0,             // Range Minimum
                        0x00A0,             // Range Maximum
                        0x04,               // Alignment
                        0x02,               // Length
                        )
                    IRQ (Edge, ActiveHigh, Exclusive, )
                        {2}
                })
            }

            Device (PIT0)
            {
                Name (_HID, EisaId ("PNP0100"))
                Name (PTB0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x10,               // Alignment
                        0x04,               // Length
                        )
                    IRQ (Edge, ActiveHigh, Exclusive, )
                        {0}
                })
                Name (PTB1, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x10,               // Alignment
                        0x04,               // Length
                        )
                })
                Method (_CRS, 0, Serialized)
                {
                    If (And (\_SB.PCI0.LPC0.MTSE, 0x04))
                    {
                        Return (PTB1)
                    }
                    Else
                    {
                        Return (PTB0)
                    }
                }
            }

            Device (DMA0)
            {
                Name (_HID, EisaId ("PNP0200"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x09,               // Length
                        )
                    IO (Decode16,
                        0x000A,             // Range Minimum
                        0x000A,             // Range Maximum
                        0x01,               // Alignment
                        0x06,               // Length
                        )
                    IO (Decode16,
                        0x0081,             // Range Minimum
                        0x0081,             // Range Maximum
                        0x01,               // Alignment
                        0x03,               // Length
                        )
                    IO (Decode16,
                        0x0087,             // Range Minimum
                        0x0087,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                    IO (Decode16,
                        0x0089,             // Range Minimum
                        0x0089,             // Range Maximum
                        0x01,               // Alignment
                        0x03,               // Length
                        )
                    IO (Decode16,
                        0x008F,             // Range Minimum
                        0x008F,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                    IO (Decode16,
                        0x00C0,             // Range Minimum
                        0x00C0,             // Range Maximum
                        0x01,               // Alignment
                        0x12,               // Length
                        )
                    IO (Decode16,
                        0x00D4,             // Range Minimum
                        0x00D4,             // Range Maximum
                        0x01,               // Alignment
                        0x0C,               // Length
                        )
                    DMA (Compatibility, BusMaster, Transfer8, )
                        {4}
                })
            }

            Device (SPK0)
            {
                Name (_HID, EisaId ("PNP0800"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0061,             // Range Minimum
                        0x0061,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                })
            }

            Device (RTC0)
            {
                Name (_HID, EisaId ("PNP0B00"))
                Name (RCB0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IRQ (Edge, ActiveHigh, Exclusive, )
                        {8}
                })
                Name (RCB1, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                })
                Method (_CRS, 0, Serialized)
                {
                    If (And (\_SB.PCI0.LPC0.MTSE, 0x04))
                    {
                        Return (RCB1)
                    }
                    Else
                    {
                        Return (RCB0)
                    }
                }
            }

            Device (MTH0)
            {
                Name (_HID, EisaId ("PNP0C04"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x00F0,             // Range Minimum
                        0x00F0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IRQ (Edge, ActiveHigh, Exclusive, )
                        {13}
                })
            }

            Device (CIR)
            {
                Name (_HID, EisaId ("ITE8708"))
                Name (BUF0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0300,             // Range Minimum
                        0x0300,             // Range Maximum
                        0x08,               // Alignment
                        0x08,               // Length
                        )
                    IRQNoFlags ()
                        {10}
                })
                Method (_CRS, 0, Serialized)
                {
                    Return (BUF0)
                }
            }

            Scope (\_SB.PCI0.LPC0)
            {
                Device (SLPB)
                {
                    Name (_HID, EisaId ("PNP0C0E"))
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_UID, 0x01)
                    Name (\ECON, 0x00)
                    Name (\BTCE, 0x00)
                    Name (\TMP0, 0x00)
                    Name (_GPE, 0x47)
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BFFR, ResourceTemplate ()
                        {
                            IO (Decode16,
                                0x0062,             // Range Minimum
                                0x0062,             // Range Maximum
                                0x00,               // Alignment
                                0x01,               // Length
                                )
                            IO (Decode16,
                                0x0066,             // Range Minimum
                                0x0066,             // Range Maximum
                                0x00,               // Alignment
                                0x01,               // Length
                                )
                        })
                        Return (BFFR)
                    }

                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x01), 
                            ,   7, 
                        CCAA,   1, 
                                Offset (0x18), 
                        SMPR,   8, 
                        SMST,   8, 
                        SMAD,   8, 
                        SMCM,   8, 
                        SMD0,   256, 
                        BCNT,   8, 
                        SMAA,   8, 
                        BATD,   16, 
                        ACIN,   1, 
                        PWON,   1, 
                        INS3,   1, 
                        WPSW,   1, 
                        INS4,   1, 
                        INST,   1, 
                        WHWP,   1, 
                        RCCO,   1, 
                            ,   4, 
                        LIDS,   1, 
                                Offset (0x43), 
                            ,   4, 
                        BANK,   4, 
                                Offset (0x49), 
                        DVSW,   8, 
                                Offset (0x55), 
                        TOPT,   8, 
                        TVGA,   8, 
                        TCPT,   8, 
                        TCPU,   8, 
                        TSYS,   8, 
                        TDTS,   8, 
                                Offset (0x60), 
                        FANM,   8, 
                                Offset (0x68), 
                        FANH,   8, 
                        FANL,   8, 
                                Offset (0x6D), 
                        BRLV,   8, 
                                Offset (0x82), 
                        NOS0,   8, 
                                Offset (0x88), 
                        QSCO,   1, 
                                Offset (0xB8), 
                        BID1,   8, 
                        BID2,   8, 
                                Offset (0xC4), 
                        MFNM,   8, 
                        DLNM,   8, 
                        BTCN,   8, 
                                Offset (0xCB), 
                        BTIN,   1, 
                        BTFU,   1, 
                        BTDT,   1, 
                        BTPF,   1, 
                        BTRT,   1, 
                        BTLW,   1, 
                        BTNC,   1, 
                        BTDD,   1, 
                        BTCG,   1, 
                        BTPC,   1, 
                        BTOT,   1, 
                        BTNI,   1, 
                        BTWK,   1, 
                        BTIC,   1, 
                        BTWC,   1, 
                        BTL3,   1
                    }

                    Field (ERAM, WordAcc, NoLock, Preserve)
                    {
                                Offset (0xA0), 
                        BTRC,   16, 
                                Offset (0xA4), 
                        BTPV,   16, 
                        BTCT,   16, 
                                Offset (0xAC), 
                        BTPR,   16, 
                        BTFC,   16, 
                        BTDC,   16, 
                        BTDV,   16
                    }

                    Name (BATO, 0x00)
                    Name (BATN, 0x00)
                    Name (BATF, 0xC0)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LAnd (LEqual (Arg0, 0x03), LEqual (Arg1, 0x01)))
                        {
                            Store (0x01, \ECON)
                        }
                    }

                    Method (_Q80, 0, NotSerialized)
                    {
                        Store (0x80, DBUG)
                        If (LEqual (QSCO, 0x00))
                        {
                            Notify (\_SB.PCI0.XVR0.Z01I.LCD0, 0x86)
                            Notify (\_SB.PCI0.IXVE.IGPU.LCD0, 0x86)
                        }
                        Else
                        {
                            Store (\_SB.PCI0.IXVE.IGPU.LCD0.CMSR (), Local0)
                            If (LEqual (Local0, 0x0F))
                            {
                                Store (0x0F, Local1)
                            }
                            Else
                            {
                                Add (Local0, 0x01, Local1)
                            }

                            \_SB.PCI0.IXVE.IGPU.LCD0.CMSB (Local1)
                        }
                    }

                    Method (_Q81, 0, NotSerialized)
                    {
                        Store (0x81, DBUG)
                        If (LEqual (QSCO, 0x00))
                        {
                            Notify (\_SB.PCI0.XVR0.Z01I.LCD0, 0x87)
                            Notify (\_SB.PCI0.IXVE.IGPU.LCD0, 0x87)
                        }
                        Else
                        {
                            Store (\_SB.PCI0.IXVE.IGPU.LCD0.CMSR (), Local0)
                            If (LEqual (Local0, 0x00))
                            {
                                Store (0x00, Local1)
                            }
                            Else
                            {
                                Subtract (Local0, 0x01, Local1)
                            }

                            \_SB.PCI0.IXVE.IGPU.LCD0.CMSB (Local1)
                        }
                    }

                    Method (_Q82, 0, NotSerialized)
                    {
                        Notify (\_SB.LID, 0x80)
                        Store (0x82, DBUG)
                    }

                    Method (_Q83, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.LPC0.EC0.ADP0, 0x80)
                        Store (0x83, DBUG)
                    }

                    Method (_Q84, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.LPC0.EC0.ADP0, 0x80)
                        Store (0x84, DBUG)
                    }

                    Method (_Q85, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.LPC0.EC0.BAT0, 0x81)
                        Notify (\_SB.PCI0.LPC0.EC0.BAT0, 0x82)
                        Store (0x85, DBUG)
                    }

                    Method (_Q86, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.LPC0.EC0.BAT0, 0x81)
                        Notify (\_SB.PCI0.LPC0.EC0.BAT0, 0x82)
                        Store (0x86, DBUG)
                    }

                    Method (Z01Q, 0, NotSerialized)
                    {
                        \_SB.AMW0.Z00I ()
                        \_SB.AMW0.Z00L ()
                        Store (0x2B, \_SB.AMW0.PT6C)
                        Store (0x01, \_SB.MMBO)
                    }

                    Method (Z01R, 0, NotSerialized)
                    {
                        \_SB.AMW0.Z00I ()
                        \_SB.AMW0.Z00L ()
                        Store (0x2C, \_SB.AMW0.PT6C)
                        Store (0x00, \_SB.MMBO)
                    }

                    Method (_Q8C, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.WLEN, 0x00))
                        {
                            If (LEqual (\_SB.BTEN, 0x00))
                            {
                                If (LEqual (\_SB.WWEN, 0x01))
                                {
                                    If (LEqual (\_SB.WWAK, 0x01))
                                    {
                                        Store (0x05, \_SB.PCI0.GP40)
                                        Z01Q ()
                                    }

                                    If (LEqual (\_SB.WWAK, 0x00))
                                    {
                                        Z01R ()
                                    }
                                }

                                If (LEqual (\_SB.WWEN, 0x00))
                                {
                                    Z01R ()
                                }
                            }

                            If (LEqual (\_SB.BTEN, 0x01))
                            {
                                If (LEqual (\_SB.WWEN, 0x01))
                                {
                                    If (LEqual (\_SB.WPAK, 0x01))
                                    {
                                        If (LEqual (\_SB.WWAK, 0x01))
                                        {
                                            Store (0x05, \_SB.PCI0.GP40)
                                            Store (0x05, \_SB.PCI0.GP54)
                                            Z01Q ()
                                        }

                                        If (LEqual (\_SB.WWAK, 0x00))
                                        {
                                            Store (0x05, \_SB.PCI0.GP54)
                                            Z01Q ()
                                        }
                                    }

                                    If (LEqual (\_SB.WPAK, 0x00))
                                    {
                                        If (LEqual (\_SB.WWAK, 0x00))
                                        {
                                            Z01R ()
                                        }

                                        If (LEqual (\_SB.WWAK, 0x01))
                                        {
                                            Store (0x05, \_SB.PCI0.GP40)
                                            Z01Q ()
                                        }
                                    }
                                }

                                If (LEqual (\_SB.WWEN, 0x00))
                                {
                                    If (LEqual (\_SB.WPAK, 0x01))
                                    {
                                        Store (0x05, \_SB.PCI0.GP54)
                                        Z01Q ()
                                    }

                                    If (LEqual (\_SB.WPAK, 0x00))
                                    {
                                        Z01R ()
                                    }
                                }
                            }
                        }

                        If (LEqual (\_SB.WLEN, 0x01))
                        {
                            If (LEqual (\_SB.BTEN, 0x00))
                            {
                                If (LEqual (\_SB.WWEN, 0x01))
                                {
                                    If (LEqual (\_SB.WLAK, 0x01))
                                    {
                                        If (LEqual (\_SB.WWAK, 0x01))
                                        {
                                            Store (0x05, \_SB.PCI0.GP40)
                                            Store (0x05, \_SB.PCI0.GP52)
                                            Z01Q ()
                                        }

                                        If (LEqual (\_SB.WWAK, 0x00))
                                        {
                                            Store (0x05, \_SB.PCI0.GP52)
                                            Z01Q ()
                                        }
                                    }

                                    If (LEqual (\_SB.WLAK, 0x00))
                                    {
                                        If (LEqual (\_SB.WWAK, 0x01))
                                        {
                                            Store (0x05, \_SB.PCI0.GP40)
                                            Z01Q ()
                                        }

                                        If (LEqual (\_SB.WWAK, 0x00))
                                        {
                                            Z01R ()
                                        }
                                    }
                                }

                                If (LEqual (\_SB.WWEN, 0x00))
                                {
                                    If (LEqual (\_SB.WLAK, 0x01))
                                    {
                                        Store (0x05, \_SB.PCI0.GP52)
                                        Z01Q ()
                                    }

                                    If (LEqual (\_SB.WLAK, 0x00))
                                    {
                                        Z01R ()
                                    }
                                }
                            }

                            If (LEqual (\_SB.BTEN, 0x01))
                            {
                                If (LEqual (\_SB.WWEN, 0x01))
                                {
                                    If (LEqual (\_SB.WLAK, 0x01))
                                    {
                                        If (LEqual (\_SB.WPAK, 0x01))
                                        {
                                            If (LEqual (\_SB.WWAK, 0x01))
                                            {
                                                Store (0x05, \_SB.PCI0.GP40)
                                                Store (0x05, \_SB.PCI0.GP54)
                                                Store (0x05, \_SB.PCI0.GP52)
                                                Z01Q ()
                                            }

                                            If (LEqual (\_SB.WWAK, 0x00))
                                            {
                                                Store (0x05, \_SB.PCI0.GP54)
                                                Store (0x05, \_SB.PCI0.GP52)
                                                Z01Q ()
                                            }
                                        }

                                        If (LEqual (\_SB.WPAK, 0x00))
                                        {
                                            If (LEqual (\_SB.WWAK, 0x01))
                                            {
                                                Store (0x05, \_SB.PCI0.GP40)
                                                Store (0x05, \_SB.PCI0.GP52)
                                                Z01Q ()
                                            }

                                            If (LEqual (\_SB.WWAK, 0x00))
                                            {
                                                Store (0x05, \_SB.PCI0.GP52)
                                                Z01Q ()
                                            }
                                        }
                                    }

                                    If (LEqual (\_SB.WLAK, 0x00))
                                    {
                                        If (LEqual (\_SB.WPAK, 0x01))
                                        {
                                            If (LEqual (\_SB.WWAK, 0x01))
                                            {
                                                Store (0x05, \_SB.PCI0.GP40)
                                                Store (0x05, \_SB.PCI0.GP54)
                                                Z01Q ()
                                            }

                                            If (LEqual (\_SB.WWAK, 0x00))
                                            {
                                                Store (0x05, \_SB.PCI0.GP54)
                                                Z01Q ()
                                            }
                                        }

                                        If (LEqual (\_SB.WPAK, 0x00))
                                        {
                                            If (LEqual (\_SB.WWAK, 0x01))
                                            {
                                                Store (0x05, \_SB.PCI0.GP40)
                                                Z01Q ()
                                            }

                                            If (LEqual (\_SB.WWAK, 0x00))
                                            {
                                                Z01R ()
                                            }
                                        }
                                    }
                                }

                                If (LEqual (\_SB.WWEN, 0x00))
                                {
                                    If (LEqual (\_SB.WLAK, 0x01))
                                    {
                                        If (LEqual (\_SB.WPAK, 0x01))
                                        {
                                            Store (0x05, \_SB.PCI0.GP54)
                                            Store (0x05, \_SB.PCI0.GP52)
                                            Z01Q ()
                                        }

                                        If (LEqual (\_SB.WPAK, 0x00))
                                        {
                                            Store (0x05, \_SB.PCI0.GP52)
                                            Z01Q ()
                                        }
                                    }

                                    If (LEqual (\_SB.WLAK, 0x00))
                                    {
                                        If (LEqual (\_SB.WPAK, 0x01))
                                        {
                                            Store (0x05, \_SB.PCI0.GP54)
                                            Z01Q ()
                                        }

                                        If (LEqual (\_SB.WPAK, 0x00))
                                        {
                                            Z01R ()
                                        }
                                    }
                                }
                            }
                        }

                        Store (0x8C, DBUG)
                    }

                    Method (_Q8D, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.WLAK, 0x01))
                        {
                            If (LEqual (\_SB.WPAK, 0x01))
                            {
                                If (LEqual (\_SB.WWAK, 0x01))
                                {
                                    Store (0x04, \_SB.PCI0.GP40)
                                    Store (0x04, \_SB.PCI0.GP54)
                                    Store (0x04, \_SB.PCI0.GP52)
                                    Z01R ()
                                }

                                If (LEqual (\_SB.WWAK, 0x00))
                                {
                                    Store (0x04, \_SB.PCI0.GP54)
                                    Store (0x04, \_SB.PCI0.GP52)
                                    Z01R ()
                                }
                            }

                            If (LEqual (\_SB.WPAK, 0x00))
                            {
                                If (LEqual (\_SB.WWAK, 0x01))
                                {
                                    Store (0x04, \_SB.PCI0.GP40)
                                    Store (0x04, \_SB.PCI0.GP52)
                                    Z01R ()
                                }

                                If (LEqual (\_SB.WWAK, 0x00))
                                {
                                    Store (0x04, \_SB.PCI0.GP52)
                                    Z01R ()
                                }
                            }
                        }

                        If (LEqual (\_SB.WLAK, 0x00))
                        {
                            If (LEqual (\_SB.WPAK, 0x01))
                            {
                                If (LEqual (\_SB.WWAK, 0x01))
                                {
                                    Store (0x04, \_SB.PCI0.GP40)
                                    Store (0x04, \_SB.PCI0.GP54)
                                    Z01R ()
                                }

                                If (LEqual (\_SB.WWAK, 0x00))
                                {
                                    Store (0x04, \_SB.PCI0.GP54)
                                    Z01R ()
                                }
                            }

                            If (LEqual (\_SB.WPAK, 0x00))
                            {
                                If (LEqual (\_SB.WWAK, 0x01))
                                {
                                    Store (0x04, \_SB.PCI0.GP40)
                                    Z01R ()
                                }

                                If (LEqual (\_SB.WWAK, 0x00))
                                {
                                    Z01R ()
                                }
                            }
                        }

                        Store (0x8D, DBUG)
                    }

                    Method (_Q8F, 0, NotSerialized)
                    {
                        Store (0x01, BTCE)
                        Notify (\_SB.PCI0.LPC0.EC0.ADP0, 0x80)
                        Notify (\_SB.PCI0.LPC0.EC0.BAT0, 0x80)
                        Store (0x8F, DBUG)
                    }

                    Method (_Q90, 0, NotSerialized)
                    {
                        Store (0x00, BTCE)
                        Notify (\_SB.PCI0.LPC0.EC0.ADP0, 0x80)
                        Notify (\_SB.PCI0.LPC0.EC0.BAT0, 0x80)
                        Store (0x90, DBUG)
                    }

                    Method (Z01S, 1, NotSerialized)
                    {
                        And (\_SB.PCI0.THRO, 0xE0, Local0)
                        Or (Local0, Arg0, Local0)
                        Store (Local0, \_SB.PCI0.THRO)
                    }

                    Method (_Q91, 0, NotSerialized)
                    {
                        Z01S (0x00)
                        Store (0x86, DBUG)
                    }

                    Method (_Q98, 0, NotSerialized)
                    {
                        Z01S (0x12)
                        Store (0x87, DBUG)
                    }

                    Method (_Q97, 0, NotSerialized)
                    {
                        Z01S (0x14)
                        Store (0x88, DBUG)
                    }

                    Method (_Q96, 0, NotSerialized)
                    {
                        Z01S (0x16)
                        Store (0x89, DBUG)
                    }

                    Method (_Q95, 0, NotSerialized)
                    {
                        Z01S (0x18)
                        Store (0x8A, DBUG)
                    }

                    Method (_Q94, 0, NotSerialized)
                    {
                        Z01S (0x1A)
                        Store (0x8B, DBUG)
                    }

                    Method (_Q93, 0, NotSerialized)
                    {
                        Z01S (0x1C)
                        Store (0x8C, DBUG)
                    }

                    Method (_Q92, 0, NotSerialized)
                    {
                        Z01S (0x1E)
                        Store (0x8D, DBUG)
                    }

                    Method (_Q99, 0, NotSerialized)
                    {
                        Store (0x00, \_PR.CPU0._PPC)
                        Notify (\_PR.CPU0, 0x80)
                        Sleep (0x03E8)
                    }

                    Method (_Q9A, 0, NotSerialized)
                    {
                        Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                        Store (NOS0, Local0)
                        Release (\_SB.PCI0.LPC0.EC0.MUT0)
                        Store (Local0, \_PR.CPU0._PPC)
                        Notify (\_PR.CPU0, 0x80)
                        Sleep (0x03E8)
                    }

                    Method (_QFD, 0, NotSerialized)
                    {
                        Store (One, \_SB.PCI0.IXVE.IGPU.Z01J)
                        Notify (\_SB.PCI0.IXVE.IGPU, 0xCB)
                        While (\_SB.PCI0.IXVE.IGPU.Z01J)
                        {
                            Sleep (0x0A)
                        }

                        Store (\_SB.PCI0.IXVE.IGPU.DGS1 (), Local0)
                        If (LOr (LEqual (Local0, 0x12), LEqual (Local0, 0x0A)))
                        {
                            Store (0x01, Local0)
                        }

                        Acquire (MUT0, 0xFFFF)
                        Store (Local0, DVSW)
                        Store (Local0, \_SB.PCI0.SR00)
                        Store (0x00, CCAA)
                        Release (MUT0)
                    }

                    Method (_QF8, 0, NotSerialized)
                    {
                        Store (0xF8, DBUG)
                        Acquire (MUT0, 0xFFFF)
                        Store (QSCO, Local1)
                        Store (DVSW, Local2)
                        Release (MUT0)
                        Store (Zero, Local0)
                        Store (\_SB.PCI0.IXVE.IGPU.DSHK (), Local0)
                        If (Local0)
                        {
                            If (LNotEqual (Local1, Zero))
                            {
                                Acquire (MUT0, 0xFFFF)
                                Store (DVSW, \_SB.PCI0.SR00)
                                Release (MUT0)
                            }
                        }

                        If (LNot (Local0))
                        {
                            If (LEqual (Local1, Zero))
                            {
                                Store (One, \_SB.PCI0.IXVE.IGPU.Z01J)
                                Notify (\_SB.PCI0.IXVE.IGPU, 0xCB)
                                While (\_SB.PCI0.IXVE.IGPU.Z01J)
                                {
                                    Sleep (0x0A)
                                }

                                \_SB.PCI0.IXVE.IGPU.DGSM ()
                            }
                            Else
                            {
                                \_SB.PCI0.IXVE.IGPU.DGS2 (Local2)
                                Acquire (MUT0, 0xFFFF)
                                Store (DVSW, \_SB.PCI0.SR00)
                                Release (MUT0)
                            }
                        }

                        Notify (\_SB.PCI0.IXVE.IGPU, 0x80)
                    }

                    Method (_QFA, 0, NotSerialized)
                    {
                        Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                        Store (\_SB.PCI0.LPC0.EC0.QSCO, Local0)
                        Release (\_SB.PCI0.LPC0.EC0.MUT0)
                        If (LEqual (Local0, Zero))
                        {
                            \_SB.PCI0.LPC0.PHS2 (0x80, 0x00)
                        }
                        Else
                        {
                            Notify (\_SB.AMW0, 0xD0)
                        }

                        Store (0xFA, DBUG)
                    }

                    Method (_QA0, 0, NotSerialized)
                    {
                        \_SB.PCI0.LPC0.PHS2 (0x80, 0x02)
                    }

                    Method (_QA2, 0, NotSerialized)
                    {
                        Store (0x0F, \_SB.BRNS)
                        Store (0x07, \_SB.BRND)
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x1C), 
                        SMW0,   16
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x1C), 
                        SMB0,   8
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x1C), 
                        FLD0,   64
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x1C), 
                        FLD1,   128
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x1C), 
                        FLD2,   192
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x1C), 
                        FLD3,   256
                    }

                    Mutex (MUT0, 0x00)
                    Method (SMRD, 4, NotSerialized)
                    {
                        If (LNotEqual (Arg0, 0x07))
                        {
                            If (LNotEqual (Arg0, 0x09))
                            {
                                If (LNotEqual (Arg0, 0x0B))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        If (Not (Acquire (MUT0, 0x1400)))
                        {
                            Store (0x04, Local0)
                            While (LGreater (Local0, 0x01))
                            {
                                And (SMST, 0x40, SMST)
                                Store (Arg2, SMCM)
                                Store (Arg1, SMAD)
                                Store (Arg0, SMPR)
                                Store (0x14, Local3)
                                And (SMST, 0xBF, Local1)
                                While (LAnd (LEqual (Local1, 0x00), LGreater (Local3, 0x00)))
                                {
                                    Sleep (0x01)
                                    And (SMST, 0xBF, Local1)
                                    Decrement (Local3)
                                }

                                If (LEqual (Local1, 0x80))
                                {
                                    Store (0x00, Local0)
                                }
                                Else
                                {
                                    Decrement (Local0)
                                }
                            }

                            If (Local0)
                            {
                                Store (And (Local1, 0x1F), Local0)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x07))
                                {
                                    Store (SMB0, Arg3)
                                }

                                If (LEqual (Arg0, 0x09))
                                {
                                    Store (SMW0, Arg3)
                                }

                                If (LEqual (Arg0, 0x0B))
                                {
                                    Store (SMD0, Arg3)
                                }
                            }

                            Release (MUT0)
                        }

                        Return (Local0)
                    }

                    Method (SMWR, 4, NotSerialized)
                    {
                        If (LNotEqual (Arg0, 0x06))
                        {
                            If (LNotEqual (Arg0, 0x08))
                            {
                                If (LNotEqual (Arg0, 0x0A))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        If (Not (Acquire (MUT0, 0x1400)))
                        {
                            Store (0x04, Local0)
                            While (LGreater (Local0, 0x01))
                            {
                                If (LEqual (Arg0, 0x06))
                                {
                                    Store (Arg3, SMB0)
                                }

                                If (LEqual (Arg0, 0x08))
                                {
                                    Store (Arg3, SMW0)
                                }

                                If (LEqual (Arg0, 0x0A))
                                {
                                    Store (Arg3, SMD0)
                                }

                                And (SMST, 0x40, SMST)
                                Store (Arg2, SMCM)
                                Store (Arg1, SMAD)
                                Store (Arg0, SMPR)
                                Store (0x14, Local3)
                                And (SMST, 0xBF, Local1)
                                While (LAnd (LEqual (Local1, 0x00), LGreater (Local3, 0x00)))
                                {
                                    Sleep (0x01)
                                    And (SMST, 0xBF, Local1)
                                    Decrement (Local3)
                                }

                                If (LEqual (Local1, 0x80))
                                {
                                    Store (0x00, Local0)
                                }
                                Else
                                {
                                    Decrement (Local0)
                                }
                            }

                            If (Local0)
                            {
                                Store (And (Local1, 0x1F), Local0)
                            }

                            Release (MUT0)
                        }

                        Return (Local0)
                    }

                    Device (BAT0)
                    {
                        Name (_HID, EisaId ("PNP0C0A"))
                        Name (_UID, 0x01)
                        Name (IN01, 0x00)
                        Method (_STA, 0, NotSerialized)
                        {
                            If (\ECON)
                            {
                                Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                                Store (\_SB.PCI0.LPC0.EC0.BTIN, Local0)
                                Release (\_SB.PCI0.LPC0.EC0.MUT0)
                                If (LEqual (0x01, Local0))
                                {
                                    Store (0x1F, Local1)
                                }
                                Else
                                {
                                    Store (0x0F, Local1)
                                }
                            }
                            Else
                            {
                                Store (0x0F, Local1)
                            }

                            Return (Local1)
                        }

                        Name (PKG0, Package (0x0D)
                        {
                            0x01, 
                            0x5700, 
                            0x1130, 
                            0x00, 
                            0x2B5C, 
                            0xFA, 
                            0x64, 
                            0x0A, 
                            0x19, 
                            "00112233  ", 
                            "BBBB", 
                            "Lion      ", 
                            "Dell      "
                        })
                        Name (PKG1, Package (0x04)
                        {
                            0x01, 
                            0x00, 
                            0x1130, 
                            0x2B5C
                        })
                        Method (UPBI, 0, NotSerialized)
                        {
                            If (\ECON)
                            {
                                Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                                Store (\_SB.PCI0.LPC0.EC0.MFNM, Local1)
                                While (One)
                                {
                                    Name (_T_0, 0x00)
                                    Store (Local1, _T_0)
                                    If (LEqual (_T_0, 0x00))
                                    {
                                        Store ("Unknow", Index (PKG0, 0x0C))
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x01))
                                        {
                                            Store ("Dell", Index (PKG0, 0x0C))
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x02))
                                            {
                                                Store ("SONY", Index (PKG0, 0x0C))
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_0, 0x03))
                                                {
                                                    Store ("SANYO", Index (PKG0, 0x0C))
                                                }
                                                Else
                                                {
                                                    If (LEqual (_T_0, 0x04))
                                                    {
                                                        Store ("PANASONIC", Index (PKG0, 0x0C))
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (_T_0, 0x05))
                                                        {
                                                            Store ("SONY_OLD", Index (PKG0, 0x0C))
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (_T_0, 0x06))
                                                            {
                                                                Store ("SDI", Index (PKG0, 0x0C))
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (_T_0, 0x07))
                                                                {
                                                                    Store ("SIMPLO", Index (PKG0, 0x0C))
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (_T_0, 0x08))
                                                                    {
                                                                        Store ("MOTOROLA", Index (PKG0, 0x0C))
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (_T_0, 0x09))
                                                                        {
                                                                            Store ("LGC", Index (PKG0, 0x0C))
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    Break
                                }

                                Sleep (0x64)
                                Store (\_SB.PCI0.LPC0.EC0.DLNM, Local1)
                                While (One)
                                {
                                    Name (_T_1, 0x00)
                                    Store (Local1, _T_1)
                                    If (LEqual (_T_1, 0x00))
                                    {
                                        Store ("Unknow", Index (PKG0, 0x09))
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_1, 0xFF))
                                        {
                                            Store ("Dell", Index (PKG0, 0x09))
                                        }
                                    }

                                    Break
                                }

                                Store (\_SB.PCI0.LPC0.EC0.BTCN, Local1)
                                While (One)
                                {
                                    Name (_T_2, 0x00)
                                    Store (Local1, _T_2)
                                    If (LEqual (_T_2, 0x00))
                                    {
                                        Store ("Unknow", Index (PKG0, 0x0B))
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_2, 0x01))
                                        {
                                            Store ("PBAC", Index (PKG0, 0x0B))
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_2, 0x02))
                                            {
                                                Store ("LION", Index (PKG0, 0x0B))
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_2, 0x03))
                                                {
                                                    Store ("NICD", Index (PKG0, 0x0B))
                                                }
                                                Else
                                                {
                                                    If (LEqual (_T_2, 0x04))
                                                    {
                                                        Store ("NIMH", Index (PKG0, 0x0B))
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (_T_2, 0x05))
                                                        {
                                                            Store ("NIZN", Index (PKG0, 0x0B))
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (_T_2, 0x06))
                                                            {
                                                                Store ("RAM", Index (PKG0, 0x0B))
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (_T_2, 0x07))
                                                                {
                                                                    Store ("ZNAR", Index (PKG0, 0x0B))
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (_T_2, 0x08))
                                                                    {
                                                                        Store ("LIP", Index (PKG0, 0x0B))
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    Break
                                }

                                Sleep (0x64)
                                Store (\_SB.PCI0.LPC0.EC0.BID1, Local1)
                                Store (\_SB.PCI0.LPC0.EC0.BID2, Local2)
                                ShiftLeft (Local1, 0x08, Local1)
                                Or (Local1, Local2, Local1)
                                Store (ITOS (ToBCD (Local1)), Index (PKG0, 0x0A))
                                If (LEqual (\_SB.PCI0.LPC0.EC0.BTIN, 0x01))
                                {
                                    Store (\_SB.PCI0.LPC0.EC0.BTDC, Index (PKG0, 0x01))
                                    Store (\_SB.PCI0.LPC0.EC0.BTFC, Index (PKG0, 0x02))
                                }

                                Release (\_SB.PCI0.LPC0.EC0.MUT0)
                            }
                        }

                        Method (ITOS, 1, NotSerialized)
                        {
                            Store (Buffer (0x09)
                                {
                                    /* 0000 */    0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                    /* 0008 */    0x00
                                }, Local0)
                            Store (Buffer (0x11)
                                {
                                    "0123456789ABCDEF"
                                }, Local7)
                            Store (0x08, Local1)
                            Store (0x00, Local2)
                            Store (0x00, Local3)
                            While (Local1)
                            {
                                Decrement (Local1)
                                And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
                                If (Local4)
                                {
                                    Store (Ones, Local3)
                                }

                                If (Local3)
                                {
                                    GBFE (Local7, Local4, RefOf (Local5))
                                    PBFE (Local0, Local2, Local5)
                                    Increment (Local2)
                                }
                            }

                            Return (Local0)
                        }

                        Method (GBFE, 3, NotSerialized)
                        {
                            CreateByteField (Arg0, Arg1, TIDX)
                            Store (TIDX, Arg2)
                        }

                        Method (PBFE, 3, NotSerialized)
                        {
                            CreateByteField (Arg0, Arg1, TIDX)
                            Store (Arg2, TIDX)
                        }

                        Method (UPBS, 0, NotSerialized)
                        {
                            If (\ECON)
                            {
                                Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                                If (LEqual (\_SB.PCI0.LPC0.EC0.BTIN, 0x01))
                                {
                                    Store (\_SB.PCI0.LPC0.EC0.BTCT, Local0)
                                    If (LEqual (Local0, 0x00))
                                    {
                                        Increment (Local0)
                                    }
                                    Else
                                    {
                                        If (\_SB.PCI0.LPC0.EC0.ACIN)
                                        {
                                            If (And (Local0, 0x8000))
                                            {
                                                Store (Ones, Local0)
                                            }
                                        }
                                        Else
                                        {
                                            If (And (Local0, 0x8000))
                                            {
                                                Subtract (0x00, Local0, Local0)
                                                And (Local0, 0xFFFF, Local0)
                                            }
                                            Else
                                            {
                                                Store (Ones, Local0)
                                            }
                                        }
                                    }

                                    Store (Local0, Index (PKG1, 0x01))
                                    Store (\_SB.PCI0.LPC0.EC0.BTRC, Index (PKG1, 0x02))
                                    Store (\_SB.PCI0.LPC0.EC0.BTPV, Index (PKG1, 0x03))
                                    If (\_SB.PCI0.LPC0.EC0.ACIN)
                                    {
                                        If (LEqual (\_SB.PCI0.LPC0.EC0.BTFU, 0x01))
                                        {
                                            Store (0x00, Local0)
                                            Store (\_SB.PCI0.LPC0.EC0.BTFC, Index (PKG1, 0x02))
                                        }
                                        Else
                                        {
                                            If (LEqual (\_SB.PCI0.LPC0.EC0.BTIC, 0x01))
                                            {
                                                Store (0x02, Local0)
                                            }
                                            Else
                                            {
                                                Store (0x00, Local0)
                                            }
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (\_SB.PCI0.LPC0.EC0.BTIC, 0x01))
                                        {
                                            Store (0x00, Local0)
                                        }
                                        Else
                                        {
                                            Store (0x01, Local0)
                                        }
                                    }

                                    Store (Local0, Index (PKG1, 0x00))
                                }

                                Release (\_SB.PCI0.LPC0.EC0.MUT0)
                            }

                            If (BTCE)
                            {
                                Store (0x00, Index (PKG1, 0x00))
                            }
                        }

                        Method (_BIF, 0, NotSerialized)
                        {
                            UPBI ()
                            Return (PKG0)
                        }

                        Method (_BST, 0, NotSerialized)
                        {
                            UPBS ()
                            Return (PKG1)
                        }

                        Name (_PCL, Package (0x01)
                        {
                            \_SB
                        })
                    }

                    Device (ADP0)
                    {
                        Name (_HID, "ACPI0003")
                        Name (IN00, 0x00)
                        Method (_PSR, 0, NotSerialized)
                        {
                            If (BTCE)
                            {
                                Store (0x01, Local0)
                            }
                            Else
                            {
                                If (\ECON)
                                {
                                    Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                                    Store (\_SB.PCI0.LPC0.EC0.ACIN, Local0)
                                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                                }
                                Else
                                {
                                    Store (0x01, Local0)
                                }
                            }

                            Return (Local0)
                        }

                        Name (_PCL, Package (0x01)
                        {
                            \_SB
                        })
                        Method (_STA, 0, NotSerialized)
                        {
                            Return (0x0F)
                        }
                    }
                }
            }
        }

        Scope (\)
        {
            Name (PICF, 0x00)
            Method (_PIC, 1, NotSerialized)
            {
                Store (Arg0, PICF)
            }

            OperationRegion (\_SB.PCI0.IMAP.PIRQ, PCI_Config, 0x60, 0x3C)
            Field (\_SB.PCI0.IMAP.PIRQ, AnyAcc, NoLock, Preserve)
            {
                PSI0,   8, 
                PSI1,   8, 
                IR01,   8, 
                IR02,   8, 
                IMAC,   8, 
                IMA1,   8, 
                IR03,   8, 
                IR04,   8, 
                IUS0,   8, 
                IUS2,   8, 
                Z01T,   8, 
                Z01U,   8, 
                ISCI,   8, 
                ITCO,   8, 
                ISMB,   8, 
                INTS,   8, 
                IAZA,   8, 
                Z01V,   8, 
                IPID,   8, 
                INTU,   8, 
                INTW,   8, 
                INTX,   8, 
                INTY,   8, 
                INTZ,   8, 
                DLIA,   8, 
                DLIB,   8, 
                DLIC,   8, 
                DLID,   8, 
                Z01W,   8, 
                Z01X,   8, 
                Z01Y,   8, 
                Z01Z,   8, 
                Z020,   8, 
                Z021,   8, 
                Z022,   8, 
                Z023,   8, 
                Z024,   8, 
                Z025,   8, 
                Z026,   8, 
                Z027,   8, 
                Z028,   8, 
                Z029,   8, 
                Z02A,   8, 
                Z02B,   8, 
                Z02C,   8, 
                Z02D,   8, 
                Z02E,   8, 
                Z02F,   8, 
                Z02G,   8, 
                Z02H,   8, 
                Z02I,   8, 
                Z02J,   8, 
                Z02K,   8, 
                Z02L,   8, 
                Z02M,   8, 
                Z02N,   8, 
                Z02O,   8, 
                Z02P,   8, 
                Z02Q,   8, 
                Z02R,   8
            }
        }

        Scope (\_SB.PCI0)
        {
            Name (BUFA, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, )
                    {7,10,11,14,15}
            })
            Name (Z02S, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, )
                    {5}
            })
            Name (BUFB, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, _Y0A)
                    {}
            })
            CreateWordField (BUFB, \_SB.PCI0._Y0A._INT, IRQV)
            Method (CRS, 1, Serialized)
            {
                If (Arg0)
                {
                    ShiftLeft (0x01, Arg0, IRQV)
                }
                Else
                {
                    Store (Zero, IRQV)
                }

                Return (BUFB)
            }

            Method (SRS, 1, Serialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Decrement (Local0)
                Return (Local0)
            }

            Name (BUFI, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000012,
                    0x00000013,
                    0x00000014,
                    0x00000015,
                    0x00000016,
                    0x00000017,
                }
            })
            Name (Z02T, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000011,
                }
            })
            Name (BUFF, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000005,
                    0x00000007,
                    0x0000000A,
                    0x0000000B,
                    0x0000000E,
                    0x0000000F,
                }
            })
            Method (CRSI, 1, Serialized)
            {
                Name (IRZ5, ResourceTemplate ()
                {
                    Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, _Y0B)
                    {
                        0x00000007,
                    }
                })
                CreateWordField (IRZ5, \_SB.PCI0.CRSI._Y0B._INT, INZ5)
                Store (Arg0, Local0)
                If (LEqual (Arg0, 0x03))
                {
                    Store (0x10, Local0)
                }

                If (LEqual (Arg0, 0x04))
                {
                    Store (0x11, Local0)
                }

                If (LEqual (Arg0, 0x06))
                {
                    Store (0x12, Local0)
                }

                If (LEqual (Arg0, 0x0C))
                {
                    Store (0x13, Local0)
                }

                If (LEqual (Arg0, 0x08))
                {
                    Store (0x14, Local0)
                }

                If (LEqual (Arg0, 0x0D))
                {
                    Store (0x15, Local0)
                }

                If (LEqual (Arg0, 0x02))
                {
                    Store (0x16, Local0)
                }

                If (LEqual (Arg0, 0x01))
                {
                    Store (0x17, Local0)
                }

                Store (Local0, INZ5)
                Return (IRZ5)
            }

            Method (SRSI, 1, Serialized)
            {
                CreateWordField (Arg0, 0x05, IRZ6)
                Store (IRZ6, Local0)
                If (LEqual (IRZ6, 0x10))
                {
                    Store (0x03, Local0)
                }

                If (LEqual (IRZ6, 0x11))
                {
                    Store (0x04, Local0)
                }

                If (LEqual (IRZ6, 0x12))
                {
                    Store (0x06, Local0)
                }

                If (LEqual (IRZ6, 0x13))
                {
                    Store (0x0C, Local0)
                }

                If (LEqual (IRZ6, 0x14))
                {
                    Store (0x08, Local0)
                }

                If (LEqual (IRZ6, 0x15))
                {
                    Store (0x0D, Local0)
                }

                If (LEqual (IRZ6, 0x16))
                {
                    Store (0x02, Local0)
                }

                If (LEqual (IRZ6, 0x17))
                {
                    Store (0x01, Local0)
                }

                Return (Local0)
            }

            Device (LNK1)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTW)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTW)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFF)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (INTW))
                    }
                    Else
                    {
                        Return (CRSI (INTW))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), INTW)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), INTW)
                    }
                }
            }

            Device (LNK2)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x02)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTX)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTX)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFF)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (INTX))
                    }
                    Else
                    {
                        Return (CRSI (INTX))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), INTX)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), INTX)
                    }
                }
            }

            Device (LNK3)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x03)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTY)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTY)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFF)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (INTY))
                    }
                    Else
                    {
                        Return (CRSI (INTY))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), INTY)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), INTY)
                    }
                }
            }

            Device (LNK4)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x04)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTZ)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTZ)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFF)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (INTZ))
                    }
                    Else
                    {
                        Return (CRSI (INTZ))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), INTZ)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), INTZ)
                    }
                }
            }

            Device (Z00Q)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x05)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z01W)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z01W)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z01W))
                    }
                    Else
                    {
                        Return (CRSI (Z01W))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z01W)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z01W)
                    }
                }
            }

            Device (Z00R)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x06)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z01X)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z01X)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z01X))
                    }
                    Else
                    {
                        Return (CRSI (Z01X))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z01X)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z01X)
                    }
                }
            }

            Device (Z00S)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x07)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z01Y)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z01Y)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z01Y))
                    }
                    Else
                    {
                        Return (CRSI (Z01Y))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z01Y)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z01Y)
                    }
                }
            }

            Device (Z00T)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x08)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z01Z)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z01Z)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z01Z))
                    }
                    Else
                    {
                        Return (CRSI (Z01Z))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z01Z)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z01Z)
                    }
                }
            }

            Device (Z00U)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x09)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z020)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z020)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z020))
                    }
                    Else
                    {
                        Return (CRSI (Z020))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z020)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z020)
                    }
                }
            }

            Device (Z00V)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0A)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z021)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z021)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z021))
                    }
                    Else
                    {
                        Return (CRSI (Z021))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z021)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z021)
                    }
                }
            }

            Device (Z00W)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0B)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z022)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z022)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z022))
                    }
                    Else
                    {
                        Return (CRSI (Z022))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z022)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z022)
                    }
                }
            }

            Device (Z00X)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0C)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z023)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z023)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z023))
                    }
                    Else
                    {
                        Return (CRSI (Z023))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z023)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z023)
                    }
                }
            }

            Device (Z00Y)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0D)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z024)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z024)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z024))
                    }
                    Else
                    {
                        Return (CRSI (Z024))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z024)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z024)
                    }
                }
            }

            Device (Z00Z)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0E)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z025)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z025)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z025))
                    }
                    Else
                    {
                        Return (CRSI (Z025))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z025)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z025)
                    }
                }
            }

            Device (Z010)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0F)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z026)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z026)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z026))
                    }
                    Else
                    {
                        Return (CRSI (Z026))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z026)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z026)
                    }
                }
            }

            Device (Z011)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x10)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z027)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z027)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z027))
                    }
                    Else
                    {
                        Return (CRSI (Z027))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z027)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z027)
                    }
                }
            }

            Device (Z012)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x11)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z028)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z028)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z028))
                    }
                    Else
                    {
                        Return (CRSI (Z028))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z028)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z028)
                    }
                }
            }

            Device (Z013)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x12)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z029)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z029)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z029))
                    }
                    Else
                    {
                        Return (CRSI (Z029))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z029)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z029)
                    }
                }
            }

            Device (Z014)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x13)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02A)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02A)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02A))
                    }
                    Else
                    {
                        Return (CRSI (Z02A))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02A)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02A)
                    }
                }
            }

            Device (Z015)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x14)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02B)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02B)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02B))
                    }
                    Else
                    {
                        Return (CRSI (Z02B))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02B)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02B)
                    }
                }
            }

            Device (Z016)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x15)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02C)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02C)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02C))
                    }
                    Else
                    {
                        Return (CRSI (Z02C))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02C)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02C)
                    }
                }
            }

            Device (Z017)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x16)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02D)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02D)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02D))
                    }
                    Else
                    {
                        Return (CRSI (Z02D))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02D)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02D)
                    }
                }
            }

            Device (Z018)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x17)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02E)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02E)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02E))
                    }
                    Else
                    {
                        Return (CRSI (Z02E))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02E)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02E)
                    }
                }
            }

            Device (Z019)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x18)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02F)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02F)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02F))
                    }
                    Else
                    {
                        Return (CRSI (Z02F))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02F)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02F)
                    }
                }
            }

            Device (Z01A)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x19)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02G)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02G)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02G))
                    }
                    Else
                    {
                        Return (CRSI (Z02G))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02G)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02G)
                    }
                }
            }

            Device (Z01B)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1A)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02H)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02H)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02H))
                    }
                    Else
                    {
                        Return (CRSI (Z02H))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02H)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02H)
                    }
                }
            }

            Device (Z01C)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1B)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02I)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02I)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02I))
                    }
                    Else
                    {
                        Return (CRSI (Z02I))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02I)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02I)
                    }
                }
            }

            Device (Z01D)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1C)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02J)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02J)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02J))
                    }
                    Else
                    {
                        Return (CRSI (Z02J))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02J)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02J)
                    }
                }
            }

            Device (Z01E)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1D)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02K)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02K)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02K))
                    }
                    Else
                    {
                        Return (CRSI (Z02K))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02K)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02K)
                    }
                }
            }

            Device (Z01F)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1E)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02L)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02L)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02L))
                    }
                    Else
                    {
                        Return (CRSI (Z02L))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02L)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02L)
                    }
                }
            }

            Device (Z01G)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1F)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02M)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02M)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02M))
                    }
                    Else
                    {
                        Return (CRSI (Z02M))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02M)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02M)
                    }
                }
            }

            Device (Z01H)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x20)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z02N)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z02N)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z02N))
                    }
                    Else
                    {
                        Return (CRSI (Z02N))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z02N)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z02N)
                    }
                }
            }

            Device (LSMB)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x25)
                Method (_STA, 0, NotSerialized)
                {
                    If (ISMB)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, ISMB)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (ISMB))
                    }
                    Else
                    {
                        Return (CRSI (ISMB))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), ISMB)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), ISMB)
                    }
                }
            }

            Device (LUS0)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x26)
                Method (_STA, 0, NotSerialized)
                {
                    If (IUS0)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, IUS0)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (IUS0))
                    }
                    Else
                    {
                        Return (CRSI (IUS0))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), IUS0)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), IUS0)
                    }
                }
            }

            Device (LUS2)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x27)
                Method (_STA, 0, NotSerialized)
                {
                    If (IUS2)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, IUS2)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (IUS2))
                    }
                    Else
                    {
                        Return (CRSI (IUS2))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), IUS2)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), IUS2)
                    }
                }
            }

            Device (LMAC)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x28)
                Method (_STA, 0, NotSerialized)
                {
                    If (IMAC)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, IMAC)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (IMAC))
                    }
                    Else
                    {
                        Return (CRSI (IMAC))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), IMAC)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), IMAC)
                    }
                }
            }

            Device (LAZA)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x29)
                Method (_STA, 0, NotSerialized)
                {
                    If (IAZA)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, IAZA)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (Z02S)
                    }
                    Else
                    {
                        Return (Z02T)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (IAZA))
                    }
                    Else
                    {
                        Return (CRSI (IAZA))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), IAZA)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), IAZA)
                    }
                }
            }

            Device (LGPU)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x2A)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z01V)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z01V)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z01V))
                    }
                    Else
                    {
                        Return (CRSI (Z01V))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z01V)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z01V)
                    }
                }
            }

            Device (LPID)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x2B)
                Method (_STA, 0, NotSerialized)
                {
                    If (IPID)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, IPID)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (IPID))
                    }
                    Else
                    {
                        Return (CRSI (IPID))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), IPID)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), IPID)
                    }
                }
            }

            Device (LSI0)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x2C)
                Method (_STA, 0, NotSerialized)
                {
                    If (PSI0)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PSI0)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (PSI0))
                    }
                    Else
                    {
                        Return (CRSI (PSI0))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), PSI0)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), PSI0)
                    }
                }
            }

            Device (LSI1)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x2D)
                Method (_STA, 0, NotSerialized)
                {
                    If (PSI1)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PSI1)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (PSI1))
                    }
                    Else
                    {
                        Return (CRSI (PSI1))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), PSI1)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), PSI1)
                    }
                }
            }

            Device (Z00O)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x2E)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z01T)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z01T)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z01T))
                    }
                    Else
                    {
                        Return (CRSI (Z01T))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z01T)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z01T)
                    }
                }
            }

            Device (Z00P)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x2F)
                Method (_STA, 0, NotSerialized)
                {
                    If (Z01U)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, Z01U)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (Z01U))
                    }
                    Else
                    {
                        Return (CRSI (Z01U))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), Z01U)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), Z01U)
                    }
                }
            }

            Device (LPMU)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x30)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTS)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTS)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (BUFA)
                    }
                    Else
                    {
                        Return (BUFI)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (CRS (INTS))
                    }
                    Else
                    {
                        Return (CRSI (INTS))
                    }
                }

                Method (_SRS, 1, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Store (SRS (Arg0), INTS)
                    }
                    Else
                    {
                        Store (SRSI (Arg0), INTS)
                    }
                }
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                If (\ECON)
                {
                    Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                    If (\_SB.PCI0.LPC0.EC0.LIDS)
                    {
                        Store (0x00, Local0)
                    }
                    Else
                    {
                        Store (0x01, Local0)
                    }

                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                }
                Else
                {
                    Store (0x01, Local0)
                }

                Return (Local0)
            }
        }
    }

    Scope (\_TZ)
    {
        ThermalZone (THRM)
        {
            Method (_TMP, 0, NotSerialized)
            {
                If (\ECON)
                {
                    Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                    Store (\_SB.PCI0.LPC0.EC0.TCPU, Local0)
                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                    Return (Add (Multiply (Local0, 0x0A), 0x0AAC))
                }
                Else
                {
                    Return (0x0C3C)
                }
            }

            Method (_PSV, 0, NotSerialized)
            {
                Return (Add (Multiply (0x5D, 0x0A), 0x0AAC))
            }

            Name (_PSL, Package (0x02)
            {
                \_PR.CPU0, 
                \_PR.CPU1
            })
            Name (_TSP, 0x28)
            Name (_TC1, 0x02)
            Name (_TC2, 0x03)
            Method (_CRT, 0, NotSerialized)
            {
                Return (Add (Multiply (0x69, 0x0A), 0x0AAC))
            }
        }
    }

    OperationRegion (DBGP, SystemIO, 0x80, 0x01)
    Field (DBGP, ByteAcc, NoLock, Preserve)
    {
        DBUG,   8
    }

    Name (FWSO, "FWSO")
}