fixed dsdt

dsdt.dsl (text/plain), 314.72 KB, created by Miguel Angel Requena Serrano on 2007-05-14 12:51:18 UTC

/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20060912
 *
 * Disassembly of dsdt.dat, Sat May 12 21:08:10 2007
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00008A9C (35484)
 *     Revision         0x01
 *     OEM ID           "TOSQCI"
 *     OEM Table ID     "Denver"
 *     OEM Revision     0x06040000 (100925440)
 *     Creator ID       "MSFT"
 *     Creator Revision 0x03000001 (50331649)
 */
DefinitionBlock ("dsdt.aml", "DSDT", 1, "TOSQCI", "Denver", 0x06040000)
{
    External (Z002)
    External (PDC1)
    External (PDC0)
    External (Z000)
    External (CFGD)
    External (\_PR_.CPU0._PPC)

    OperationRegion (PORT, SystemIO, 0x0378, 0x01)
    Field (PORT, ByteAcc, NoLock, Preserve)
    {
        P80H,   8
    }

    OperationRegion (IO_T, SystemIO, 0x0800, 0x10)
    Field (IO_T, ByteAcc, NoLock, Preserve)
    {
                Offset (0x08), 
        TRP0,   8
    }

    OperationRegion (PMIO, SystemIO, 0x1000, 0x80)
    Field (PMIO, ByteAcc, NoLock, Preserve)
    {
                Offset (0x10), 
            ,   1, 
        TDTY,   3, 
        THTE,   1, 
                Offset (0x28), 
            ,   1, 
        HOTS,   1, 
                Offset (0x2A), 
            ,   6, 
        CRTS,   1, 
                Offset (0x2B), 
            ,   6, 
        LIDS,   1, 
        DOCS,   1, 
                Offset (0x42), 
            ,   1, 
        GPEC,   1
    }

    OperationRegion (GPIO, SystemIO, 0x1180, 0x3C)
    Field (GPIO, ByteAcc, NoLock, Preserve)
    {
        GU00,   8, 
        GU01,   8, 
        GU02,   8, 
        GU03,   8, 
        GIO0,   8, 
        GIO1,   8, 
        GIO2,   8, 
        GIO3,   8, 
                Offset (0x0C), 
        GL00,   8, 
            ,   4, 
        GP12,   1, 
                Offset (0x0E), 
        GL02,   8, 
        GL03,   8, 
                Offset (0x18), 
        GB00,   8, 
        GB01,   8, 
        GB02,   8, 
        GB03,   8, 
                Offset (0x2C), 
        GIV0,   8, 
            ,   6, 
        LIDP,   1, 
        DOCP,   1, 
        GIV2,   8, 
        GIV3,   8, 
        GU04,   8, 
        GU05,   8, 
        GU06,   8, 
        GU07,   8, 
        GIO4,   8, 
        GIO5,   8, 
        GIO6,   8, 
        GIO7,   8, 
            ,   2, 
        BAYR,   1, 
        BID1,   1, 
            ,   1, 
        BAYO,   1, 
        BID0,   1, 
                Offset (0x39), 
        GL05,   8, 
        GL06,   8, 
        GL07,   8
    }

    OperationRegion (GNVS, SystemMemory, 0x3FE9CB2C, 0x0100)
    Field (GNVS, AnyAcc, Lock, Preserve)
    {
        OSYS,   16, 
        SMIF,   8, 
        PRM0,   8, 
        PRM1,   8, 
        SCIF,   8, 
        PRM2,   8, 
        PRM3,   8, 
                Offset (0x09), 
                Offset (0x0A), 
                Offset (0x0B), 
        P80D,   32, 
        PWRS,   8, 
                Offset (0x11), 
                Offset (0x12), 
                Offset (0x13), 
                Offset (0x14), 
                Offset (0x1A), 
        DTSE,   8, 
        DTS1,   8, 
        DTS2,   8, 
        DTSP,   8, 
                Offset (0x28), 
        APIC,   8, 
        MPEN,   8, 
        PPCS,   8, 
        PPCM,   8, 
        PCP0,   8, 
        PCP1,   8, 
                Offset (0x32), 
                Offset (0x37), 
        MODL,   8, 
        CIRP,   8, 
        KSTS,   8, 
        PNLT,   16, 
        IGDS,   8, 
        TLST,   8, 
        CADL,   8, 
        PADL,   8, 
        CSTE,   16, 
        NSTE,   16, 
        SSTE,   16, 
        NDID,   8, 
        DID1,   32, 
        DID2,   32, 
        DID3,   32, 
        DID4,   32, 
        DID5,   32, 
                Offset (0x67), 
                Offset (0x68), 
        BRTL,   8, 
                Offset (0x6E), 
                Offset (0x74), 
        MEFE,   8, 
                Offset (0x78), 
        TPMP,   8, 
        TPME,   8, 
                Offset (0x82), 
        GTF0,   56, 
        GTF2,   56, 
        IDEM,   8
    }

    OperationRegion (RCRB, SystemMemory, 0xFED1C000, 0x4000)
    Field (RCRB, DWordAcc, Lock, Preserve)
    {
                Offset (0x1000), 
                Offset (0x3000), 
                Offset (0x3404), 
        HPAS,   2, 
            ,   5, 
        HPAE,   1, 
                Offset (0x3418), 
            ,   1, 
        PATD,   1, 
        SATD,   1, 
        SMBD,   1, 
        HDAD,   1, 
        A97D,   1, 
                Offset (0x341A), 
        RP1D,   1, 
        RP2D,   1, 
        RP3D,   1, 
        RP4D,   1, 
        RP5D,   1, 
        RP6D,   1
    }

    Mutex (MUTX, 0x00)
    Name (_S0, Package (0x03)
    {
        0x00, 
        0x00, 
        0x00
    })
    Name (_S3, Package (0x03)
    {
        0x05, 
        0x05, 
        0x00
    })
    Name (_S4, Package (0x03)
    {
        0x06, 
        0x06, 
        0x00
    })
    Name (_S5, Package (0x03)
    {
        0x07, 
        0x07, 
        0x00
    })
    Scope (\_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
        Processor (CPU1, 0x01, 0x00001010, 0x06)
        {
            Method (_INI, 0, NotSerialized)
            {
                If (DTSE)
                {
                    TRAP (0x46)
                }
            }
        }
    }

    Name (\DSEN, 0x01)
    Name (\ECON, 0x00)
    Name (\GPIC, 0x00)
    Name (\CTYP, 0x00)
    Name (\L01C, 0x00)
    Name (\VFN0, 0x00)
    Name (\VFN1, 0x00)
    Name (\INSX, 0x00)
    Name (\PPMF, 0x80000000)
    Method (\_PIC, 1, NotSerialized)
    {
        Store (Arg0, GPIC)
    }

    Method (_PTS, 1, NotSerialized)
    {
        Store (0x00, P80D)
        P8XH (0x00, Arg0)
        If (LEqual (Arg0, 0x04))
        {
            Store (0x01, INS4)
            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
            Store (0x01, \_SB.PCI0.LPCB.EC0.PFLG)
            Store (0x01, \_SB.PCI0.LPCB.EC0.FLS4)
            Release (\_SB.PCI0.LPCB.EC0.MUT1)
        }

        If (\_SB.ECOK)
        {
            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
            If (LEqual (\_SB.PCI0.PCIB.LANC.LANP, 0x00))
            {
                Store (0x00, \_SB.PCI0.LPCB.EC0.VAUX)
            }
            Else
            {
                Store (0x01, \_SB.PCI0.LPCB.EC0.VAUX)
            }

            \_SB.PHSR (0x08, \_SB.PCI0.LPCB.EC0.TPAD)
            Release (\_SB.PCI0.LPCB.EC0.MUT1)
        }

        If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x03)))
        {
            If (\_SB.ECOK)
            {
                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                Store (\_SB.PCI0.LPCB.EC0.KSWH, KSTS)
                Release (\_SB.PCI0.LPCB.EC0.MUT1)
            }
        }

        P8XH (0x00, 0xEF)
    }

    Method (_WAK, 1, NotSerialized)
    {
        P8XH (0x00, 0xAB)
        If (LEqual (Arg0, 0x03))
        {
            TRAP (0x46)
        }

        If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04)))
        {
            If (And (CFGD, 0x01000000))
            {
                If (LAnd (And (CFGD, 0xF0), LEqual (OSYS, 0x07D1)))
                {
                    TRAP (0x3D)
                }
            }
        }

        If (LEqual (RP1D, 0x00))
        {
            Notify (\_SB.PCI0.RP01, 0x00)
        }

        If (LEqual (RP2D, 0x00))
        {
            Notify (\_SB.PCI0.RP02, 0x00)
        }

        If (LEqual (RP3D, 0x00))
        {
            Notify (\_SB.PCI0.RP03, 0x00)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0x00, INS4)
            If (DTSE)
            {
                TRAP (0x47)
            }

            Notify (\_SB.PWRB, 0x02)
        }

        If (LEqual (OSYS, 0x07D2))
        {
            If (And (CFGD, 0x01))
            {
                If (LGreater (\_PR.CPU0._PPC, 0x00))
                {
                    Subtract (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)
                    PNOT ()
                    Add (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)
                    PNOT ()
                }
                Else
                {
                    Add (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)
                    PNOT ()
                    Subtract (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)
                    PNOT ()
                }
            }
        }

        If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x03)))
        {
            If (\_SB.ECOK)
            {
                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                If (\_SB.BTEN)
                {
                    If (LNotEqual (\_SB.PCI0.LPCB.EC0.KSWH, KSTS))
                    {
                        If (LNot (\_SB.PCI0.LPCB.EC0.KSWH))
                        {
                            Store (\_SB.BTEN, \_SB.PCI0.LPCB.EC0.BLTH)
                            \_SB.PHSR (Z000, 0x00)
                        }
                    }
                }

                Store (\_SB.PCI0.LPCB.EC0.ACDF, \PWRS)
                Release (\_SB.PCI0.LPCB.EC0.MUT1)
            }

            \_SB.BAT1.BSTA ()
            If (\_SB.BAT1.BTIN)
            {
                \_SB.BAT1.UBIF ()
                Notify (\_SB.BAT1, 0x81)
            }
        }

        If (LEqual (OSYS, 0x07D6))
        {
            If (\_SB.ECOK)
            {
                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                And (\_SB.PCI0.LPCB.EC0.MBTB, 0x03, Local1)
                Release (\_SB.PCI0.LPCB.EC0.MUT1)
                If (Local1)
                {
                    If (LEqual (Arg0, 0x04))
                    {
                        \_SB.PHSR (0x0F, 0x05)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        If (LEqual (Local1, 0x01))
                        {
                            Notify (\_SB.PCI0.LPCB.EC0.DAL1, 0x02)
                        }

                        If (LEqual (Local1, 0x02))
                        {
                            Notify (\_SB.PCI0.LPCB.EC0.DAL2, 0x02)
                        }
                    }
                }
            }
        }

        P8XH (0x00, 0xCD)
        Return (Package (0x02)
        {
            0x00, 
            0x00
        })
    }

    Scope (\_GPE)
    {
        Method (_L01, 0, NotSerialized)
        {
            Add (L01C, 0x01, L01C)
            P8XH (0x00, 0x01)
            P8XH (0x01, L01C)
            Sleep (0x64)
            If (LAnd (LEqual (RP1D, 0x00), \_SB.PCI0.RP01.HPCS))
            {
                If (\_SB.PCI0.RP01.PDC1)
                {
                    Store (0x01, \_SB.PCI0.RP01.PDC1)
                    Store (0x01, \_SB.PCI0.RP01.HPCS)
                    Notify (\_SB.PCI0.RP01, 0x00)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.RP01.HPCS)
                }
            }

            If (LAnd (LEqual (RP2D, 0x00), \_SB.PCI0.RP02.HPCS))
            {
                If (\_SB.PCI0.RP02.PDC2)
                {
                    Store (0x01, \_SB.PCI0.RP02.PDC2)
                    Store (0x01, \_SB.PCI0.RP02.HPCS)
                    Notify (\_SB.PCI0.RP02, 0x00)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.RP02.HPCS)
                }
            }

            If (LAnd (LEqual (RP3D, 0x00), \_SB.PCI0.RP03.HPCS))
            {
                If (\_SB.PCI0.RP03.PDC3)
                {
                    Store (0x01, \_SB.PCI0.RP03.PDC3)
                    Store (0x01, \_SB.PCI0.RP03.HPCS)
                    Notify (\_SB.PCI0.RP03, 0x00)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.RP03.HPCS)
                }
            }

            If (LAnd (LEqual (RP4D, 0x00), \_SB.PCI0.RP04.HPCS))
            {
                If (\_SB.PCI0.RP04.PDC4)
                {
                    Store (0x01, \_SB.PCI0.RP04.PDC4)
                    Store (0x01, \_SB.PCI0.RP04.HPCS)
                    Notify (\_SB.PCI0.RP04, 0x00)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.RP04.HPCS)
                }
            }

            If (LAnd (LEqual (RP5D, 0x00), \_SB.PCI0.RP05.HPCS))
            {
                If (\_SB.PCI0.RP05.PDC5)
                {
                    Store (0x01, \_SB.PCI0.RP05.PDC5)
                    Store (0x01, \_SB.PCI0.RP05.HPCS)
                    Notify (\_SB.PCI0.RP05, 0x00)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.RP05.HPCS)
                }
            }

            If (LAnd (LEqual (RP6D, 0x00), \_SB.PCI0.RP06.HPCS))
            {
                If (\_SB.PCI0.RP06.PDC6)
                {
                    Store (0x01, \_SB.PCI0.RP06.PDC6)
                    Store (0x01, \_SB.PCI0.RP06.HPCS)
                    Notify (\_SB.PCI0.RP06, 0x00)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.RP06.HPCS)
                }
            }
        }

        Method (_L02, 0, NotSerialized)
        {
            Store (Zero, GPEC)
            If (\_SB.ECOK)
            {
                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                Store (DTSP, \_SB.PCI0.LPCB.EC0.DESP)
                Release (\_SB.PCI0.LPCB.EC0.MUT1)
            }
        }

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

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

        Method (_L05, 0, NotSerialized)
        {
            If (HDAD) {}
            Else
            {
                Notify (\_SB.PCI0.HDEF, 0x02)
            }
        }

        Method (_L07, 0, NotSerialized)
        {
            Store (0x20, \_SB.PCI0.SBUS.HSTS)
        }

        Method (_L09, 0, NotSerialized)
        {
            If (\_SB.PCI0.RP01.PSP1)
            {
                Store (0x01, \_SB.PCI0.RP01.PSP1)
                Store (0x01, \_SB.PCI0.RP01.PMCS)
                Notify (\_SB.PCI0.RP01, 0x02)
            }

            If (\_SB.PCI0.RP02.PSP2)
            {
                Store (0x01, \_SB.PCI0.RP02.PSP2)
                Store (0x01, \_SB.PCI0.RP02.PMCS)
                Notify (\_SB.PCI0.RP02, 0x02)
            }

            If (\_SB.PCI0.RP03.PSP3)
            {
                Store (0x01, \_SB.PCI0.RP03.PSP3)
                Store (0x01, \_SB.PCI0.RP03.PMCS)
                Notify (\_SB.PCI0.RP03, 0x02)
            }
        }

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

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

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

        Method (_L0E, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB4, 0x02)
        }
    }

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

    Method (HKDS, 1, Serialized)
    {
        If (LEqual (0x00, DSEN))
        {
            If (LEqual (TRAP (Arg0), 0x00))
            {
                If (LNotEqual (CADL, PADL))
                {
                    Store (CADL, PADL)
                    If (LOr (LGreater (OSYS, 0x07D0), LLess (OSYS, 0x07D6)))
                    {
                        Notify (\_SB.PCI0, 0x00)
                    }
                    Else
                    {
                        Notify (\_SB.PCI0.GFX0, 0x00)
                    }

                    Sleep (0x02EE)
                }

                Notify (\_SB.PCI0.GFX0, 0x80)
            }
        }

        If (LEqual (0x01, DSEN))
        {
            If (LEqual (TRAP (Increment (Arg0)), 0x00))
            {
                Notify (\_SB.PCI0.GFX0, 0x81)
            }
        }
    }

    Method (P8XH, 2, Serialized)
    {
        If (LEqual (Arg0, 0x00))
        {
            Store (Or (And (P80D, 0xFFFFFF00), Arg1), P80D)
        }

        If (LEqual (Arg0, 0x01))
        {
            Store (Or (And (P80D, 0xFFFF00FF), ShiftLeft (Arg1, 0x08)
                ), P80D)
        }

        If (LEqual (Arg0, 0x02))
        {
            Store (Or (And (P80D, 0xFF00FFFF), ShiftLeft (Arg1, 0x10)
                ), P80D)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (Or (And (P80D, 0x00FFFFFF), ShiftLeft (Arg1, 0x18)
                ), P80D)
        }

        Store (P80D, P80H)
    }

    Method (PNOT, 0, Serialized)
    {
        If (MPEN)
        {
            If (And (PDC0, 0x08))
            {
                Notify (\_PR.CPU0, 0x80)
                If (And (PDC0, 0x10))
                {
                    Sleep (0x64)
                    Notify (\_PR.CPU0, 0x81)
                }
            }

            If (And (PDC1, 0x08))
            {
                Notify (\_PR.CPU1, 0x80)
                If (And (PDC1, 0x10))
                {
                    Sleep (0x64)
                    Notify (\_PR.CPU1, 0x81)
                }
            }
        }
        Else
        {
            Notify (\_PR.CPU0, 0x80)
            Sleep (0x64)
            Notify (\_PR.CPU0, 0x81)
        }
    }

    Method (TRAP, 1, Serialized)
    {
        Store (Arg0, SMIF)
        Store (0x00, TRP0)
        Return (SMIF)
    }

    Method (VTOB, 1, NotSerialized)
    {
        Store (0x01, Local0)
        ShiftLeft (Local0, Arg0, Local0)
        Return (Local0)
    }

    Method (BTOV, 1, NotSerialized)
    {
        ShiftRight (Arg0, 0x01, Local0)
        Store (0x00, Local1)
        While (Local0)
        {
            Increment (Local1)
            ShiftRight (Local0, 0x01, Local0)
        }

        Return (Local1)
    }

    Method (MKWD, 2, NotSerialized)
    {
        If (And (Arg1, 0x80))
        {
            Store (0xFFFF0000, Local0)
        }
        Else
        {
            Store (Zero, Local0)
        }

        Or (Local0, Arg0, Local0)
        Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
        Return (Local0)
    }

    Method (POSW, 1, NotSerialized)
    {
        If (And (Arg0, 0x8000))
        {
            If (LEqual (Arg0, 0xFFFF))
            {
                Return (0xFFFFFFFF)
            }
            Else
            {
                Not (Arg0, Local0)
                Increment (Local0)
                And (Local0, 0xFFFF, Local0)
                Return (Local0)
            }
        }
        Else
        {
            Return (Arg0)
        }
    }

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

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

    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 (GETP, 1, Serialized)
    {
        If (LEqual (And (Arg0, 0x09), 0x00))
        {
            Return (0xFFFFFFFF)
        }

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

        ShiftRight (And (Arg0, 0x0300), 0x08, Local0)
        ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)
        Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))
            ))
    }

    Method (GDMA, 5, Serialized)
    {
        If (Arg0)
        {
            If (LAnd (Arg1, Arg4))
            {
                Return (0x14)
            }

            If (LAnd (Arg2, Arg4))
            {
                Return (Multiply (Subtract (0x04, Arg3), 0x0F))
            }

            Return (Multiply (Subtract (0x04, Arg3), 0x1E))
        }

        Return (0xFFFFFFFF)
    }

    Method (GETT, 1, Serialized)
    {
        Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02
            ), 0x03), And (Arg0, 0x03)))))
    }

    Method (GETF, 3, Serialized)
    {
        Name (TMPF, 0x00)
        If (Arg0)
        {
            Or (TMPF, 0x01, TMPF)
        }

        If (And (Arg2, 0x02))
        {
            Or (TMPF, 0x02, TMPF)
        }

        If (Arg1)
        {
            Or (TMPF, 0x04, TMPF)
        }

        If (And (Arg2, 0x20))
        {
            Or (TMPF, 0x08, TMPF)
        }

        If (And (Arg2, 0x4000))
        {
            Or (TMPF, 0x10, TMPF)
        }

        Return (TMPF)
    }

    Method (SETP, 3, Serialized)
    {
        If (LGreater (Arg0, 0xF0))
        {
            Return (0x08)
        }
        Else
        {
            If (And (Arg1, 0x02))
            {
                If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))
                {
                    Return (0x2301)
                }

                If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, 0x01)))
                {
                    Return (0x2101)
                }
            }

            Return (0x1001)
        }
    }

    Method (SDMA, 1, Serialized)
    {
        If (LLessEqual (Arg0, 0x14))
        {
            Return (0x01)
        }

        If (LLessEqual (Arg0, 0x1E))
        {
            Return (0x02)
        }

        If (LLessEqual (Arg0, 0x2D))
        {
            Return (0x01)
        }

        If (LLessEqual (Arg0, 0x3C))
        {
            Return (0x02)
        }

        If (LLessEqual (Arg0, 0x5A))
        {
            Return (0x01)
        }

        Return (0x00)
    }

    Method (SETT, 3, Serialized)
    {
        If (And (Arg1, 0x02))
        {
            If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))
            {
                Return (0x0B)
            }

            If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, 0x01)))
            {
                Return (0x09)
            }
        }

        Return (0x04)
    }

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

    IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
    {
                Offset (0x20), 
        TMOD,   1, 
                Offset (0x6E), 
        INS4,   1
    }

    Scope (\_SB)
    {
        Method (_INI, 0, NotSerialized)
        {
            If (DTSE)
            {
                TRAP (0x47)
            }

            Store (0x07D0, OSYS)
//            If (CondRefOf (_OSI, Local0))
//            {
//                If (_OSI ("Linux"))
//                {
//                    Store (0x07D6, OSYS)
//                }
//                Else
//                {
//                    Store (0x07D1, OSYS)
//                   If (_OSI ("Windows 2001 SP2"))
//                    {
//                        Store (0x07D2, OSYS)
//                    }
//
//                    If (_OSI ("Windows 2001.1"))
//                    {
//                        Store (0x07D3, OSYS)
//                    }
//
//                    If (_OSI ("Windows 2001.1 SP1"))
//                    {
//                        Store (0x07D4, OSYS)
//                    }
//
//                    If (_OSI ("Windows 2006"))
//                    {
//                        Store (0x07D6, OSYS)
//                    }
//
//                    If (LAnd (MPEN, LEqual (OSYS, 0x07D1)))
//                    {
//                        TRAP (0x3D)
//                    }
//                }
//            }
	Store (0x07D6, OSYS)  // Fake Windows 2006 
        }

        Name (ECOK, 0x00)
        Device (PCI0)
        {
            Method (_S3D, 0, NotSerialized)
            {
                Return (0x02)
            }

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

            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, 0x030AD041)
            Name (_ADR, 0x00)
            Name (_BBN, 0x00)
            OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
            Field (HBUS, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x14), 
                    ,   1, 
                PEGA,   1, 
                        Offset (0x50), 
                    ,   4, 
                PM0H,   2, 
                        Offset (0x51), 
                PM1L,   2, 
                    ,   2, 
                PM1H,   2, 
                        Offset (0x52), 
                PM2L,   2, 
                    ,   2, 
                PM2H,   2, 
                        Offset (0x53), 
                PM3L,   2, 
                    ,   2, 
                PM3H,   2, 
                        Offset (0x54), 
                PM4L,   2, 
                    ,   2, 
                PM4H,   2, 
                        Offset (0x55), 
                PM5L,   2, 
                    ,   2, 
                PM5H,   2, 
                        Offset (0x56), 
                PM6L,   2, 
                    ,   2, 
                PM6H,   2, 
                        Offset (0x57), 
                    ,   7, 
                HENA,   1, 
                        Offset (0x5C), 
                    ,   3, 
                TOUD,   5
            }

            Name (BUF0, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x00FF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0100,             // Length
                    ,, )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0x00000CF7,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000CF8,         // Length
                    ,, , TypeStatic)
                IO (Decode16,
                    0x0CF8,             // Range Minimum
                    0x0CF8,             // Range Maximum
                    0x01,               // Alignment
                    0x08,               // Length
                    )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000D00,         // Range Minimum
                    0x0000FFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x0000F300,         // 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
                    ,, _Y00, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C4000,         // Range Minimum
                    0x000C7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y01, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C8000,         // Range Minimum
                    0x000CBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y02, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000CC000,         // Range Minimum
                    0x000CFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y03, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D0000,         // Range Minimum
                    0x000D3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y04, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D4000,         // Range Minimum
                    0x000D7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y05, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D8000,         // Range Minimum
                    0x000DBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y06, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000DC000,         // Range Minimum
                    0x000DFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y07, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E0000,         // Range Minimum
                    0x000E3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y08, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E4000,         // Range Minimum
                    0x000E7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y09, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E8000,         // Range Minimum
                    0x000EBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y0A, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000EC000,         // Range Minimum
                    0x000EFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y0B, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000F0000,         // Range Minimum
                    0x000FFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00010000,         // Length
                    ,, _Y0C, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0xFEBFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    ,, _Y0D, AddressRangeMemory, TypeStatic)
            })
            Method (_CRS, 0, Serialized)
            {
                If (PM1L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y00._LEN, C0LN)
                    Store (Zero, C0LN)
                }

                If (LEqual (PM1L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y00._RW, C0RW)
                    Store (Zero, C0RW)
                }

                If (PM1H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y01._LEN, C4LN)
                    Store (Zero, C4LN)
                }

                If (LEqual (PM1H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y01._RW, C4RW)
                    Store (Zero, C4RW)
                }

                If (PM2L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y02._LEN, C8LN)
                    Store (Zero, C8LN)
                }

                If (LEqual (PM2L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y02._RW, C8RW)
                    Store (Zero, C8RW)
                }

                If (PM2H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y03._LEN, CCLN)
                    Store (Zero, CCLN)
                }

                If (LEqual (PM2H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y03._RW, CCRW)
                    Store (Zero, CCRW)
                }

                If (PM3L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y04._LEN, D0LN)
                    Store (Zero, D0LN)
                }

                If (LEqual (PM3L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y04._RW, D0RW)
                    Store (Zero, D0RW)
                }

                If (PM3H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y05._LEN, D4LN)
                    Store (Zero, D4LN)
                }

                If (LEqual (PM3H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y05._RW, D4RW)
                    Store (Zero, D4RW)
                }

                If (PM4L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y06._LEN, D8LN)
                    Store (Zero, D8LN)
                }

                If (LEqual (PM4L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y06._RW, D8RW)
                    Store (Zero, D8RW)
                }

                If (PM4H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y07._LEN, DCLN)
                    Store (Zero, DCLN)
                }

                If (LEqual (PM4H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y07._RW, DCRW)
                    Store (Zero, DCRW)
                }

                If (PM5L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y08._LEN, E0LN)
                    Store (Zero, E0LN)
                }

                If (LEqual (PM5L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y08._RW, E0RW)
                    Store (Zero, E0RW)
                }

                If (PM5H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y09._LEN, E4LN)
                    Store (Zero, E4LN)
                }

                If (LEqual (PM5H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y09._RW, E4RW)
                    Store (Zero, E4RW)
                }

                If (PM6L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0A._LEN, E8LN)
                    Store (Zero, E8LN)
                }

                If (LEqual (PM6L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0A._RW, E8RW)
                    Store (Zero, E8RW)
                }

                If (PM6H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0B._LEN, ECLN)
                    Store (Zero, ECLN)
                }

                If (LEqual (PM6H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0B._RW, ECRW)
                    Store (Zero, ECRW)
                }

                If (PM0H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0C._LEN, F0LN)
                    Store (Zero, F0LN)
                }

                If (LEqual (PM0H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0C._RW, F0RW)
                    Store (Zero, F0RW)
                }

                CreateDWordField (BUF0, \_SB.PCI0._Y0D._MIN, M1MN)
                CreateDWordField (BUF0, \_SB.PCI0._Y0D._MAX, M1MX)
                CreateDWordField (BUF0, \_SB.PCI0._Y0D._LEN, M1LN)
                ShiftLeft (TOUD, 0x1B, M1MN)
                Add (Subtract (M1MX, M1MN), 0x01, M1LN)
                Return (BUF0)
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (GPIC)
                {
                    Return (Package (0x11)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x0002FFFF, 
                            0x00, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x0007FFFF, 
                            0x03, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001BFFFF, 
                            0x00, 
                            0x00, 
                            0x16
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x00, 
                            0x00, 
                            0x11
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x01, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x02, 
                            0x00, 
                            0x12
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x03, 
                            0x00, 
                            0x13
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x00, 
                            0x00, 
                            0x17
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x01, 
                            0x00, 
                            0x13
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x02, 
                            0x00, 
                            0x12
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x03, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x00, 
                            0x00, 
                            0x16
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x01, 
                            0x00, 
                            0x14
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x00, 
                            0x00, 
                            0x12
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            0x00, 
                            0x13
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x03, 
                            0x00, 
                            0x10
                        }
                    })
                }
                Else
                {
                    Return (Package (0x11)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x0002FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x0007FFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001BFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKG, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKB, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x02, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKH, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x02, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKG, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKE, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }
                    })
                }
            }

            Device (PDRC)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x01)
                Name (_CRS, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0xE0000000,         // Address Base
                        0x10000000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED14000,         // Address Base
                        0x00004000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED18000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED19000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED1C000,         // Address Base
                        0x00004000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED20000,         // Address Base
                        0x00020000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED45000,         // Address Base
                        0x0004B000,         // Address Length
                        )
                })
            }

            Device (PEGP)
            {
                Name (_ADR, 0x00010000)
                Method (_STA, 0, NotSerialized)
                {
                    If (PEGA)
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x13
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }
                        })
                    }
                }

                Device (VGA)
                {
                    Name (_ADR, 0x00)
                    Name (SWIT, 0x01)
                    Name (OSTE, 0x02)
                    Name (CRTA, 0x00)
                    Name (LCDA, 0x01)
                    Name (TV0A, 0x00)
                    Name (DVIA, 0x00)
                    Name (TOGF, 0x00)
                    Name (LSTF, 0x00)
                    Name (DISD, 0x01)
                    Name (WDAS, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_PSC, 0x00)
                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, _PSC)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (0x03, _PSC)
                    }

                    Method (_DOS, 1, NotSerialized)
                    {
                        Store (And (Arg0, 0x03), SWIT)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Return (Package (0x04)
                        {
                            0x00010100, 
                            0x00010110, 
                            0x00010200, 
                            0x00010210
                        })
                    }

                    Device (LCD)
                    {
                        Name (_ADR, 0x0110)
                        Method (_BCL, 0, NotSerialized)
                        {
                            Return (Package (0x0A)
                            {
                                0x64, 
                                0x2A, 
                                0x00, 
                                0x0E, 
                                0x1C, 
                                0x2A, 
                                0x38, 
                                0x46, 
                                0x54, 
                                0x64
                            })
                        }

                        Method (_BCM, 1, NotSerialized)
                        {
                            While (One)
                            {
				Name (k0, 0x00)
                                Store (ToInteger (Arg0), k0)
                                If (LEqual (k0, 0x00))
                                {
                                    Store (0x00, Local1)
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x0E))
                                    {
                                        Store (0x01, Local1)
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x1C))
                                        {
                                            Store (0x02, Local1)
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0x2A))
                                            {
                                                Store (0x03, Local1)
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x38))
                                                {
                                                    Store (0x04, Local1)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k0, 0x46))
                                                    {
                                                        Store (0x05, Local1)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k0, 0x54))
                                                        {
                                                            Store (0x06, Local1)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (k0, 0x64))
                                                            {
                                                                Store (0x07, Local1)
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                Break
                            }

                            If (LEqual (OSYS, 0x07D6))
                            {
                                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                Store (Local1, \_SB.PCI0.LPCB.EC0.BLVL)
                                Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            }
                        }

                        Method (_BQC, 0, NotSerialized)
                        {
                            If (LEqual (OSYS, 0x07D6))
                            {
                                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                Store (\_SB.PCI0.LPCB.EC0.BLVL, Local0)
                                Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            }

                            While (One)
                            {
                                Name (k0, 0x00)
                                Store (ToInteger (Local0), k0)
                                If (LEqual (k0, 0x00))
                                {
                                    Store (0x00, Local1)
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x01))
                                    {
                                        Store (0x0E, Local1)
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x02))
                                        {
                                            Store (0x1C, Local1)
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0x03))
                                            {
                                                Store (0x2A, Local1)
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x04))
                                                {
                                                    Store (0x38, Local1)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k0, 0x05))
                                                    {
                                                        Store (0x46, Local1)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k0, 0x06))
                                                        {
                                                            Store (0x54, Local1)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (k0, 0x07))
                                                            {
                                                                Store (0x64, Local1)
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                Break
                            }

                            Return (Local1)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            If (And (OSTE, 0x01))
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

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

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("LCD --_DSS", Debug)
                        }
                    }

                    Device (CRT)
                    {
                        Name (_ADR, 0x0100)
                        Method (_DCS, 0, NotSerialized)
                        {
                            If (And (OSTE, 0x02))
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

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

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("CRT --_DSS", Debug)
                        }
                    }

                    Device (TV0)
                    {
                        Name (_ADR, 0x0200)
                        Method (_DCS, 0, NotSerialized)
                        {
                            If (And (OSTE, 0x04))
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

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

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("TV --_DSS", Debug)
                        }
                    }

                    Device (DVI)
                    {
                        Name (_ADR, 0x0210)
                        Method (_DCS, 0, NotSerialized)
                        {
                            If (And (OSTE, 0x08))
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

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

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("DVI --_DSS", Debug)
                        }
                    }

                    Method (SWIH, 0, NotSerialized)
                    {
                        Store (\_SB.PHSR (0x06, 0x00), Local2)
                        Store (And (Local2, 0x0F), WDAS)
                        Store (And (ShiftRight (Local2, 0x04), 0x0F), DISD)
                        While (One)
                        {
                            Name (k0, 0x00)
                            Store (ToInteger (WDAS), k0)
                            If (LEqual (k0, 0x01))
                            {
                                Store (0x01, OSTE)
                            }
                            Else
                            {
                                If (LEqual (k0, 0x03))
                                {
                                    While (One)
                                    {
                                        Name (k1, 0x00)
                                        Store (ToInteger (DISD), k1)
                                        If (LEqual (k1, 0x01))
                                        {
                                            Store (0x03, OSTE)
                                        }
                                        Else
                                        {
                                            If (LEqual (k1, 0x02))
                                            {
                                                Store (0x01, OSTE)
                                            }
                                            Else
                                            {
                                                If (LEqual (k1, 0x03))
                                                {
                                                    Store (0x02, OSTE)
                                                }
                                                Else
                                                {
                                                    Store (0x03, OSTE)
                                                }
                                            }
                                        }

                                        Break
                                    }
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x05))
                                    {
                                        While (One)
                                        {
                                            Name (k2, 0x00)
                                            Store (ToInteger (DISD), k2)
                                            If (LEqual (k2, 0x01))
                                            {
                                                Store (0x05, OSTE)
                                            }
                                            Else
                                            {
                                                If (LEqual (k2, 0x04))
                                                {
                                                    Store (0x01, OSTE)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k2, 0x05))
                                                    {
                                                        Store (0x04, OSTE)
                                                    }
                                                    Else
                                                    {
                                                        Store (0x05, OSTE)
                                                    }
                                                }
                                            }

                                            Break
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x07))
                                        {
                                            While (One)
                                            {
                                                Name (k3, 0x00)
                                                Store (ToInteger (DISD), k3)
                                                If (LEqual (k3, 0x01))
                                                {
                                                    Store (0x03, OSTE)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k3, 0x02))
                                                    {
                                                        Store (0x05, OSTE)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k3, 0x03))
                                                        {
                                                            Store (0x02, OSTE)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (k3, 0x04))
                                                            {
                                                                Store (0x01, OSTE)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (k3, 0x05))
                                                                {
                                                                    Store (0x04, OSTE)
                                                                }
                                                                Else
                                                                {
                                                                    Store (0x07, OSTE)
                                                                }
                                                            }
                                                        }
                                                    }
                                                }

                                                Break
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0x09))
                                            {
                                                While (One)
                                                {
                                                    Name (k4, 0x00)
                                                    Store (ToInteger (DISD), k4)
                                                    If (LEqual (k4, 0x01))
                                                    {
                                                        Store (0x09, OSTE)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k4, 0x08))
                                                        {
                                                            Store (0x01, OSTE)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (k4, 0x09))
                                                            {
                                                                Store (0x08, OSTE)
                                                            }
                                                            Else
                                                            {
                                                                Store (0x09, OSTE)
                                                            }
                                                        }
                                                    }

                                                    Break
                                                }
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x0B))
                                                {
                                                    While (One)
                                                    {
                                                        Name (k5, 0x00)
                                                        Store (ToInteger (DISD), k5)
                                                        If (LEqual (k5, 0x01))
                                                        {
                                                            Store (0x09, OSTE)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (k5, 0x02))
                                                            {
                                                                Store (0x01, OSTE)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (k5, 0x03))
                                                                {
                                                                    Store (0x08, OSTE)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (k5, 0x08))
                                                                    {
                                                                        Store (0x01, OSTE)
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (k5, 0x09))
                                                                        {
                                                                            Store (0x08, OSTE)
                                                                        }
                                                                        Else
                                                                        {
                                                                            Store (0x09, OSTE)
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }

                                                        Break
                                                    }
                                                }
                                                Else
                                                {
                                                    If (LEqual (k0, 0x0D))
                                                    {
                                                        While (One)
                                                        {
                                                            Name (k6, 0x00)
                                                            Store (ToInteger (DISD), k6)
                                                            If (LEqual (k6, 0x01))
                                                            {
                                                                Store (0x09, OSTE)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (k6, 0x04))
                                                                {
                                                                    Store (0x01, OSTE)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (k6, 0x05))
                                                                    {
                                                                        Store (0x04, OSTE)
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (k6, 0x08))
                                                                        {
                                                                            Store (0x05, OSTE)
                                                                        }
                                                                        Else
                                                                        {
                                                                            If (LEqual (k6, 0x09))
                                                                            {
                                                                                Store (0x08, OSTE)
                                                                            }
                                                                            Else
                                                                            {
                                                                                Store (0x0D, OSTE)
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }

                                                            Break
                                                        }
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k0, 0x0F))
                                                        {
                                                            While (One)
                                                            {
                                                                Name (k7, 0x00)
                                                                Store (ToInteger (DISD), k7)
                                                                If (LEqual (k7, 0x01))
                                                                {
                                                                    Store (0x09, OSTE)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (k7, 0x02))
                                                                    {
                                                                        Store (0x05, OSTE)
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (k7, 0x03))
                                                                        {
                                                                            Store (0x08, OSTE)
                                                                        }
                                                                        Else
                                                                        {
                                                                            If (LEqual (k7, 0x04))
                                                                            {
                                                                                Store (0x01, OSTE)
                                                                            }
                                                                            Else
                                                                            {
                                                                                If (LEqual (k7, 0x05))
                                                                                {
                                                                                    Store (0x04, OSTE)
                                                                                }
                                                                                Else
                                                                                {
                                                                                    If (LEqual (k7, 0x08))
                                                                                    {
                                                                                        Store (0x05, OSTE)
                                                                                    }
                                                                                    Else
                                                                                    {
                                                                                        If (LEqual (k7, 0x09))
                                                                                        {
                                                                                            Store (0x08, OSTE)
                                                                                        }
                                                                                        Else
                                                                                        {
                                                                                            Store (0x0F, OSTE)
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }

                                                                Break
                                                            }
                                                        }
                                                        Else
                                                        {
                                                            Store (0x0F, OSTE)
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }

                        Notify (VGA, 0x80)
                        Return (0x00)
                    }

                    Name (ERR0, Buffer (0x04)
                    {
                        /* 0000 */    0x00, 0x00, 0x00, 0x00
                    })
                    Name (ERR1, Buffer (0x04)
                    {
                        /* 0000 */    0x01, 0x00, 0x00, 0x80
                    })
                    Name (VER1, Buffer (0x04)
                    {
                        /* 0000 */    0x01, 0x00, 0x00, 0x00
                    })
                    Method (NVIF, 3, NotSerialized)
                    {
                        Store (ERR1, Local0)
                        If (LEqual (Arg0, 0x01))
                        {
                            Concatenate (ERR0, VER1, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x08))
                            {
                                If (LEqual (Arg1, 0x00))
                                {
                                    Store (ERR0, Local0)
                                }
                                Else
                                {
                                    If (LEqual (Arg1, 0x01))
                                    {
                                        Name (DA81, Buffer (0x04)
                                        {
                                            /* 0000 */    0x32, 0x00, 0x05, 0x00
                                        })
                                        Concatenate (ERR0, DA81, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg1, 0x02))
                                        {
                                            Store ("VGA : NVIF(0x00000008, 2)", Debug)
                                            Store (Arg2, Debug)
                                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                            CreateByteField (Arg2, 0x00, NVTM)
                                            Store (NVTM, \_SB.PCI0.LPCB.EC0.VTMP)
                                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                                            Store (ERR0, Local0)
                                        }
                                    }
                                }
                            }
                        }

                        Return (Local0)
                    }
                }
            }

            Device (GFX0)
            {
                Name (_ADR, 0x00020000)
                Method (_STA, 0, NotSerialized)
                {
                    If (PEGA)
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                Method (_DOS, 1, NotSerialized)
                {
                    Store (And (Arg0, 0x03), DSEN)
                }

                Method (_DOD, 0, NotSerialized)
                {
                    If (LEqual (NDID, 0x01))
                    {
                        Name (TMP1, Package (0x01)
                        {
                            0xFFFFFFFF
                        })
                        Store (Or (0x00010000, DID1), Index (TMP1, 0x00))
                        Return (TMP1)
                    }

                    If (LEqual (NDID, 0x02))
                    {
                        Name (TMP2, Package (0x02)
                        {
                            0xFFFFFFFF, 
                            0xFFFFFFFF
                        })
                        Store (Or (0x00010000, DID1), Index (TMP2, 0x00))
                        Store (Or (0x00010000, DID2), Index (TMP2, 0x01))
                        Return (TMP2)
                    }

                    If (LEqual (NDID, 0x03))
                    {
                        Name (TMP3, Package (0x03)
                        {
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF
                        })
                        Store (Or (0x00010000, DID1), Index (TMP3, 0x00))
                        Store (Or (0x00010000, DID2), Index (TMP3, 0x01))
                        Store (Or (0x00010000, DID3), Index (TMP3, 0x02))
                        Return (TMP3)
                    }

                    If (LEqual (NDID, 0x04))
                    {
                        Name (TMP4, Package (0x04)
                        {
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF
                        })
                        Store (Or (0x00010000, DID1), Index (TMP4, 0x00))
                        Store (Or (0x00010000, DID2), Index (TMP4, 0x01))
                        Store (Or (0x00010000, DID3), Index (TMP4, 0x02))
                        Store (Or (0x00010000, DID4), Index (TMP4, 0x03))
                        Return (TMP4)
                    }

                    Name (TMP5, Package (0x05)
                    {
                        0xFFFFFFFF, 
                        0xFFFFFFFF, 
                        0xFFFFFFFF, 
                        0xFFFFFFFF, 
                        0xFFFFFFFF
                    })
                    Store (Or (0x00010000, DID1), Index (TMP5, 0x00))
                    Store (Or (0x00010000, DID2), Index (TMP5, 0x01))
                    Store (Or (0x00010000, DID3), Index (TMP5, 0x02))
                    Store (Or (0x00010000, DID4), Index (TMP5, 0x03))
                    Store (Or (0x00010000, DID5), Index (TMP5, 0x04))
                    Return (TMP5)
                }

                Device (DD01)
                {
                    Method (_ADR, 0, Serialized)
                    {
                        Return (And (0xFFFF, DID1))
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        TRAP (0x01)
                        If (And (CSTE, 0x01))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x01))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
                        {
                            Store (NSTE, CSTE)
                        }
                    }
                }

                Device (DD02)
                {
                    Method (_ADR, 0, Serialized)
                    {
                        Return (And (0xFFFF, DID2))
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        TRAP (0x01)
                        If (And (CSTE, 0x02))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x02))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
                        {
                            Store (NSTE, CSTE)
                        }
                    }
                }

                Device (DD03)
                {
                    Method (_ADR, 0, Serialized)
                    {
                        Return (And (0xFFFF, DID3))
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        TRAP (0x01)
                        If (And (CSTE, 0x04))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x04))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
                        {
                            Store (NSTE, CSTE)
                        }
                    }
                }

                Device (DD04)
                {
                    Method (_ADR, 0, Serialized)
                    {
                        Return (And (0xFFFF, DID4))
                    }

                    Method (_BCL, 0, NotSerialized)
                    {
                        Return (Package (0x0A)
                        {
                            0x64, 
                            0x2A, 
                            0x00, 
                            0x0E, 
                            0x1C, 
                            0x2A, 
                            0x38, 
                            0x46, 
                            0x54, 
                            0x64
                        })
                    }

                    Method (_BCM, 1, NotSerialized)
                    {
                        While (One)
                        {
                            Name (k0, 0x00)
                            Store (ToInteger (Arg0), k0)
                            If (LEqual (k0, 0x00))
                            {
                                Store (0x00, Local1)
                            }
                            Else
                            {
                                If (LEqual (k0, 0x0E))
                                {
                                    Store (0x01, Local1)
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x1C))
                                    {
                                        Store (0x02, Local1)
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x2A))
                                        {
                                            Store (0x03, Local1)
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0x38))
                                            {
                                                Store (0x04, Local1)
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x46))
                                                {
                                                    Store (0x05, Local1)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k0, 0x54))
                                                    {
                                                        Store (0x06, Local1)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k0, 0x64))
                                                        {
                                                            Store (0x07, Local1)
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }

                        If (LEqual (OSYS, 0x07D6))
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            Store (Local1, \_SB.PCI0.LPCB.EC0.BLVL)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                        }
                    }

                    Method (_BQC, 0, NotSerialized)
                    {
                        If (LEqual (OSYS, 0x07D6))
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            Store (\_SB.PCI0.LPCB.EC0.BLVL, Local0)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                        }

                        While (One)
                        {
                            Name (k0, 0x00)
                            Store (ToInteger (Local0), k0)
                            If (LEqual (k0, 0x00))
                            {
                                Store (0x00, Local1)
                            }
                            Else
                            {
                                If (LEqual (k0, 0x01))
                                {
                                    Store (0x0E, Local1)
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x02))
                                    {
                                        Store (0x1C, Local1)
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x03))
                                        {
                                            Store (0x2A, Local1)
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0x04))
                                            {
                                                Store (0x38, Local1)
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x05))
                                                {
                                                    Store (0x46, Local1)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k0, 0x06))
                                                    {
                                                        Store (0x54, Local1)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k0, 0x07))
                                                        {
                                                            Store (0x64, Local1)
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            Break
                        }

                        Return (Local1)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        TRAP (0x01)
                        If (And (CSTE, 0x08))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x08))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
                        {
                            Store (NSTE, CSTE)
                        }
                    }
                }

                Device (DD05)
                {
                    Method (_ADR, 0, Serialized)
                    {
                        Return (And (0xFFFF, DID5))
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        TRAP (0x01)
                        If (And (CSTE, 0x10))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x10))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
                        {
                            Store (NSTE, CSTE)
                        }
                    }
                }
            }

            Device (HDEF)
            {
                Name (_ADR, 0x001B0000)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
            }

            Device (RP01)
            {
                Name (_ADR, 0x001C0000)
                OperationRegion (P1CS, PCI_Config, 0x40, 0x0100)
                Field (P1CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP1,   1, 
                        ,   2, 
                    PDC1,   1, 
                        ,   2, 
                    PDS1,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP1,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

                Device (LANE)
                {
                    Name (_ADR, 0x00)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x05
                    })
                    Name (LANP, 0x00)
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x00))
                        {
                            Store (0x00, LANP)
                        }
                        Else
                        {
                            Store (0x01, LANP)
                        }
                    }
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x13
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (RP02)
            {
                Name (_ADR, 0x001C0001)
                OperationRegion (P2CS, PCI_Config, 0x40, 0x0100)
                Field (P2CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP2,   1, 
                        ,   2, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP2,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

                Device (PXS2)
                {
                    Name (_ADR, 0x00)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x04
                    })
                    Name (_EJD, "\\_SB.PCI0.USB7.HUB7.PRT8")
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x13
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x10
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (RP03)
            {
                Name (_ADR, 0x001C0002)
                OperationRegion (P3CS, PCI_Config, 0x40, 0x0100)
                Field (P3CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP3,   1, 
                        ,   2, 
                    PDC3,   1, 
                        ,   2, 
                    PDS3,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP3,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

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

                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x04
                    })
                    Name (_EJD, "\\_SB.PCI0.USB7.HUB7.PRT7")
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x13
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x11
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (RP04)
            {
                Name (_ADR, 0x001C0003)
                OperationRegion (P4CS, PCI_Config, 0x40, 0x0100)
                Field (P4CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP4,   1, 
                        ,   2, 
                    PDC4,   1, 
                        ,   2, 
                    PDS4,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP4,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

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

                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x04
                    })
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x13
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x12
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (RP05)
            {
                Name (_ADR, 0x001C0004)
                OperationRegion (P5CS, PCI_Config, 0x40, 0x0100)
                Field (P5CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP5,   1, 
                        ,   2, 
                    PDC5,   1, 
                        ,   2, 
                    PDS5,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP5,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

                Device (PXS5)
                {
                    Name (_ADR, 0x00)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x04
                    })
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x13
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (RP06)
            {
                Name (_ADR, 0x001C0005)
                OperationRegion (P6CS, PCI_Config, 0x40, 0x0100)
                Field (P6CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x10), 
                        ,   4, 
                    LDP6,   1, 
                            Offset (0x1A), 
                    ABP6,   1, 
                        ,   2, 
                    PDC6,   1, 
                        ,   2, 
                    PDS6,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP6,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

                Device (PXS6)
                {
                    Name (_ADR, 0x00)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x04
                    })
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x13
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x10
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)
                OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)
                Field (U1CS, DWordAcc, NoLock, Preserve)
                {
                    U1EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x03, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    Store (0x03, U1EN)
                }

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

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

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)
                OperationRegion (U2CS, PCI_Config, 0xC4, 0x04)
                Field (U2CS, DWordAcc, NoLock, Preserve)
                {
                    U2EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x04, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    Store (0x03, U2EN)
                }

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

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

            Device (USB3)
            {
                Name (_ADR, 0x001D0002)
                OperationRegion (U2CS, PCI_Config, 0xC4, 0x04)
                Field (U2CS, DWordAcc, NoLock, Preserve)
                {
                    U3EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    Store (0x03, U3EN)
                }

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

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

            Device (USB4)
            {
                Name (_ADR, 0x001D0003)
                OperationRegion (U4CS, PCI_Config, 0xC4, 0x04)
                Field (U4CS, DWordAcc, NoLock, Preserve)
                {
                    U4EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    Store (0x03, U4EN)
                }

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

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

            Device (USB7)
            {
                Name (_ADR, 0x001D0007)
                Device (HUB7)
                {
                    Name (_ADR, 0x00)
                    Device (PRT1)
                    {
                        Name (_ADR, 0x01)
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                    }

                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                    }

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                    }

                    Device (PRT5)
                    {
                        Name (_ADR, 0x05)
                    }

                    Device (PRT6)
                    {
                        Name (_ADR, 0x06)
                    }

                    Device (PRT7)
                    {
                        Name (_ADR, 0x07)
                        Name (_EJD, "\\_SB.PCI0.RP02.PXS3")
                    }

                    Device (PRT8)
                    {
                        Name (_ADR, 0x08)
                        Name (_EJD, "\\_SB.PCI0.RP03.PXS2")
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

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

            Device (PCIB)
            {
                Name (_ADR, 0x001E0000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0x0004FFFF, 
                                0x00, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0x0004FFFF, 
                                0x01, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0x0004FFFF, 
                                0x02, 
                                0x00, 
                                0x13
                            }, 

                            Package (0x04)
                            {
                                0x0008FFFF, 
                                0x00, 
                                0x00, 
                                0x14
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x15)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKF, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKG, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKH, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKE, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0001FFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKG, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0001FFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKF, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0001FFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKE, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0001FFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKH, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0003FFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

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

                            Package (0x04)
                            {
                                0x0003FFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKF, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0003FFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKG, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0005FFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0005FFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKE, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0005FFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKG, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0005FFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKF, 
                                0x00
                            }, 

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

                Device (LANC)
                {
                    Name (_ADR, 0x00080000)
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x05
                    })
                    Name (LANP, 0x00)
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x00))
                        {
                            Store (0x00, LANP)
                        }
                        Else
                        {
                            Store (0x01, LANP)
                        }
                    }
                }
            }

            Device (LPCB)
            {
                Name (_ADR, 0x001F0000)
                OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)
                Field (LPC0, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x20), 
                    PARC,   8, 
                    PBRC,   8, 
                    PCRC,   8, 
                    PDRC,   8, 
                            Offset (0x28), 
                    PERC,   8, 
                    PFRC,   8, 
                    PGRC,   8, 
                    PHRC,   8, 
                            Offset (0x40), 
                    UADR,   3, 
                        ,   1, 
                    UBDR,   3, 
                            Offset (0x41), 
                    LPDR,   2, 
                        ,   2, 
                    FDDR,   1, 
                            Offset (0x42), 
                    UALE,   1, 
                    UBLE,   1, 
                    LPLE,   1, 
                    FDLE,   1, 
                    SBLE,   1, 
                    MDLE,   1, 
                    MSLE,   1, 
                    ADLE,   1, 
                    GLLE,   1, 
                    GHLE,   1, 
                    KBLE,   1, 
                    MCLE,   1, 
                    C1LE,   1, 
                    C2LE,   1, 
                            Offset (0x44), 
                            Offset (0x60), 
                        ,   7, 
                    C4C3,   1
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PARC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLA, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y0E)
                                {}
                        })
                        CreateWordField (RTLA, \_SB.PCI0.LPCB.LNKA._CRS._Y0E._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PARC, 0x0F), IRQ0)
                        Return (RTLA)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PARC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PARC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PBRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLB, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y0F)
                                {}
                        })
                        CreateWordField (RTLB, \_SB.PCI0.LPCB.LNKB._CRS._Y0F._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PBRC, 0x0F), IRQ0)
                        Return (RTLB)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PBRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PBRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PCRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLC, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y10)
                                {}
                        })
                        CreateWordField (RTLC, \_SB.PCI0.LPCB.LNKC._CRS._Y10._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PCRC, 0x0F), IRQ0)
                        Return (RTLC)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PCRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PCRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PDRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y11)
                                {}
                        })
                        CreateWordField (RTLD, \_SB.PCI0.LPCB.LNKD._CRS._Y11._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PDRC, 0x0F), IRQ0)
                        Return (RTLD)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PDRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PDRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PERC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLE, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y12)
                                {}
                        })
                        CreateWordField (RTLE, \_SB.PCI0.LPCB.LNKE._CRS._Y12._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PERC, 0x0F), IRQ0)
                        Return (RTLE)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PERC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PERC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PFRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLF, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y13)
                                {}
                        })
                        CreateWordField (RTLF, \_SB.PCI0.LPCB.LNKF._CRS._Y13._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PFRC, 0x0F), IRQ0)
                        Return (RTLF)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PFRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PFRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PGRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLG, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y14)
                                {}
                        })
                        CreateWordField (RTLG, \_SB.PCI0.LPCB.LNKG._CRS._Y14._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PGRC, 0x0F), IRQ0)
                        Return (RTLG)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PGRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PGRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PHRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLH, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, _Y15)
                                {}
                        })
                        CreateWordField (RTLH, \_SB.PCI0.LPCB.LNKH._CRS._Y15._INT, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PHRC, 0x0F), IRQ0)
                        Return (RTLH)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PHRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PHRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0062,             // Range Minimum
                            0x0062,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0066,             // Range Minimum
                            0x0066,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                    })
                    Name (_GPE, 0x17)
                    Name (SEL0, 0xF0)
                    Name (BFLG, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, Local0)
                            If (Local0)
                            {
                                Store (0x01, ECOK)
                                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                Store (\TMOD, \_SB.PCI0.LPCB.EC0.TMOD)
                                Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            }
                            Else
                            {
                                Store (0x00, ECOK)
                            }
                        }

                        If (\_SB.ECOK)
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            If (LEqual (OSYS, 0x07D6))
                            {
                                Store (One, \_SB.PCI0.LPCB.EC0.OSTP)
                                \_SB.PHSR (0x0D, 0x00)
                            }
                            Else
                            {
                                Store (Zero, \_SB.PCI0.LPCB.EC0.OSTP)
                            }

                            Store (0x03, \_SB.PCI0.LPCB.EC0.RG59)
                            Store (\_SB.CIRE, \_SB.PCI0.LPCB.EC0.CIRE)
                            Store (\_SB.PHSR (0x05, 0x00), DOFF)
                            Store (\_SB.PCI0.LPCB.EC0.ACDF, \PWRS)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                        }
                    }

                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x04), 
                        CMCM,   8, 
                        CMD1,   8, 
                        CMD2,   8, 
                        CMD3,   8, 
                                Offset (0x18), 
                        SMPR,   8, 
                        SMST,   8, 
                        SMAD,   8, 
                        SMCM,   8, 
                        SMD0,   256, 
                        BCNT,   8, 
                        SMAA,   8, 
                        BATD,   16, 
                        ACDF,   1, 
                                Offset (0x41), 
                            ,   4, 
                        FPR1,   1, 
                        FLS4,   1, 
                        S5LW,   1, 
                        PFLG,   1, 
                                Offset (0x43), 
                        TMSS,   2, 
                            ,   2, 
                        BANK,   4, 
                                Offset (0x45), 
                        VFAN,   1, 
                                Offset (0x46), 
                        RL01,   1, 
                        RD01,   1, 
                        RF01,   1, 
                        RP01,   1, 
                        RB01,   1, 
                        RC01,   1, 
                            ,   1, 
                        R701,   1, 
                        R801,   1, 
                        RM01,   1, 
                        RI01,   1, 
                            ,   1, 
                            ,   1, 
                            ,   1, 
                        RA01,   1, 
                        RR01,   1, 
                        RL10,   1, 
                        RD10,   1, 
                        RF10,   1, 
                        RP10,   1, 
                        RB10,   1, 
                        RC10,   1, 
                            ,   1, 
                        R710,   1, 
                        R810,   1, 
                        RM10,   1, 
                        RI10,   1, 
                            ,   1, 
                            ,   1, 
                            ,   1, 
                        RA10,   1, 
                        RR10,   1, 
                        LIDE,   1, 
                        BAYE,   1, 
                        PRDE,   1, 
                        WP01,   1, 
                        WB01,   1, 
                        WC01,   1, 
                            ,   1, 
                        W701,   1, 
                        W801,   1, 
                        WM01,   1, 
                        WI01,   1, 
                            ,   1, 
                            ,   1, 
                            ,   1, 
                        WA01,   1, 
                        WR01,   1, 
                        LIDS,   1, 
                        BAYI,   1, 
                        PRCT,   1, 
                        WP10,   1, 
                        WB10,   1, 
                        WC10,   1, 
                            ,   1, 
                        W710,   1, 
                        W810,   1, 
                        WM10,   1, 
                        WI10,   1, 
                            ,   1, 
                            ,   1, 
                            ,   1, 
                        WA10,   1, 
                        WR10,   1, 
                                Offset (0x51), 
                        BLVL,   8, 
                                Offset (0x53), 
                        DOFF,   8, 
                                Offset (0x57), 
                        RG57,   8, 
                        CTMP,   8, 
                        RG59,   8, 
                        RG5A,   8, 
                        RG5B,   8, 
                        FSPD,   16, 
                        VTMP,   8, 
                        WLAN,   1, 
                        BLTH,   1, 
                        CPLE,   1, 
                        KSWH,   1, 
                        CIRE,   1, 
                                Offset (0x60), 
                            ,   6, 
                        RFST,   1, 
                        BTHE,   1, 
                        BRLV,   8, 
                                Offset (0x63), 
                            ,   7, 
                        VGAF,   1, 
                                Offset (0x65), 
                            ,   1, 
                        TMOD,   1, 
                                Offset (0x71), 
                        MBTS,   1, 
                        MBTF,   1, 
                                Offset (0x72), 
                        MBTC,   1, 
                            ,   2, 
                        LION,   1, 
                                Offset (0x77), 
                        BA1C,   8, 
                                Offset (0x7E), 
                        NEVT,   16, 
                                Offset (0x81), 
                        ABTS,   1, 
                        ABFC,   1, 
                            ,   3, 
                        ABBL,   1, 
                        Z001,   1, 
                        ABCT,   1, 
                        ABCG,   1, 
                            ,   2, 
                        ABTP,   1, 
                                Offset (0x87), 
                        BA2C,   8, 
                                Offset (0x8A), 
                        ACUR,   16, 
                                Offset (0x8F), 
                        MBTB,   8, 
                                Offset (0x9D), 
                        OSTP,   1, 
                                Offset (0xA0), 
                        DESP,   8, 
                        DE0L,   8, 
                        DE0H,   8, 
                        DE1L,   8, 
                        DE1H,   8, 
                        DE2L,   8, 
                        DE2H,   8, 
                        DE3L,   8, 
                        DE3H,   8, 
                        DE4L,   8, 
                        DE4H,   8, 
                                Offset (0xAC), 
                        FEVT,   16, 
                        VEVT,   16, 
                                Offset (0xB5), 
                        FNSK,   8, 
                                Offset (0xC1), 
                        MCUR,   16, 
                        MBRM,   16, 
                        MBVG,   16, 
                        BTST,   8, 
                        ABCR,   16, 
                        ABRM,   16, 
                        ABVG,   16, 
                                Offset (0xD0), 
                        EBPL,   1, 
                                Offset (0xD1), 
                        PWRE,   1, 
                                Offset (0xD2), 
                            ,   6, 
                        VAUX,   1, 
                                Offset (0xD3), 
                        TPAD,   1, 
                                Offset (0xD6), 
                        DBPL,   8, 
                                Offset (0xD8), 
                        LFCC,   16, 
                        BTSN,   16, 
                        BTDC,   16, 
                        BTDV,   16, 
                        BTMN,   8, 
                        BTMD,   8, 
                        AFCC,   16, 
                        ABSN,   16, 
                        ABDC,   16, 
                        ABDV,   16, 
                        ABMN,   8, 
                        ABMD,   8, 
                        TRDV,   3
                    }

                    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 (MUT1, 0x00)
                    Mutex (MUT0, 0x00)
                    Method (SMRD, 4, NotSerialized)
                    {
                        If (LEqual (\_SB.ECOK, 0x00))
                        {
                            Return (0xFF)
                        }

                        If (LNotEqual (Arg0, 0x07))
                        {
                            If (LNotEqual (Arg0, 0x09))
                            {
                                If (LNotEqual (Arg0, 0x0B))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        Acquire (MUT0, 0xFFFF)
                        Store (0x04, Local0)
                        While (LGreater (Local0, 0x01))
                        {
                            And (SMST, 0x40, SMST)
                            Store (Arg2, SMCM)
                            Store (Arg1, SMAD)
                            Store (Arg0, SMPR)
                            Store (0x00, Local3)
                            While (LNot (And (SMST, 0xBF, Local1)))
                            {
                                Sleep (0x02)
                                Increment (Local3)
                                If (LEqual (Local3, 0x32))
                                {
                                    And (SMST, 0x40, SMST)
                                    Store (Arg2, SMCM)
                                    Store (Arg1, SMAD)
                                    Store (Arg0, SMPR)
                                    Store (0x00, 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 (BCNT, Local3)
                                ShiftRight (0x0100, 0x03, Local2)
                                If (LGreater (Local3, Local2))
                                {
                                    Store (Local2, Local3)
                                }

                                If (LLess (Local3, 0x09))
                                {
                                    Store (FLD0, Local2)
                                }
                                Else
                                {
                                    If (LLess (Local3, 0x11))
                                    {
                                        Store (FLD1, Local2)
                                    }
                                    Else
                                    {
                                        If (LLess (Local3, 0x19))
                                        {
                                            Store (FLD2, Local2)
                                        }
                                        Else
                                        {
                                            Store (FLD3, Local2)
                                        }
                                    }
                                }

                                Increment (Local3)
                                Store (Buffer (Local3) {}, Local4)
                                Decrement (Local3)
                                Store (Zero, Local5)
                                While (LGreater (Local3, Local5))
                                {
                                    GBFE (Local2, Local5, RefOf (Local6))
                                    PBFE (Local4, Local5, Local6)
                                    Increment (Local5)
                                }

                                PBFE (Local4, Local5, 0x00)
                                Store (Local4, Arg3)
                            }
                        }

                        Release (MUT0)
                        Return (Local0)
                    }

                    Method (SMWR, 4, NotSerialized)
                    {
                        If (LEqual (\_SB.ECOK, 0x00))
                        {
                            Return (0xFF)
                        }

                        If (LNotEqual (Arg0, 0x06))
                        {
                            If (LNotEqual (Arg0, 0x08))
                            {
                                If (LNotEqual (Arg0, 0x0A))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        Acquire (MUT0, 0xFFFF)
                        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 (0x00, Local3)
                            While (LNot (And (SMST, 0xBF, Local1)))
                            {
                                Sleep (0x02)
                                Increment (Local3)
                                If (LEqual (Local3, 0x32))
                                {
                                    And (SMST, 0x40, SMST)
                                    Store (Arg2, SMCM)
                                    Store (Arg1, SMAD)
                                    Store (Arg0, SMPR)
                                    Store (0x00, Local3)
                                }
                            }

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

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

                        Release (MUT0)
                        Return (Local0)
                    }

                    Method (APOL, 1, NotSerialized)
                    {
                        Store (Arg0, DBPL)
                        Store (0x01, EBPL)
                    }

                    Name (PSTA, 0x00)
                    Method (CPOL, 1, NotSerialized)
                    {
                        If (LEqual (PSTA, 0x00))
                        {
                            If (LNotEqual (\_SB.ECOK, 0x00))
                            {
                                APOL (Arg0)
                                Store (0x01, PSTA)
                            }
                        }
                    }

                    Method (_Q20, 0, NotSerialized)
                    {
                        If (\_SB.ECOK)
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            If (And (SMST, 0x40))
                            {
                                Store (SMAA, Local0)
                                If (LEqual (Local0, 0x14))
                                {
                                    And (SMST, 0xBF, SMST)
                                    Store (PWRE, Local1)
                                    If (Local1)
                                    {
                                        Store (0x00, PWRE)
                                        Store (0x12, BFLG)
                                        CPOL (0x01)
                                    }
                                }

                                If (LEqual (Local0, 0x16))
                                {
                                    And (SMST, 0xBF, SMST)
                                    Store (0x04, \_SB.BAT1.BCRI)
                                    Notify (\_SB.BAT1, 0x80)
                                }
                                Else
                                {
                                    Store (0x00, \_SB.BAT1.BCRI)
                                }
                            }

                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                        }
                    }

                    Method (_Q09, 0, NotSerialized)
                    {
                        If (\_SB.ECOK)
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            Store (0x00, \_SB.PCI0.LPCB.EC0.PSTA)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            \_SB.BAT1.BSTA ()
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            Store (\_SB.PCI0.LPCB.EC0.ACDF, \PWRS)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            PNOT ()
                            Notify (\_SB.ACAD, 0x80)
                            Sleep (0x01F4)
                            Notify (\_SB.BAT1, 0x80)
                            If (\_SB.BAT1.BTCH)
                            {
                                \_SB.BAT1.UBIF ()
                                Notify (\_SB.BAT1, 0x81)
                                Store (0x00, \_SB.BAT1.BTCH)
                            }
                        }
                    }

                    Method (_Q8A, 0, NotSerialized)
                    {
                        If (LIDE)
                        {
                            Store (0x01, LIDE)
                            Notify (\_SB.LID, 0x80)
                        }
                    }

                    Method (_Q8D, 0, NotSerialized)
                    {
                        Store (0x00, \TDTY)
                        Store (0x01, \THTE)
                    }

                    Method (_Q8E, 0, NotSerialized)
                    {
                        Store (0x00, \THTE)
                    }

                    Method (_Q01, 0, NotSerialized)
                    {
                        P8XH (0x00, 0x01)
                        Notify (\_SB.BT, 0x90)
                    }

                    Method (_Q02, 0, NotSerialized)
                    {
                        P8XH (0x00, 0x02)
                        Notify (\_SB.BT, 0x90)
                    }

                    Method (_Q90, 0, NotSerialized)
                    {
                        P8XH (0x00, 0x90)
                        \_SB.VALZ.EVNT (0x02)
                    }

                    Method (_Q91, 0, NotSerialized)
                    {
                        P8XH (0x00, 0x91)
                        \_SB.VALZ.EVNT (0x03)
                        Sleep (0x05)
                        \_SB.VALZ.EVNT (0x04)
                    }

                    Method (_Q92, 0, NotSerialized)
                    {
                        P8XH (0x00, 0x92)
                        \_SB.VALZ.EVNT (0x02)
                        Sleep (0x05)
                        \_SB.VALZ.EVNT (0x03)
                        Sleep (0x05)
                        \_SB.VALZ.EVNT (0x04)
                    }

                    Method (_Q03, 0, NotSerialized)
                    {
                        Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                        And (\_SB.PCI0.LPCB.EC0.MBTB, 0x03, Local0)
                        Release (\_SB.PCI0.LPCB.EC0.MUT1)
                        While (One)
                        {
                            Name (k0, 0x00)
                            Store (Local0, k0)
                            If (LEqual (k0, 0x01))
                            {
                                Notify (\_SB.PCI0.LPCB.EC0.DAL1, 0x80)
                            }
                            Else
                            {
                                If (LEqual (k0, 0x02))
                                {
                                    Notify (\_SB.PCI0.LPCB.EC0.DAL2, 0x80)
                                }
                            }

                            Break
                        }
                    }

                    Method (_Q0E, 0, NotSerialized)
                    {
                        If (\_SB.PCI0.PEGA)
                        {
                            \_SB.PCI0.PEGP.VGA.SWIH ()
                        }
                        Else
                        {
                            Store (0x01, TLST)
                            HKDS (0x0A)
                        }
                    }

                    Method (_Q0F, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.LPCB.EC0.BLVL, Local0)
                        If (Local0)
                        {
                            Decrement (Local0)
                        }
                        Else
                        {
                            Store (Zero, Local0)
                        }

                        Store (Local0, \_SB.PCI0.LPCB.EC0.BLVL)
                        If (\_SB.PCI0.PEGA)
                        {
                            Notify (\_SB.PCI0.PEGP.VGA.LCD, 0x87)
                        }
                        Else
                        {
                            Notify (\_SB.PCI0.GFX0.DD04, 0x87)
                        }
                    }

                    Method (_Q10, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.LPCB.EC0.BLVL, Local0)
                        If (LLess (Local0, 0x07))
                        {
                            Increment (Local0)
                        }
                        Else
                        {
                            Store (0x07, Local0)
                        }

                        Store (Local0, \_SB.PCI0.LPCB.EC0.BLVL)
                        If (\_SB.PCI0.PEGA)
                        {
                            Notify (\_SB.PCI0.PEGP.VGA.LCD, 0x86)
                        }
                        Else
                        {
                            Notify (\_SB.PCI0.GFX0.DD04, 0x86)
                        }
                    }

                    Device (DAL1)
                    {
                        Name (_HID, EisaId ("PNP0C32"))
                        Name (_UID, 0x01)
                        Method (_STA, 0, NotSerialized)
                        {
                            If (LEqual (OSYS, 0x07D6))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Method (GHID, 0, NotSerialized)
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            And (\_SB.PCI0.LPCB.EC0.MBTB, 0x01, Local0)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            If (Local0)
                            {
                                Notify (\_SB.PCI0.LPCB.EC0.DAL1, 0x02)
                            }

                            Return (Buffer (0x01)
                            {
                                /* 0000 */    0x01
                            })
                        }
                    }

                    Device (DAL2)
                    {
                        Name (_HID, EisaId ("PNP0C32"))
                        Name (_UID, 0x02)
                        Method (_STA, 0, NotSerialized)
                        {
                            If (LEqual (OSYS, 0x07D6))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Method (GHID, 0, NotSerialized)
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            And (\_SB.PCI0.LPCB.EC0.MBTB, 0x02, Local0)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            If (Local0)
                            {
                                Notify (\_SB.PCI0.LPCB.EC0.DAL2, 0x02)
                            }

                            Return (Buffer (0x01)
                            {
                                /* 0000 */    0x02
                            })
                        }
                    }
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        IO (Decode16,
                            0x0081,             // Range Minimum
                            0x0081,             // Range Maximum
                            0x01,               // Alignment
                            0x11,               // Length
                            )
                        IO (Decode16,
                            0x0093,             // Range Minimum
                            0x0093,             // Range Maximum
                            0x01,               // Alignment
                            0x0D,               // Length
                            )
                        IO (Decode16,
                            0x00C0,             // Range Minimum
                            0x00C0,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        DMA (Compatibility, NotBusMaster, Transfer8_16, )
                            {4}
                    })
                }

                Device (HPET)
                {
                    Name (_HID, EisaId ("PNP0103"))
                    Name (_CID, 0x010CD041)
                    Name (BUF0, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0xFED00000,         // Address Base
                            0x00000400,         // Address Length
                            _Y16)
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LGreaterEqual (OSYS, 0x07D1))
                        {
                            If (HPAE)
                            {
                                Return (0x0F)
                            }
                        }
                        Else
                        {
                            If (HPAE)
                            {
                                Return (0x0B)
                            }
                        }

                        Return (0x00)
                    }

                    Method (_CRS, 0, Serialized)
                    {
                        If (HPAE)
                        {
                            CreateDWordField (BUF0, \_SB.PCI0.LPCB.HPET._Y16._BAS, HPT0)
                            If (LEqual (HPAS, 0x01))
                            {
                                Store (0xFED01000, HPT0)
                            }

                            If (LEqual (HPAS, 0x02))
                            {
                                Store (0xFED02000, HPT0)
                            }

                            If (LEqual (HPAS, 0x03))
                            {
                                Store (0xFED03000, HPT0)
                            }
                        }

                        Return (BUF0)
                    }
                }

                Device (IPIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0020,             // Range Minimum
                            0x0020,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0024,             // Range Minimum
                            0x0024,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0028,             // Range Minimum
                            0x0028,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x002C,             // Range Minimum
                            0x002C,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0030,             // Range Minimum
                            0x0030,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0034,             // Range Minimum
                            0x0034,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0038,             // Range Minimum
                            0x0038,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x003C,             // Range Minimum
                            0x003C,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A0,             // Range Minimum
                            0x00A0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A4,             // Range Minimum
                            0x00A4,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A8,             // Range Minimum
                            0x00A8,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00AC,             // Range Minimum
                            0x00AC,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00B0,             // Range Minimum
                            0x00B0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00B4,             // Range Minimum
                            0x00B4,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00B8,             // Range Minimum
                            0x00B8,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00BC,             // Range Minimum
                            0x00BC,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x04D0,             // Range Minimum
                            0x04D0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {2}
                    })
                }

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x00F0,             // Range Minimum
                            0x00F0,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {13}
                    })
                }

                Device (LDRC)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x02)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x002E,             // Range Minimum
                            0x002E,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0061,             // Range Minimum
                            0x0061,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0063,             // Range Minimum
                            0x0063,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0065,             // Range Minimum
                            0x0065,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0067,             // Range Minimum
                            0x0067,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0068,             // Range Minimum
                            0x006F,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0080,             // Range Minimum
                            0x0080,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0092,             // Range Minimum
                            0x0092,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x00B2,             // Range Minimum
                            0x00B2,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0680,             // Range Minimum
                            0x0680,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0800,             // Range Minimum
                            0x0800,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x1000,             // Range Minimum
                            0x1000,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x1180,             // Range Minimum
                            0x1180,             // Range Maximum
                            0x01,               // Alignment
                            0x40,               // Length
                            )
                        IO (Decode16,
                            0x1620,             // Range Minimum
                            0x1620,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x1640,             // Range Minimum
                            0x1640,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0xFE10,             // Range Minimum
                            0xFE10,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0xFE00,             // Range Minimum
                            0xFE00,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0070,             // Range Minimum
                            0x0070,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {8}
                    })
                }

                Device (TIMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0040,             // Range Minimum
                            0x0040,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x0050,             // Range Minimum
                            0x0050,             // Range Maximum
                            0x10,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {0}
                    })
                }

                Device (SIO)
                {
                    Name (_HID, EisaId ("PNP0A05"))
                    Mutex (MX00, 0x00)
                    OperationRegion (SMC1, SystemIO, 0x162E, 0x02)
                    Field (SMC1, ByteAcc, NoLock, Preserve)
                    {
                        I1K,    8, 
                        D1K,    8
                    }

                    IndexField (I1K, D1K, AnyAcc, Lock, WriteAsOnes)
                    {
                                AccessAs (ByteAcc, 0x00), 
                                Offset (0x01), 
                            ,   2, 
                        PPWR,   1, 
                        PMOD,   1, 
                                Offset (0x02), 
                            ,   3, 
                        APWR,   1, 
                            ,   1, 
                        PLLP,   1, 
                        IRPW,   1, 
                        BPWR,   1, 
                                Offset (0x04), 
                        PEMD,   2, 
                            ,   4, 
                        EPPT,   1, 
                                Offset (0x07), 
                            ,   4, 
                        PPAP,   1, 
                        BAPD,   1, 
                        AAPD,   1, 
                        FAPD,   1, 
                                Offset (0x0A), 
                            ,   4, 
                        CMOD,   2, 
                        MMOD,   2, 
                        CRXI,   1, 
                        CTXO,   1, 
                        CDUX,   1, 
                        CIRM,   3, 
                                Offset (0x0C), 
                        BRXI,   1, 
                        BTXO,   1, 
                        BDUX,   1, 
                        BMOD,   3, 
                        ASPD,   1, 
                        BSPD,   1, 
                                Offset (0x12), 
                        IADR,   8, 
                        ADR1,   8, 
                                Offset (0x18), 
                        CDMA,   4, 
                        CIRQ,   4, 
                                Offset (0x1F), 
                        CAD0,   8, 
                        CAD1,   6, 
                                Offset (0x22), 
                        ECPD,   3, 
                        ECPI,   3, 
                                Offset (0x23), 
                        PADR,   8, 
                        AADR,   8, 
                        BADR,   8, 
                        PDMA,   4, 
                                Offset (0x27), 
                        PIRQ,   4, 
                                Offset (0x28), 
                        AIRQ,   8, 
                                Offset (0x2B), 
                        FBAR,   8, 
                        IDMA,   8, 
                                Offset (0x30), 
                        RADR,   8, 
                        G10D,   1, 
                        G11D,   1, 
                        G12D,   1, 
                        G13D,   1, 
                        G14D,   1, 
                                Offset (0x32), 
                        G10P,   1, 
                        G11P,   1, 
                        G12P,   1, 
                        G13P,   1, 
                        G14P,   1, 
                                Offset (0x33), 
                            ,   3, 
                        G23O,   1, 
                            ,   3, 
                        GP12,   1, 
                            ,   3, 
                        GP23,   1, 
                            ,   1, 
                        IPME,   1, 
                        GP13,   1, 
                        GP14,   1, 
                        GP40,   1, 
                        GP41,   1, 
                        GP42,   1, 
                                Offset (0x37), 
                        G40D,   1, 
                        G41D,   1, 
                        G42D,   1, 
                        G43D,   1, 
                        G44D,   1, 
                        G45D,   1, 
                        G46D,   1, 
                        G47D,   1, 
                        G40P,   1, 
                        G41P,   1, 
                        G42P,   1, 
                        G43P,   1, 
                        G44P,   1, 
                        G45P,   1, 
                        G46P,   1, 
                        G47P,   1, 
                        G12O,   1, 
                        G13O,   1, 
                        G14O,   1, 
                            ,   4, 
                        PMEO,   1
                    }

                    Method (ENFG, 0, NotSerialized)
                    {
                        Acquire (MX00, 0xFFFF)
                        Store (0x55, I1K)
                    }

                    Method (EXFG, 0, NotSerialized)
                    {
                        Store (0xAA, I1K)
                        Release (MX00)
                    }

                    Method (RDRG, 1, NotSerialized)
                    {
                        ENFG ()
                        Store (Arg0, I1K)
                        Store (D1K, Local0)
                        EXFG ()
                        Return (Local0)
                    }

                    Method (WRRG, 2, NotSerialized)
                    {
                        ENFG ()
                        Store (Arg0, I1K)
                        Store (Arg1, D1K)
                        EXFG ()
                    }

                    Method (READ, 3, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x00))
                        {
                            Store (RDRG (Arg1), Local1)
                        }

                        And (Local1, Arg2, Local1)
                        Return (Local1)
                    }

                    Method (WRIT, 3, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x00))
                        {
                            WRRG (Arg1, Arg2)
                        }
                    }

                    Device (CIR)
                    {
                        Name (_HID, EisaId ("SMCB000"))
                        Name (_PRW, Package (0x02)
                        {
                            0x0B, 
                            0x05
                        })
                        Method (_STA, 0, NotSerialized)
                        {
                            ENFG ()
                            If (LNotEqual (CIRP, 0x00))
                            {
                                Store (0x40, CAD0)
                                Store (0x01, CAD1)
                                If (IRPW)
                                {
                                    EXFG ()
                                    Return (0x0F)
                                }
                                Else
                                {
                                    EXFG ()
                                    Return (0x0D)
                                }
                            }
                            Else
                            {
                                EXFG ()
                                Store (0x00, Local0)
                            }

                            If (LEqual (Local0, 0x00))
                            {
                                \_SB.PCI0.LPCB.SIO.CIR._DIS ()
                            }

                            Return (Local0)
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            ENFG ()
                            Store (READ (0x00, 0x02, 0xC8), Local0)
                            And (Local0, 0xBF, Local0)
                            WRIT (0x00, 0x02, Local0)
                            Store (0x00, CAD0)
                            Store (0x00, CAD1)
                            EXFG ()
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (RSRC, ResourceTemplate ()
                            {
                                IO (Decode16,
                                    0x0000,             // Range Minimum
                                    0x0000,             // Range Maximum
                                    0x08,               // Alignment
                                    0x08,               // Length
                                    _Y17)
                                IRQNoFlags (_Y18)
                                    {}
                            })
                            CreateByteField (RSRC, \_SB.PCI0.LPCB.SIO.CIR._CRS._Y17._MIN, IO1)
                            CreateByteField (RSRC, 0x03, IO2)
                            CreateByteField (RSRC, \_SB.PCI0.LPCB.SIO.CIR._CRS._Y17._MAX, IO3)
                            CreateByteField (RSRC, 0x05, IO4)
                            CreateWordField (RSRC, \_SB.PCI0.LPCB.SIO.CIR._CRS._Y18._INT, IRQV)
                            ENFG ()
                            Store (CAD0, Local0)
                            Store (CAD1, Local1)
                            ShiftLeft (Local1, 0x08, Local1)
                            Or (Local1, Local0, Local0)
                            ShiftLeft (Local0, 0x02, Local0)
                            And (Local0, 0xFF, IO1)
                            ShiftRight (Local0, 0x08, IO2)
                            And (Local0, 0xFF, IO3)
                            ShiftRight (Local0, 0x08, IO4)
                            Store (0x01, Local0)
                            ShiftLeft (Local0, CIRQ, IRQV)
                            EXFG ()
                            Return (RSRC)
                        }

                        Name (_PRS, ResourceTemplate ()
                        {
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16,
                                    0x0500,             // Range Minimum
                                    0x0500,             // Range Maximum
                                    0x08,               // Alignment
                                    0x08,               // Length
                                    )
                                IRQNoFlags ()
                                    {9}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16,
                                    0x0500,             // Range Minimum
                                    0x0500,             // Range Maximum
                                    0x08,               // Alignment
                                    0x08,               // Length
                                    )
                                IRQNoFlags ()
                                    {10}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16,
                                    0x0900,             // Range Minimum
                                    0x0900,             // Range Maximum
                                    0x08,               // Alignment
                                    0x08,               // Length
                                    )
                                IRQNoFlags ()
                                    {9}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16,
                                    0x0900,             // Range Minimum
                                    0x0900,             // Range Maximum
                                    0x08,               // Alignment
                                    0x08,               // Length
                                    )
                                IRQNoFlags ()
                                    {10}
                            }
                            EndDependentFn ()
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, IO1)
                            CreateByteField (Arg0, 0x03, IO2)
                            CreateWordField (Arg0, 0x09, IRQV)
                            ENFG ()
                            ShiftLeft (IO2, 0x08, Local0)
                            Or (IO1, Local0, Local0)
                            Store (Local0, Local1)
                            And (Local0, 0x03F8, Local0)
                            ShiftRight (Local0, 0x02, Local0)
                            Store (Local0, CAD0)
                            And (Local1, 0xFC00, Local1)
                            ShiftRight (Local1, 0x0A, Local1)
                            Store (Local1, CAD1)
                            FindSetRightBit (IRQV, Local0)
                            Subtract (Local0, 0x01, CIRQ)
                            Store (READ (0x00, 0x02, 0xC8), Local0)
                            Or (Local0, 0x40, Local0)
                            WRIT (0x00, 0x02, Local0)
                            EXFG ()
                        }
                    }
                }

                Device (PS2K)
                {
                    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 (PS2M)
                {
                    Name (_HID, EisaId ("SYN1010"))
                    Name (_CID, Package (0x03)
                    {
                        0x00102E4F, 
                        0x02002E4F, 
                        0x130FD041
                    })
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {12}
                    })
                }
            }

            Device (PATA)
            {
                Name (_ADR, 0x001F0001)
                OperationRegion (PACS, PCI_Config, 0x40, 0xC0)
                Field (PACS, DWordAcc, NoLock, Preserve)
                {
                    PRIT,   16, 
                            Offset (0x04), 
                    PSIT,   4, 
                            Offset (0x08), 
                    SYNC,   4, 
                            Offset (0x0A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                            Offset (0x14), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (Buffer (0x14)
                        {
                            /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
                            /* 0008 */    0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
                            /* 0010 */    0x1F, 0x00, 0x00, 0x00
                        })
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (PRIT, 0xC0F0, PRIT)
                            And (SYNC, 0x02, SYNC)
                            Store (0x00, SDT0)
                            And (ICR0, 0x02, ICR0)
                            And (ICR1, 0x02, ICR1)
                            And (ICR3, 0x02, ICR3)
                            And (ICR5, 0x02, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (PRIT, 0x8004, PRIT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (PRIT, 0x02, PRIT)
                            }

                            Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x01, SYNC)
                                Store (SDMA (DMA0), SDT0)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x01, ICR0)
                                }

                                If (And (W930, 0x2000))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                }
                            }
                        }

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (PRIT, 0xBF0F, PRIT)
                            Store (0x00, PSIT)
                            And (SYNC, 0x01, SYNC)
                            Store (0x00, SDT1)
                            And (ICR0, 0x01, ICR0)
                            And (ICR1, 0x01, ICR1)
                            And (ICR3, 0x01, ICR3)
                            And (ICR5, 0x01, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (PRIT, 0x8040, PRIT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (PRIT, 0x20, PRIT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (PRIT, 0x4000, PRIT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (PRIT, 0x80, PRIT)
                                }
                                Else
                                {
                                    Or (PRIT, 0x10, PRIT)
                                    Store (SETT (PIO1, W531, W641), PSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x02, SYNC)
                                Store (SDMA (DMA1), SDT1)
                                If (LLess (DMA1, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

                                If (LLess (DMA1, 0x3C))
                                {
                                    Or (ICR0, 0x02, ICR0)
                                }

                                If (And (W931, 0x2000))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                }
                            }
                        }
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB0, Buffer (0x0E)
                            {
                                /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            CreateByteField (PIB0, 0x01, PMD0)
                            CreateByteField (PIB0, 0x08, DMD0)
                            If (And (PRIT, 0x02))
                            {
                                If (LEqual (And (PRIT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                If (And (ICR1, 0x01))
                                {
                                    If (And (ICR0, 0x01))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x01))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            Return (PIB0)
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB1, Buffer (0x0E)
                            {
                                /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (PIB1, 0x01, PMD1)
                            CreateByteField (PIB1, 0x08, DMD1)
                            If (And (PRIT, 0x20))
                            {
                                If (LEqual (And (PRIT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (PSIT, 0x03), ShiftRight (And (PSIT, 0x0C), 
                                        0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SYNC, 0x02))
                            {
                                Store (Or (SDT1, 0x40), DMD1)
                                If (And (ICR1, 0x02))
                                {
                                    If (And (ICR0, 0x02))
                                    {
                                        Add (DMD1, 0x02, DMD1)
                                    }

                                    If (And (ICR3, 0x02))
                                    {
                                        Store (0x45, DMD1)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (PIB1)
                        }
                    }
                }
            }

            Device (SATA)
            {
                Name (_ADR, 0x001F0002)
                OperationRegion (SACS, PCI_Config, 0x40, 0xC0)
                Field (SACS, DWordAcc, NoLock, Preserve)
                {
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                            Offset (0x08), 
                    SYNC,   4, 
                            Offset (0x0A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                            Offset (0x0B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                            Offset (0x14), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4, 
                            Offset (0x50), 
                    MAPV,   2
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (Buffer (0x14)
                        {
                            /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
                            /* 0008 */    0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
                            /* 0010 */    0x1F, 0x00, 0x00, 0x00
                        })
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (PRIT, 0xC0F0, PRIT)
                            And (SYNC, 0x0E, SYNC)
                            Store (0x00, SDT0)
                            And (ICR0, 0x0E, ICR0)
                            And (ICR1, 0x0E, ICR1)
                            And (ICR3, 0x0E, ICR3)
                            And (ICR5, 0x0E, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (PRIT, 0x8004, PRIT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (PRIT, 0x02, PRIT)
                            }

                            Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x01, SYNC)
                                Store (SDMA (DMA0), SDT0)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x01, ICR0)
                                }

                                Or (ICR1, 0x01, ICR1)
                            }
                        }

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (PRIT, 0xBF0F, PRIT)
                            Store (0x00, PSIT)
                            And (SYNC, 0x0D, SYNC)
                            Store (0x00, SDT1)
                            And (ICR0, 0x0D, ICR0)
                            And (ICR1, 0x0D, ICR1)
                            And (ICR3, 0x0D, ICR3)
                            And (ICR5, 0x0D, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (PRIT, 0x8040, PRIT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (PRIT, 0x20, PRIT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (PRIT, 0x4000, PRIT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (PRIT, 0x80, PRIT)
                                }
                                Else
                                {
                                    Or (PRIT, 0x10, PRIT)
                                    Store (SETT (PIO1, W531, W641), PSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x02, SYNC)
                                Store (SDMA (DMA1), SDT1)
                                If (LLess (DMA1, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

                                If (LLess (DMA1, 0x3C))
                                {
                                    Or (ICR0, 0x02, ICR0)
                                }

                                Or (ICR1, 0x02, ICR1)
                            }
                        }
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB0, Buffer (0x0E)
                            {
                                /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            CreateByteField (PIB0, 0x01, PMD0)
                            CreateByteField (PIB0, 0x08, DMD0)
                            If (And (PRIT, 0x02))
                            {
                                If (LEqual (And (PRIT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                If (And (ICR1, 0x01))
                                {
                                    If (And (ICR0, 0x01))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x01))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            Return (PIB0)
                        }
                    }
                }
            }

            Device (SBUS)
            {
                Name (_ADR, 0x001F0003)
                OperationRegion (SMBP, PCI_Config, 0x40, 0xC0)
                Field (SMBP, DWordAcc, NoLock, Preserve)
                {
                        ,   2, 
                    I2CE,   1
                }

                OperationRegion (SMBI, SystemIO, 0x18C0, 0x10)
                Field (SMBI, ByteAcc, NoLock, Preserve)
                {
                    HSTS,   8, 
                            Offset (0x02), 
                    HCON,   8, 
                    HCOM,   8, 
                    TXSA,   8, 
                    DAT0,   8, 
                    DAT1,   8, 
                    HBDR,   8, 
                    PECR,   8, 
                    RXSA,   8, 
                    SDAT,   16
                }

                Method (SSXB, 2, Serialized)
                {
                    If (STRT ())
                    {
                        Return (0x00)
                    }

                    Store (0x00, I2CE)
                    Store (0xBF, HSTS)
                    Store (Arg0, TXSA)
                    Store (Arg1, HCOM)
                    Store (0x48, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (0x01)
                    }

                    Return (0x00)
                }

                Method (SRXB, 1, Serialized)
                {
                    If (STRT ())
                    {
                        Return (0xFFFF)
                    }

                    Store (0x00, I2CE)
                    Store (0xBF, HSTS)
                    Store (Or (Arg0, 0x01), TXSA)
                    Store (0x44, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (DAT0)
                    }

                    Return (0xFFFF)
                }

                Method (SWRB, 3, Serialized)
                {
                    If (STRT ())
                    {
                        Return (0x00)
                    }

                    Store (0x00, I2CE)
                    Store (0xBF, HSTS)
                    Store (Arg0, TXSA)
                    Store (Arg1, HCOM)
                    Store (Arg2, DAT0)
                    Store (0x48, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (0x01)
                    }

                    Return (0x00)
                }

                Method (SRDB, 2, Serialized)
                {
                    If (STRT ())
                    {
                        Return (0xFFFF)
                    }

                    Store (0x00, I2CE)
                    Store (0xBF, HSTS)
                    Store (Or (Arg0, 0x01), TXSA)
                    Store (Arg1, HCOM)
                    Store (0x48, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (DAT0)
                    }

                    Return (0xFFFF)
                }

                Method (SBLW, 4, Serialized)
                {
                    If (STRT ())
                    {
                        Return (0x00)
                    }

                    Store (Arg3, I2CE)
                    Store (0xBF, HSTS)
                    Store (Arg0, TXSA)
                    Store (Arg1, HCOM)
                    Store (SizeOf (Arg2), DAT0)
                    Store (0x00, Local1)
                    Store (DerefOf (Index (Arg2, 0x00)), HBDR)
                    Store (0x54, HCON)
                    While (LGreater (SizeOf (Arg2), Local1))
                    {
                        Store (0x0FA0, Local0)
                        While (LAnd (LNot (And (HSTS, 0x80)), Local0))
                        {
                            Decrement (Local0)
                            Stall (0x32)
                        }

                        If (LNot (Local0))
                        {
                            KILL ()
                            Return (0x00)
                        }

                        Store (0x80, HSTS)
                        Increment (Local1)
                        If (LGreater (SizeOf (Arg2), Local1))
                        {
                            Store (DerefOf (Index (Arg2, Local1)), HBDR)
                        }
                    }

                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (0x01)
                    }

                    Return (0x00)
                }

                Method (SBLR, 3, Serialized)
                {
                    Name (TBUF, Buffer (0x0100) {})
                    If (STRT ())
                    {
                        Return (0x00)
                    }

                    Store (Arg2, I2CE)
                    Store (0xBF, HSTS)
                    Store (Or (Arg0, 0x01), TXSA)
                    Store (Arg1, HCOM)
                    Store (0x54, HCON)
                    Store (0x0FA0, Local0)
                    While (LAnd (LNot (And (HSTS, 0x80)), Local0))
                    {
                        Decrement (Local0)
                        Stall (0x32)
                    }

                    If (LNot (Local0))
                    {
                        KILL ()
                        Return (0x00)
                    }

                    Store (DAT0, Index (TBUF, 0x00))
                    Store (0x80, HSTS)
                    Store (0x01, Local1)
                    While (LLess (Local1, DerefOf (Index (TBUF, 0x00))))
                    {
                        Store (0x0FA0, Local0)
                        While (LAnd (LNot (And (HSTS, 0x80)), Local0))
                        {
                            Decrement (Local0)
                            Stall (0x32)
                        }

                        If (LNot (Local0))
                        {
                            KILL ()
                            Return (0x00)
                        }

                        Store (HBDR, Index (TBUF, Local1))
                        Store (0x80, HSTS)
                        Increment (Local1)
                    }

                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (TBUF)
                    }

                    Return (0x00)
                }

                Method (STRT, 0, Serialized)
                {
                    Store (0xC8, Local0)
                    While (Local0)
                    {
                        If (And (HSTS, 0x40))
                        {
                            Decrement (Local0)
                            Sleep (0x01)
                            If (LEqual (Local0, 0x00))
                            {
                                Return (0x01)
                            }
                        }
                        Else
                        {
                            Store (0x00, Local0)
                        }
                    }

                    Store (0x0FA0, Local0)
                    While (Local0)
                    {
                        If (And (HSTS, 0x01))
                        {
                            Decrement (Local0)
                            Stall (0x32)
                            If (LEqual (Local0, 0x00))
                            {
                                KILL ()
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Return (0x01)
                }

                Method (COMP, 0, Serialized)
                {
                    Store (0x0FA0, Local0)
                    While (Local0)
                    {
                        If (And (HSTS, 0x02))
                        {
                            Return (0x01)
                        }
                        Else
                        {
                            Decrement (Local0)
                            Stall (0x32)
                            If (LEqual (Local0, 0x00))
                            {
                                KILL ()
                            }
                        }
                    }

                    Return (0x00)
                }

                Method (KILL, 0, Serialized)
                {
                    Or (HCON, 0x02, HCON)
                    Or (HSTS, 0xFF, HSTS)
                }
            }
        }

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

        OperationRegion (SMI1, SystemMemory, 0x3FE9CC2D, 0x00000320)
        Field (SMI1, AnyAcc, NoLock, Preserve)
        {
            BCMD,   8, 
            DID,    32, 
            INF,    8
        }

        Field (SMI1, AnyAcc, NoLock, Preserve)
        {
                    Offset (0x110), 
            BTEN,   1, 
            WLAN,   1, 
            CIRE,   1, 
            ENSR,   2, 
                    Offset (0x120), 
            OWNS,   4096
        }

        Mutex (PSMX, 0x00)
        Method (PHSR, 2, NotSerialized)
        {
            Acquire (\_SB.PSMX, 0xFFFF)
            Store (0x90, BCMD)
            Store (Arg0, DID)
            Store (Arg1, INF)
            Store (Zero, SMIC)
            Store (INF, Local0)
            Release (\_SB.PSMX)
            Return (Local0)
        }

        Device (ACAD)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (ACST, 0x00)
            Method (_PSR, 0, NotSerialized)
            {
                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.ACDF, ACST)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                }
                Else
                {
                    Store (0x01, ACST)
                }

                If (ACST)
                {
                    Store (0x01, Local0)
                    Store (0x00, \_SB.BAT1.BCRI)
                }
                Else
                {
                    Store (0x00, Local0)
                }

                Return (Local0)
            }
        }

        Device (BAT1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x01)
            Name (CBTI, 0x00)
            Name (PBTI, 0x00)
            Name (BTIN, 0x00)
            Name (BTCH, 0x00)
            Name (BIFI, 0x00)
            Name (SEL0, 0x00)
            Name (BCRI, 0x00)
            Name (PBIF, Package (0x0D)
            {
                0x01, 
                0x1130, 
                0x1130, 
                0x01, 
                0x2B5C, 
                0x012C, 
                0x3C, 
                0x20, 
                0x20, 
                "PA3480U-1BRS", 
                "11        ", 
                "11        ", 
                "TOSHIBA   "
            })
            Name (PBST, Package (0x04)
            {
                0x00, 
                Z002, 
                Z002, 
                0x2710
            })
            Name (ERRC, 0x00)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (_STA, 0, NotSerialized)
            {
                If (BTIN)
                {
                    Return (0x1F)
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Method (_BIF, 0, NotSerialized)
            {
                If (LEqual (BIFI, 0x00))
                {
                    \_SB.BAT1.UBIF ()
                    Store (0x01, BIFI)
                }

                Return (PBIF)
            }

            Name (LFCC, 0x1130)
            Method (UBIF, 0, NotSerialized)
            {
                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.BTDC, Local0)
                    Store (\_SB.PCI0.LPCB.EC0.LFCC, Local1)
                    Store (\_SB.PCI0.LPCB.EC0.BTDV, Local2)
                    Store (\_SB.PCI0.LPCB.EC0.BTMD, Local3)
                    Store (\_SB.PCI0.LPCB.EC0.BTMN, Local4)
                    Store (\_SB.PCI0.LPCB.EC0.BTSN, Local5)
                    Store (\_SB.PCI0.LPCB.EC0.LION, Local6)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Store (Local0, Index (PBIF, 0x01))
                    Store (Local1, Index (PBIF, 0x02))
                    Store (Local2, Index (PBIF, 0x04))
                    Store (Local1, LFCC)
                    If (Local6)
                    {
                        Store ("NiMH", Index (PBIF, 0x0B))
                    }
                    Else
                    {
                        Store ("LION", Index (PBIF, 0x0B))
                    }

                    And (Local3, 0x0F, Local3)
                    If (LEqual (Local3, 0x01))
                    {
                        Store ("PA3480U-1BAS", Index (PBIF, 0x09))
                    }
                    Else
                    {
                        If (LEqual (Local3, 0x02))
                        {
                            Store ("PA3479U-1BAS", Index (PBIF, 0x09))
                        }
                        Else
                        {
                            If (LEqual (Local3, 0x03))
                            {
                                Store ("PA3480U-1BRS", Index (PBIF, 0x09))
                            }
                            Else
                            {
                                If (LEqual (Local3, 0x04))
                                {
                                    Store ("PA3479U-1BRS", Index (PBIF, 0x09))
                                }
                            }
                        }
                    }

                    Store (ITOS (ToBCD (Local5)), Index (PBIF, 0x0A))
                }
            }

            Name (RCAP, 0x00)
            Method (_BST, 0, NotSerialized)
            {
                If (LEqual (BTIN, 0x00))
                {
                    Store (0x00, Index (PBST, 0x00))
                    Store (0xFFFFFFFF, Index (PBST, 0x01))
                    Store (0xFFFFFFFF, Index (PBST, 0x02))
                    Store (0xFFFFFFFF, Index (PBST, 0x03))
                    Return (PBST)
                }

                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.MBTC, Local0)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Sleep (0x32)
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.MBRM, Local1)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Sleep (0x32)
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.MBVG, Local2)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Sleep (0x32)
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.MCUR, Local3)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Sleep (0x32)
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.BTST, Local4)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Sleep (0x32)
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.MBTF, Local5)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Sleep (0x32)
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.ACDF, Local6)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Sleep (0x32)
                    If (Local6)
                    {
                        If (LEqual (Local5, 0x01))
                        {
                            Store (0x00, Local7)
                            Store (LFCC, Local1)
                        }
                        Else
                        {
                            If (LEqual (Local0, 0x01))
                            {
                                Store (0x02, Local7)
                            }
                            Else
                            {
                                Store (0x00, Local7)
                            }
                        }
                    }
                    Else
                    {
                        If (LAnd (Local4, 0x01))
                        {
                            Store (0x01, Local7)
                        }
                        Else
                        {
                            Store (0x00, Local7)
                        }
                    }

                    And (Local4, 0x04, Local4)
                    If (LEqual (Local4, 0x04))
                    {
                        Or (Local7, Local4, Local7)
                    }

                    Store (Local7, Index (PBST, 0x00))
                    If (LNot (And (Local1, 0x8000)))
                    {
                        Store (Local1, Index (PBST, 0x02))
                    }

                    If (LNot (And (Local2, 0x8000)))
                    {
                        Store (Local2, Index (PBST, 0x03))
                    }

                    If (LAnd (Local3, 0x8000))
                    {
                        If (LNotEqual (Local3, 0xFFFF))
                        {
                            Not (Local3, Local3)
                            Increment (Local3)
                            And (Local3, 0xFFFF, Local3)
                        }
                    }

                    Store (Local3, Index (PBST, 0x01))
                }

                Return (PBST)
            }

            Method (BSTA, 0, NotSerialized)
            {
                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.MBTS, Local0)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    If (LEqual (Local0, 0x01))
                    {
                        If (LEqual (\_SB.BAT1.BTIN, 0x00))
                        {
                            Store (0x01, \_SB.BAT1.BTCH)
                            Store (0x00, \_SB.BAT1.BIFI)
                        }

                        Store (0x01, \_SB.BAT1.BTIN)
                    }
                    Else
                    {
                        If (LEqual (\_SB.BAT1.BTIN, 0x01))
                        {
                            Store (0x01, \_SB.BAT1.BTCH)
                            Store (0x00, \_SB.BAT1.BIFI)
                        }

                        Store (0x00, \_SB.BAT1.BTIN)
                    }
                }
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Name (LSTS, 0x00)
            Method (_LID, 0, NotSerialized)
            {
                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    If (\_SB.PCI0.LPCB.EC0.LIDS)
                    {
                        Store (Zero, LSTS)
                    }
                    Else
                    {
                        Store (One, LSTS)
                    }

                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                }
                Else
                {
                    Store (One, LSTS)
                }

                Return (LSTS)
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
        }

        Device (BT)
        {
            Name (_HID, EisaId ("TOS6205"))
            Method (_STA, 0, NotSerialized)
            {
                If (BTEN)
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (DUSB, 0, NotSerialized)
            {
                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (Zero, \_SB.PCI0.LPCB.EC0.BLTH)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                }
            }

            Method (AUSB, 0, NotSerialized)
            {
                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (One, \_SB.PCI0.LPCB.EC0.BLTH)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                }
            }

            Method (BTPO, 0, NotSerialized)
            {
                \_SB.PHSR (0x0C, 0x25)
            }

            Method (BTPF, 0, NotSerialized)
            {
                \_SB.PHSR (0x0C, 0x26)
            }

            Method (BTST, 0, NotSerialized)
            {
                If (\_SB.ECOK)
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.KSWH, Local0)
                    XOr (Local0, 0x01, Local0)
                    Store (\_SB.PCI0.LPCB.EC0.BTHE, Local7)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    If (Local0)
                    {
                        ShiftLeft (Local7, 0x06, Local6)
                        ShiftLeft (Local7, 0x07, Local7)
                        Or (Local7, Local6, Local1)
                        Or (Local0, Local1, Local2)
                        Return (Local2)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }
		Else
		    {
		    	Return (Zero)
		    }	
		
		}
        }

        Device (VALZ)
        {
            Name (_HID, EisaId ("TOS1900"))
            Method (_STA, 0, NotSerialized)
            {
                If (LEqual (OSYS, 0x07D6))
                {
                    Return (0x0B)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Name (_DDN, "VALZeneral")
            Name (VZOK, 0x00)
            Name (VBFG, 0x0A)
            Method (ENAB, 0, NotSerialized)
            {
                Store (0x01, VZOK)
            }

            Method (EVNT, 1, NotSerialized)
            {
                While (VZOK)
                {
                    If (LEqual (VZOK, 0x01))
                    {
                        Store (Arg0, VZOK)
                        Notify (\_SB.VALZ, 0x80)
                        Return (Zero)
                    }
                    Else
                    {
                        Sleep (0x05)
			Return (Zero)
                    }
                }
            }

            Method (INFO, 0, Serialized)
            {
                If (LEqual (VZOK, 0x02))
                {
                    Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                    Store (\_SB.PCI0.LPCB.EC0.VEVT, Local0)
                    Release (\_SB.PCI0.LPCB.EC0.MUT1)
                    Store (0x01, VZOK)
                    Return (Local0)
                }
                Else
                {
                    If (LEqual (VZOK, 0x03))
                    {
                        Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                        Store (\_SB.PCI0.LPCB.EC0.FEVT, Local0)
                        Release (\_SB.PCI0.LPCB.EC0.MUT1)
                        Store (0x01, VZOK)
                        Return (Local0)
                    }
                    Else
                    {
                        If (LEqual (VZOK, 0x04))
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            Store (\_SB.PCI0.LPCB.EC0.NEVT, Local0)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            Store (0x01, VZOK)
                            Return (Local0)
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }
                }
            }

            Name (VALI, Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFFFF, 
                0xFFFF, 
                0xFFFF, 
                0xFFFF
            })
            Name (VALO, Package (0x06)
            {
                0x00, 
                0x00, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (GWFS, Package (0x06)
            {
                0xFE00, 
                0x56, 
                0x00, 
                0x01, 
                0x00, 
                0x00
            })
            Name (SWRN, Package (0x06)
            {
                0xFF00, 
                0x56, 
                0x01, 
                0x0200, 
                0x00, 
                0x00
            })
            Name (SWRF, Package (0x06)
            {
                0xFF00, 
                0x56, 
                0x00, 
                0x0200, 
                0x00, 
                0x00
            })
            Name (GTPS, Package (0x06)
            {
                0xF300, 
                0x050E, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (STPD, Package (0x06)
            {
                0xF400, 
                0x050E, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (STPE, Package (0x06)
            {
                0xF400, 
                0x050E, 
                0x01, 
                0x00, 
                0x00, 
                0x00
            })
            Name (FNDS, Package (0x06)
            {
                0xFF00, 
                0x5A, 
                0x00, 
                0x01, 
                0x00, 
                0x00
            })
            Name (FNTP, Package (0x06)
            {
                0xFF00, 
                0x5A, 
                0x01, 
                0x01, 
                0x00, 
                0x00
            })
            Name (FNTC, Package (0x06)
            {
                0xFF00, 
                0x5A, 
                0x02, 
                0x01, 
                0x00, 
                0x00
            })
            Name (GCCM, Package (0x06)
            {
                0xFE00, 
                0x7F, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SCMP, Package (0x06)
            {
                0xFF00, 
                0x7F, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SCMS, Package (0x06)
            {
                0xFF00, 
                0x7F, 
                0x01, 
                0x00, 
                0x00, 
                0x00
            })
            Name (CESS, Package (0x06)
            {
                0xFE00, 
                0x62, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (GPNL, Package (0x06)
            {
                0xFE00, 
                0x11, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SHK0, Package (0x06)
            {
                0xFF00, 
                0xC000, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SHK1, Package (0x06)
            {
                0xFF00, 
                0xC000, 
                0x00, 
                0x01, 
                0x00, 
                0x00
            })
            Name (GHKM, Package (0x06)
            {
                0xFE00, 
                0xC000, 
                0x03, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SBED, Package (0x06)
            {
                0xFF00, 
                0x1E, 
                0x01, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SBEE, Package (0x06)
            {
                0xFF00, 
                0x1E, 
                0x03, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SHEE, Package (0x06)
            {
                0xFF00, 
                0x1E, 
                0x09, 
                0x00, 
                0x00, 
                0x00
            })
            Name (SBHE, Package (0x06)
            {
                0xFF00, 
                0x1E, 
                0x0B, 
                0x00, 
                0x00, 
                0x00
            })
            Name (GBEM, Package (0x06)
            {
                0xFE00, 
                0x1E, 
                0x00, 
                0x00, 
                0x00, 
                0x00
            })
            Method (MTCH, 2, NotSerialized)
            {
                If (LNotEqual (DerefOf (Index (Arg0, 0x00)), DerefOf (Index (
                    Arg1, 0x00))))
                {
                    Return (Zero)
                }

                If (LNotEqual (DerefOf (Index (Arg0, 0x01)), DerefOf (Index (
                    Arg1, 0x01))))
                {
                    Return (Zero)
                }

                If (LNotEqual (DerefOf (Index (Arg0, 0x02)), DerefOf (Index (
                    Arg1, 0x02))))
                {
                    Return (Zero)
                }

                If (LNotEqual (DerefOf (Index (Arg0, 0x03)), DerefOf (Index (
                    Arg1, 0x03))))
                {
                    Return (Zero)
                }

                If (LNotEqual (DerefOf (Index (Arg0, 0x04)), DerefOf (Index (
                    Arg1, 0x04))))
                {
                    Return (Zero)
                }

                If (LNotEqual (DerefOf (Index (Arg0, 0x05)), DerefOf (Index (
                    Arg1, 0x05))))
                {
                    Return (Zero)
                }

                Return (One)
            }

            Method (SPFC, 6, Serialized)
            {
                Store (ToInteger (Arg0), Index (VALI, 0x00))
                Store (ToInteger (Arg1), Index (VALI, 0x01))
                Store (ToInteger (Arg2), Index (VALI, 0x02))
                Store (ToInteger (Arg3), Index (VALI, 0x03))
                Store (ToInteger (Arg4), Index (VALI, 0x04))
                Store (ToInteger (Arg5), Index (VALI, 0x05))
                Store (Zero, Index (VALO, 0x01))
                Store (Zero, Index (VALO, 0x02))
                Store (Zero, Index (VALO, 0x03))
                Store (Zero, Index (VALO, 0x04))
                Store (Zero, Index (VALO, 0x05))
                While (One)
                {
                    Name (k0, 0x00)
                    Store (ToInteger (Arg1), k0)
                    If (LEqual (k0, 0x56))
                    {
                        If (MTCH (VALI, GWFS))
                        {
                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                            Store (\_SB.PCI0.LPCB.EC0.KSWH, Local0)
                            XOr (Local0, 0x01, Local0)
                            Store (\_SB.PCI0.LPCB.EC0.RFST, Local1)
                            ShiftLeft (Local1, 0x09, Local1)
                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                            If (Local0)
                            {
                                Or (Local0, Local1, Local0)
                            }

                            Store (Local0, Index (VALO, 0x02))
                            Store (Zero, Index (VALO, 0x00))
                        }
                        Else
                        {
                            If (MTCH (VALI, SWRN))
                            {
                                \_SB.PHSR (0x0C, 0x23)
                                Store (Zero, Index (VALO, 0x00))
                            }
                            Else
                            {
                                If (MTCH (VALI, SWRF))
                                {
                                    \_SB.PHSR (0x0C, 0x24)
                                    Store (Zero, Index (VALO, 0x00))
                                }
                                Else
                                {
                                    Store (0x8000, Index (VALO, 0x00))
                                }
                            }
                        }
                    }
                    Else
                    {
                        If (LEqual (k0, 0x050E))
                        {
                            If (MTCH (VALI, GTPS))
                            {
                                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                Store (\_SB.PCI0.LPCB.EC0.TPAD, Local0)
                                XOr (Local0, 0x01, Local0)
                                Release (\_SB.PCI0.LPCB.EC0.MUT1)
                                Store (Local0, Index (VALO, 0x02))
                                Store (Zero, Index (VALO, 0x00))
                            }
                            Else
                            {
                                If (MTCH (VALI, STPE))
                                {
                                    \_SB.PHSR (0x0C, 0x5A)
                                    Store (Zero, Index (VALO, 0x00))
                                }
                                Else
                                {
                                    If (MTCH (VALI, STPD))
                                    {
                                        \_SB.PHSR (0x0C, 0x5B)
                                        Store (Zero, Index (VALO, 0x00))
                                    }
                                    Else
                                    {
                                        Store (0x8000, Index (VALO, 0x00))
                                    }
                                }
                            }
                        }
                        Else
                        {
                            If (LEqual (k0, 0x5A))
                            {
                                If (MTCH (VALI, FNDS))
                                {
                                    \_SB.PHSR (0x0E, 0x00)
                                    Store (Zero, Index (VALO, 0x00))
                                }
                                Else
                                {
                                    If (MTCH (VALI, FNTP))
                                    {
                                        \_SB.PHSR (0x0E, 0x01)
                                        Store (Zero, Index (VALO, 0x00))
                                    }
                                    Else
                                    {
                                        If (MTCH (VALI, FNTC))
                                        {
                                            \_SB.PHSR (0x0E, 0x02)
                                            Store (Zero, Index (VALO, 0x00))
                                        }
                                        Else
                                        {
                                            Store (0x8000, Index (VALO, 0x00))
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                If (LEqual (k0, 0x7F))
                                {
                                    If (MTCH (VALI, GCCM))
                                    {
                                        Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                        Store (\_SB.PCI0.LPCB.EC0.TMOD, Local0)
                                        Release (\_SB.PCI0.LPCB.EC0.MUT1)
                                        Store (Local0, Index (VALO, 0x02))
                                        Store (0x01, Index (VALO, 0x03))
                                        Store (Zero, Index (VALO, 0x00))
                                    }
                                    Else
                                    {
                                        If (MTCH (VALI, SCMP))
                                        {
                                            Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                            Store (0x00, \_SB.PCI0.LPCB.EC0.TMOD)
                                            Release (\_SB.PCI0.LPCB.EC0.MUT1)
                                            \_SB.PHSR (0x0B, 0x00)
                                            Store (Zero, Index (VALO, 0x00))
                                        }
                                        Else
                                        {
                                            If (MTCH (VALI, SCMS))
                                            {
                                                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                                                Store (0x01, \_SB.PCI0.LPCB.EC0.TMOD)
                                                Release (\_SB.PCI0.LPCB.EC0.MUT1)
                                                \_SB.PHSR (0x0B, 0x01)
                                                Store (Zero, Index (VALO, 0x00))
                                            }
                                            Else
                                            {
                                                Store (0x8000, Index (VALO, 0x00))
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x62))
                                    {
                                        If (MTCH (VALI, CESS))
                                        {
                                            If (LEqual (\_SB.ENSR, 0x02))
                                            {
                                                Store (0x21, Index (VALO, 0x03))
                                            }
                                            Else
                                            {
                                                Store (Zero, Index (VALO, 0x03))
                                            }

                                            Store (Zero, Index (VALO, 0x00))
                                        }
                                        Else
                                        {
                                            Store (0x8000, Index (VALO, 0x00))
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x11))
                                        {
                                            If (MTCH (VALI, GPNL))
                                            {
                                                Store (PNLT, Index (VALO, 0x02))
                                                Store (Zero, Index (VALO, 0x00))
                                            }
                                            Else
                                            {
                                                Store (0x8000, Index (VALO, 0x00))
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0xC000))
                                            {
                                                If (MTCH (VALI, SHK0))
                                                {
                                                    Store (Zero, Index (VALO, 0x00))
                                                }
                                                Else
                                                {
                                                    If (MTCH (VALI, SHK1))
                                                    {
                                                        Store (Zero, Index (VALO, 0x00))
                                                    }
                                                    Else
                                                    {
                                                        If (MTCH (VALI, GHKM))
                                                        {
                                                            Store (Zero, Index (VALO, 0x03))
                                                            Store (Zero, Index (VALO, 0x00))
                                                        }
                                                        Else
                                                        {
                                                            Store (0x8000, Index (VALO, 0x00))
                                                        }
                                                    }
                                                }
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x1E))
                                                {
                                                    If (MTCH (VALI, SBED))
                                                    {
                                                        Store (0x00, VBFG)
                                                        \_SB.PHSR (0x0A, 0xC0)
                                                        Store (Zero, Index (VALO, 0x00))
                                                    }
                                                    Else
                                                    {
                                                        If (MTCH (VALI, SBEE))
                                                        {
                                                            Store (0x02, VBFG)
                                                            \_SB.PHSR (0x0A, 0x40)
                                                            Store (Zero, Index (VALO, 0x00))
                                                        }
                                                        Else
                                                        {
                                                            If (MTCH (VALI, SHEE))
                                                            {
                                                                Store (0x08, VBFG)
                                                                \_SB.PHSR (0x0A, 0x80)
                                                                Store (Zero, Index (VALO, 0x00))
                                                            }
                                                            Else
                                                            {
                                                                If (MTCH (VALI, SBHE))
                                                                {
                                                                    Store (0x0A, VBFG)
                                                                    \_SB.PHSR (0x0A, 0x00)
                                                                    Store (Zero, Index (VALO, 0x00))
                                                                }
                                                                Else
                                                                {
                                                                    If (MTCH (VALI, GBEM))
                                                                    {
                                                                        Store (VBFG, Local0)
                                                                        Store (Increment (Local0), Index (VALO, 0x02))
                                                                        Store (Zero, Index (VALO, 0x00))
                                                                    }
                                                                    Else
                                                                    {
                                                                        Store (0x8000, Index (VALO, 0x00))
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                Else
                                                {
                                                    Store (0x8000, Index (VALO, 0x00))
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Break
                }

                Return (VALO)
            }
        }

        Device (AMW0)
        {
            Name (_HID, "PNP0C14")
            Name (_UID, 0x00)
            Method (_STA, 0, NotSerialized)
            {
                If (LEqual (OSYS, 0x07D6))
                {
                    Return (Zero)
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Name (_WDG, Buffer (0x3C)
            {
                /* 0000 */    0xA7, 0x1D, 0x85, 0x2E, 0x53, 0xD0, 0x5F, 0x49, 
                /* 0008 */    0x9D, 0xFA, 0x1A, 0x4A, 0xD6, 0x2E, 0x6A, 0x86, 
                /* 0010 */    0x41, 0x43, 0x01, 0x00, 0x3B, 0x6D, 0x43, 0x71, 
                /* 0018 */    0xDD, 0xFB, 0x72, 0x4C, 0xBC, 0xB8, 0x43, 0x5B, 
                /* 0020 */    0xFE, 0x0D, 0x64, 0xF9, 0x42, 0x43, 0x01, 0x00, 
                /* 0028 */    0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, 
                /* 0030 */    0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, 
                /* 0038 */    0x42, 0x41, 0x01, 0x00
            })
            Name (STAC, Buffer (0x04)
            {
                /* 0000 */    0x01, 0x32, 0x05, 0x00
            })
            Method (WQAC, 1, NotSerialized)
            {
                Store ("MXMTCConfigData", Debug)
                Return (STAC)
            }

            Name (STBC, Buffer (0x04)
            {
                /* 0000 */    0x01, 0x00, 0x00, 0x00
            })
            Method (WQBC, 1, NotSerialized)
            {
                Store ("Get MXMTCControlData: STBC = ", Debug)
                Store (STBC, Debug)
                Return (STBC)
            }

            Method (WSBC, 2, NotSerialized)
            {
                Store (Arg1, STBC)
                Store ("Set MXMTCControlData: STBC = ", Debug)
                Store (STBC, Debug)
                Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                Store (DerefOf (Index (STBC, 0x01)), \_SB.PCI0.LPCB.EC0.VTMP)
                Release (\_SB.PCI0.LPCB.EC0.MUT1)
            }

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

        Scope (\_SB)
        {
            Device (QWMI)
            {
                Name (_HID, "PNP0C14")
                Name (_UID, 0x01)
                Method (PHSR, 2, NotSerialized)
                {
                    Acquire (\_SB.PSMX, 0xFFFF)
                    Store (0x91, BCMD)
                    Store (Arg0, DID)
                    Store (Arg1, INF)
                    Store (Zero, SMIC)
                    Store (DID, Local0)
                    Release (\_SB.PSMX)
                    Return (Local0)
                }

                Name (_WDG, Buffer (0x3C)
                {
                    /* 0000 */    0x69, 0xA4, 0x2B, 0xC6, 0x2C, 0x69, 0x4C, 0x4A, 
                    /* 0008 */    0x98, 0x69, 0x31, 0xB8, 0x3E, 0x0C, 0x76, 0x71, 
                    /* 0010 */    0x41, 0x41, 0x01, 0x00, 0x76, 0xF0, 0x58, 0x15, 
                    /* 0018 */    0x69, 0x3C, 0xDB, 0x4C, 0x80, 0xA5, 0xD2, 0xF3, 
                    /* 0020 */    0x9C, 0x62, 0x94, 0x9B, 0x41, 0x42, 0x01, 0x00, 
                    /* 0028 */    0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, 
                    /* 0030 */    0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, 
                    /* 0038 */    0x42, 0x41, 0x01, 0x00
                })
                Name (FCOD, 0x00)
                Name (RCOD, 0x00)
                Name (SFAI, 0x00)
                Name (SFLG, 0x00)
                Name (UFAI, 0x00)
                Name (UFLG, 0x00)
                Name (QBUF, Buffer (0x0201)
                {
                    /* 0000 */    0x00
                })
                CreateField (QBUF, 0x00, 0x08, Q000)
                CreateField (QBUF, 0x08, 0x08, Q001)
                CreateField (QBUF, 0x00, 0x1000, Q512)
                CreateField (QBUF, 0x1000, 0x08, QZZZ)
                CreateField (QBUF, 0x00, 0x08, QMJV)
                CreateField (QBUF, 0x08, 0x08, QMNV)
                Method (WQAA, 1, NotSerialized)
                {
                    Store (0x01, QMJV)
                    Store (0x00, QMNV)
                    Return (QBUF)
                }

                Method (WSAA, 2, NotSerialized)
                {
                    Store (Arg1, QBUF)
                    Store (Q000, FCOD)
                    Store (Q001, RCOD)
                }

                Method (WQAB, 1, NotSerialized)
                {
                    While (One)
                    {
                        Name (k0, 0x00)
                        Store (ToInteger (RCOD), k0)
                        If (LEqual (k0, 0x01))
                        {
                            RQ01 (Arg0)
                        }
                        Else
                        {
                            If (LEqual (k0, 0x02))
                            {
                                RQ02 (Arg0)
                            }
                            Else
                            {
                                If (LEqual (k0, 0x03))
                                {
                                    RQ03 (Arg0)
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x04))
                                    {
                                        RQ04 (Arg0)
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x05))
                                        {
                                            RQ05 (Arg0)
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0x06))
                                            {
                                                RQ06 (Arg0)
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x07))
                                                {
                                                    RQ07 (Arg0)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k0, 0x08))
                                                    {
                                                        RQ08 (Arg0)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k0, 0x09))
                                                        {
                                                            RQ09 (Arg0)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (k0, 0x0A))
                                                            {
                                                                RQ0A (Arg0)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (k0, 0x0B))
                                                                {
                                                                    RQ0B (Arg0)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (k0, 0x0C))
                                                                    {
                                                                        RQ0C (Arg0)
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Break
                    }

                    Return (QBUF)
                }

                Method (WSAB, 2, NotSerialized)
                {
                    While (One)
                    {
                        Name (k0, 0x00)
                        Store (ToInteger (RCOD), k0)
                        If (LEqual (k0, 0x01))
                        {
                            RS01 (Arg0, Arg1)
                        }
                        Else
                        {
                            If (LEqual (k0, 0x02))
                            {
                                RS02 (Arg0, Arg1)
                            }
                            Else
                            {
                                If (LEqual (k0, 0x03))
                                {
                                    RS03 (Arg0, Arg1)
                                }
                                Else
                                {
                                    If (LEqual (k0, 0x04))
                                    {
                                        RS04 (Arg0, Arg1)
                                    }
                                    Else
                                    {
                                        If (LEqual (k0, 0x05))
                                        {
                                            RS05 (Arg0, Arg1)
                                        }
                                        Else
                                        {
                                            If (LEqual (k0, 0x06))
                                            {
                                                RS06 (Arg0, Arg1)
                                            }
                                            Else
                                            {
                                                If (LEqual (k0, 0x07))
                                                {
                                                    RS07 (Arg0, Arg1)
                                                }
                                                Else
                                                {
                                                    If (LEqual (k0, 0x08))
                                                    {
                                                        RS08 (Arg0, Arg1)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (k0, 0x09))
                                                        {
                                                            RS09 (Arg0, Arg1)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (k0, 0x0A))
                                                            {
                                                                RS0A (Arg0, Arg1)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (k0, 0x0B))
                                                                {
                                                                    RS0B (Arg0, Arg1)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (k0, 0x0C))
                                                                    {
                                                                        RS0C (Arg0, Arg1)
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Break
                    }
                }

                Method (RQ01, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x02))
                    {
                        \_SB.QWMI.PHSR (0x01, 0x00)
                        Store (OWNS, Q512)
                    }

                    If (LEqual (FCOD, 0x05))
                    {
                        Store (SFAI, Q000)
                    }

                    If (LEqual (FCOD, 0x04))
                    {
                        If (LEqual (SFLG, 0x00))
                        {
                            Store (0x01, Q000)
                        }
                        Else
                        {
                            Store (0x00, Q000)
                        }
                    }
                }

                Method (RS01, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    If (LEqual (FCOD, 0x04))
                    {
                        Store (0x00, SFLG)
                        \_SB.QWMI.PHSR (0x01, 0x04)
                        Store (OWNS, Q512)
                        Store (Q000, SFLG)
                    }

                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x01, 0x02)
                    }

                    If (LEqual (FCOD, 0x03))
                    {
                        \_SB.QWMI.PHSR (0x01, 0x03)
                    }

                    If (LEqual (FCOD, 0x05))
                    {
                        Store (OWNS, Q512)
                        Store (Q000, SFAI)
                    }
                }

                Method (RQ02, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x02))
                    {
                        \_SB.QWMI.PHSR (0x02, 0x00)
                        Store (OWNS, Q512)
                    }

                    If (LEqual (FCOD, 0x05))
                    {
                        Store (UFAI, Q000)
                    }

                    If (LEqual (FCOD, 0x04))
                    {
                        If (LEqual (UFLG, 0x00))
                        {
                            Store (0x01, Q000)
                        }
                        Else
                        {
                            Store (0x00, Q000)
                        }
                    }
                }

                Method (RS02, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    If (LEqual (FCOD, 0x04))
                    {
                        Store (0x00, UFLG)
                        \_SB.QWMI.PHSR (0x02, 0x04)
                        Store (OWNS, Q512)
                        Store (Q000, UFLG)
                    }

                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x02, 0x02)
                    }

                    If (LEqual (FCOD, 0x03))
                    {
                        \_SB.QWMI.PHSR (0x02, 0x03)
                    }

                    If (LEqual (FCOD, 0x05))
                    {
                        Store (OWNS, Q512)
                        Store (Q000, UFAI)
                    }
                }

                Method (RQ03, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x03, 0x02)
                    }
                    Else
                    {
                        \_SB.QWMI.PHSR (0x03, 0x00)
                    }

                    Store (OWNS, Q512)
                }

                Method (RS03, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x03, 0x01)
                }

                Method (RQ04, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x04, 0x02)
                    }
                    Else
                    {
                        \_SB.QWMI.PHSR (0x04, 0x00)
                    }

                    Store (OWNS, Q512)
                }

                Method (RS04, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x04, 0x01)
                }

                Method (RQ05, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x05, 0x02)
                    }
                    Else
                    {
                        \_SB.QWMI.PHSR (0x05, 0x00)
                    }

                    Store (OWNS, Q512)
                }

                Method (RS05, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x05, 0x01)
                }

                Method (RQ06, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x06, 0x02)
                    }
                    Else
                    {
                        \_SB.QWMI.PHSR (0x06, 0x00)
                    }

                    Store (OWNS, Q512)
                }

                Method (RS06, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x06, 0x01)
                }

                Method (RQ07, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x07, 0x02)
                    }
                    Else
                    {
                        \_SB.QWMI.PHSR (0x07, 0x00)
                    }

                    Store (OWNS, Q512)
                }

                Method (RS07, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x07, 0x01)
                }

                Method (RQ08, 1, NotSerialized)
                {
                    If (LEqual (FCOD, 0x01))
                    {
                        \_SB.QWMI.PHSR (0x08, 0x02)
                    }
                    Else
                    {
                        \_SB.QWMI.PHSR (0x08, 0x00)
                    }

                    Store (OWNS, Q512)
                }

                Method (RS08, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x08, 0x01)
                }

                Method (RQ09, 1, NotSerialized)
                {
                    \_SB.QWMI.PHSR (0x00, 0x00)
                    Store (OWNS, Q512)
                    Store (0x00, QZZZ)
                }

                Method (RS09, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x00, 0x01)
                }

                Method (RQ0A, 1, NotSerialized)
                {
                    \_SB.QWMI.PHSR (0x09, 0x00)
                    Store (OWNS, Q512)
                }

                Method (RS0A, 2, NotSerialized)
                {
                }

                Method (RQ0B, 1, NotSerialized)
                {
                    \_SB.QWMI.PHSR (0x0A, 0x00)
                    Store (OWNS, Q512)
                }

                Method (RS0B, 2, NotSerialized)
                {
                    Store (Arg1, OWNS)
                    \_SB.QWMI.PHSR (0x0A, 0x01)
                }

                Method (RQ0C, 1, NotSerialized)
                {
                    \_SB.QWMI.PHSR (0x0B, 0x00)
                    Store (OWNS, Q512)
                }

                Method (RS0C, 2, NotSerialized)
                {
                }

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

        Scope (\_TZ)
        {
            ThermalZone (THRM)
            {
                Method (_TMP, 0, NotSerialized)
                {
                    If (\_SB.ECOK)
                    {
                        Acquire (\_SB.PCI0.LPCB.EC0.MUT1, 0xFFFF)
                        Store (\_SB.PCI0.LPCB.EC0.CTMP, Local0)
                        Release (\_SB.PCI0.LPCB.EC0.MUT1)
                        Return (Add (Multiply (Local0, 0x0A), 0x0AAC))
                    }
                    Else
                    {
                        Return (0x0C3C)
                    }
                }

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

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

    Name (FWSO, "FWSO")
}