The original DSDT.

dsdt-orig.dsl (text/plain), 124.87 KB, created by Christopher Head on 2009-06-12 09:02:45 UTC

/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20090521
 *
 * Disassembly of dsdt-orig.dat, Fri Jun 12 02:01:08 2009
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00004619 (17945)
 *     Revision         0x01 **** ACPI 1.0, no 64-bit math support
 *     Checksum         0x41
 *     OEM ID           "TOSHIB"
 *     OEM Table ID     "A0025   "
 *     OEM Revision     0x20041222 (537137698)
 *     Compiler ID      "MSFT"
 *     Compiler Version 0x0100000E (16777230)
 */
DefinitionBlock ("dsdt-orig.aml", "DSDT", 1, "TOSHIB", "A0025   ", 0x20041222)
{
    External (\_PR_.CPU0)

    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S3, Package (0x04)
    {
        0x05, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S4, Package (0x04)
    {
        0x06, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S5, Package (0x04)
    {
        0x07, 
        0x00, 
        0x00, 
        0x00
    })
    Scope (\_SB)
    {
        Name (PRS0, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {3,4,5,6,7,11}
        })
        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x01)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQA))
            }

            Name (_PRS, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, )
                    {10}
            })
            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQA))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQA)
            }
        }

        Device (LNKB)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x02)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQB))
            }

            Method (_PRS, 0, NotSerialized)
            {
                Return (PRS0)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQB))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQB)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQB)
            }
        }

        Device (LNKC)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x03)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQC))
            }

            Method (_PRS, 0, NotSerialized)
            {
                Return (PRS0)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQC))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQC)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQC)
            }
        }

        Device (LNKD)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x04)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQD))
            }

            Method (_PRS, 0, NotSerialized)
            {
                Return (PRS0)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQD))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQD)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQD)
            }
        }

        Device (LNKE)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x05)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQE))
            }

            Method (_PRS, 0, NotSerialized)
            {
                Return (PRS0)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQE))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQE)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQE)
            }
        }

        Device (LNKF)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x06)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQF))
            }

            Method (_PRS, 0, NotSerialized)
            {
                Return (PRS0)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQF))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQF)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQF)
            }
        }

        Device (LNKG)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x07)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQG))
            }

            Method (_PRS, 0, NotSerialized)
            {
                Return (PRS0)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQG))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQG)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQG)
            }
        }

        Device (LNKH)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x08)
            Method (_STA, 0, NotSerialized)
            {
                Return (STAL (\_SB.PCI0.FNC0.IRQH))
            }

            Method (_PRS, 0, NotSerialized)
            {
                Return (PRS0)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Return (CRSL (\_SB.PCI0.FNC0.IRQH))
            }

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.FNC0.IRQH)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQX)
                FindSetRightBit (IRQX, Local0)
                Decrement (Local0)
                Store (Local0, \_SB.PCI0.FNC0.IRQH)
            }
        }

        Device (MEM)
        {
            Name (_HID, EisaId ("PNP0C01"))
            Name (_STA, 0x0F)
            Method (_CRS, 0, NotSerialized)
            {
                Return (CRS (0x01))
            }

            OperationRegion (SRAM, SystemMemory, 0x000EE800, 0x1800)
            Field (SRAM, AnyAcc, NoLock, Preserve)
            {
                PAR1,   16, 
                PAR2,   16, 
                PAR3,   16, 
                PAR4,   16, 
                PAR5,   16, 
                PAR6,   16
            }

            Field (SRAM, AnyAcc, NoLock, Preserve)
            {
                        Offset (0x02), 
                RDID,   32, 
                RDSN,   32, 
                CAPB,   16
            }

            Field (SRAM, AnyAcc, NoLock, Preserve)
            {
                IEAX,   32, 
                IEBX,   32, 
                IECX,   32, 
                IEDX,   32, 
                IESI,   32, 
                IEDI,   32, 
                IEBP,   32, 
                        Offset (0x20), 
                OEAX,   32, 
                OEBX,   32, 
                OECX,   32, 
                OEDX,   32, 
                OESI,   32, 
                OEDI,   32, 
                OEBP,   32, 
                        Offset (0xFF), 
                ACST,   1, 
                BES1,   1, 
                BES2,   1, 
                        Offset (0x100), 
                BMN1,   104, 
                BSN1,   88, 
                BTP1,   72, 
                BPU1,   32, 
                BDC1,   32, 
                BLF1,   32, 
                BTC1,   32, 
                BDV1,   32, 
                BST1,   32, 
                BPR1,   32, 
                BRC1,   32, 
                BPV1,   32, 
                        Offset (0x149), 
                BCW1,   32, 
                BCL1,   32, 
                BG11,   32, 
                BG21,   32, 
                BOI1,   8, 
                BRF1,   1, 
                        Offset (0x200), 
                BMN2,   104, 
                BSN2,   88, 
                BTP2,   72, 
                BPU2,   32, 
                BDC2,   32, 
                BLF2,   32, 
                BTC2,   32, 
                BDV2,   32, 
                BST2,   32, 
                BPR2,   32, 
                BRC2,   32, 
                BPV2,   32, 
                        Offset (0x249), 
                BCW2,   32, 
                BCL2,   32, 
                BG12,   32, 
                BG22,   32, 
                BOI2,   32, 
                        Offset (0x300), 
                AC01,   16, 
                AC11,   16, 
                PSV1,   16, 
                CRT1,   16, 
                TMP1,   16, 
                AST1,   16, 
                AC21,   16, 
                AC31,   16, 
                AC02,   16, 
                AC12,   16, 
                PSV2,   16, 
                CRT2,   16, 
                TMP2,   16, 
                AST2,   16, 
                AC22,   16, 
                AC32,   16, 
                AC03,   16, 
                AC13,   16, 
                PSV3,   16, 
                CRT3,   16, 
                TMP3,   16, 
                AST3,   16, 
                AC23,   16, 
                AC33,   16, 
                        Offset (0x340), 
                TMPF,   16, 
                        Offset (0x3F0), 
                FANH,   1, 
                FANL,   7, 
                TF11,   1, 
                TF21,   1, 
                TF31,   1, 
                    ,   1, 
                TF10,   1, 
                TF20,   1, 
                TF30,   1, 
                        Offset (0x3F2), 
                TP11,   1, 
                TP21,   1, 
                TP31,   1, 
                        Offset (0x400), 
                GP50,   1, 
                GP51,   1, 
                GP52,   1, 
                GP53,   1, 
                GP54,   1, 
                GP55,   1, 
                GP56,   1, 
                GP57,   1, 
                GP60,   1, 
                GP61,   1, 
                GP62,   1, 
                GP63,   1, 
                GP64,   1, 
                GP65,   1, 
                GP66,   1, 
                GP67,   1, 
                GP70,   1, 
                GP71,   1, 
                GP72,   1, 
                GP73,   1, 
                GP74,   1, 
                GP75,   1, 
                GP76,   1, 
                GP77,   1, 
                WED0,   1, 
                WED1,   1, 
                WED2,   1, 
                WED3,   1, 
                WED4,   1, 
                        Offset (0x404), 
                SBL0,   1, 
                SBL1,   1, 
                SBL2,   1, 
                SBL3,   1, 
                        Offset (0x405), 
                LIDS,   1, 
                VALF,   1, 
                DCST,   1, 
                DOS2,   1, 
                DCKI,   1, 
                DCKF,   1, 
                BT1F,   1, 
                BT2F,   1, 
                NXLA,   1, 
                NXCA,   1, 
                NXTA,   1, 
                NXDA,   1, 
                CTLA,   1, 
                CTCA,   1, 
                CTTA,   1, 
                CTDA,   1, 
                LANA,   1, 
                PNLS,   1, 
                        Offset (0x483), 
                GCVS,   8, 
                        Offset (0x486), 
                DDS0,   8, 
                        Offset (0x4C0), 
                PSS0,   16, 
                PSS1,   16, 
                        Offset (0x4D0), 
                SYU0,   1, 
                SYU1,   1, 
                SYU2,   1, 
                SYU3,   1, 
                SYU4,   1, 
                WAKS,   1, 
                SYU6,   1, 
                SYU7,   1, 
                RPPC,   1, 
                DNTF,   1, 
                DCKU,   1, 
                DCKD,   1, 
                        Offset (0x500), 
                HKCD,   8, 
                        Offset (0x502), 
                DLID,   32, 
                DSRN,   32, 
                        Offset (0x50E), 
                BDID,   32, 
                DSPW,   1, 
                VGAF,   1, 
                VWE0,   1, 
                VWE1,   1, 
                PPSC,   1, 
                SPSC,   1, 
                EWLD,   1, 
                EPWS,   1, 
                LCDS,   4, 
                CRTS,   4, 
                VWE2,   1, 
                WEF0,   1, 
                WEF1,   1, 
                WED5,   1, 
                ECWE,   1, 
                        Offset (0x515), 
                BTMD,   1, 
                WSF0,   1, 
                WSF1,   1, 
                GP83,   1, 
                ECWS,   1, 
                    ,   1, 
                BPFE,   1, 
                BWUE,   1, 
                DVIS,   4, 
                        Offset (0x517), 
                HTM0,   1, 
                HTM1,   1, 
                HTS0,   1, 
                    ,   1, 
                I1EJ,   1, 
                        Offset (0x518), 
                PSND,   1, 
                PMDM,   1, 
                        Offset (0x520), 
                VGAR,   1, 
                KBCR,   1, 
                ID0R,   1, 
                ID1R,   1, 
                ID2R,   1, 
                ID3R,   1, 
                IDAR,   1, 
                ACLR,   1, 
                BTRE,   1, 
                ACVA,   1, 
                        Offset (0x522), 
                GP90,   1, 
                GP91,   1, 
                GP92,   1, 
                GP93,   1, 
                GP94,   1, 
                GP95,   1, 
                        Offset (0x523), 
                HTTE,   1, 
                CPED,   1, 
                        Offset (0x524), 
                EXHS,   1, 
                EXUP,   1, 
                        Offset (0x525), 
                DSB0,   1, 
                DSB1,   1, 
                DSB2,   1, 
                        Offset (0x6C0), 
                BDCS,   1, 
                        Offset (0x6C1), 
                BWE0,   1, 
                BWE1,   1, 
                BWE2,   1, 
                BWE3,   1, 
                BWE4,   1, 
                BWE5,   1, 
                BWF0,   1, 
                BWF1,   1, 
                BCDD,   4, 
                        Offset (0x701), 
                HAPS,   2, 
                HHSW,   2, 
                HPSU,   2, 
                HRCU,   2, 
                HGSU,   2, 
                HEBI,   2, 
                HTMD,   2, 
                        Offset (0x703), 
                HKRD,   2, 
                        Offset (0x708), 
                TNVS,   1, 
                OSPC,   1, 
                ACBK,   1, 
                LBAT,   1, 
                LANB,   1, 
                PICM,   1, 
                        Offset (0x709), 
                BTNE,   8, 
                PULD,   8, 
                PULA,   8, 
                BCLD,   8, 
                BCLA,   8, 
                        Offset (0x710), 
                OSID,   8, 
                        Offset (0x720), 
                MSSI,   16, 
                MSSS,   8, 
                MSSR,   8, 
                MSP0,   8, 
                MSC0,   8, 
                MSP1,   8, 
                MSC1,   8, 
                        Offset (0x740), 
                        Offset (0x800), 
                PRES,   32768
            }

            Field (SRAM, AnyAcc, NoLock, Preserve)
            {
                        Offset (0x406), 
                NXDD,   4, 
                CTDD,   4
            }

            Field (SRAM, AnyAcc, NoLock, Preserve)
            {
                        Offset (0x800), 
                        Offset (0x808), 
                        Offset (0x812), 
                        Offset (0x814), 
                        Offset (0x818), 
                FSDP,   8, 
                        Offset (0x823), 
                        Offset (0x826), 
                        Offset (0x836), 
                        Offset (0x87E), 
                        Offset (0x87F), 
                EDCK,   8
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Method (_CRS, 0, NotSerialized)
            {
                Name (CRBF, ResourceTemplate ()
                {
                    WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x00FF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0100,             // Length
                        ,, )
                    IO (Decode16,
                        0x0CF8,             // Range Minimum
                        0x0CF8,             // Range Maximum
                        0x01,               // Alignment
                        0x08,               // Length
                        )
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x0CF7,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0CF8,             // Length
                        ,, , TypeStatic)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0D00,             // Range Minimum
                        0xFFFF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0xF300,             // Length
                        ,, , TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000A0000,         // Range Minimum
                        0x000BFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00020000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000D0000,         // Range Minimum
                        0x000DFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00010000,         // Length
                        ,, _Y00, AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x80100000,         // Range Minimum
                        0xFEC0FFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x7EB10000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0xFEC20000,         // Range Minimum
                        0xFED9FFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00180000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0xFEDC0000,         // Range Minimum
                        0xFFB7FFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00DC0000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0xFFC00000,         // Range Minimum
                        0xFFEFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00300000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (CRBF, \_SB.PCI0._CRS._Y00._MIN, EMMS)
                CreateDWordField (CRBF, \_SB.PCI0._CRS._Y00._LEN, EMME)
                If (\_SB.MEM.LANB)
                {
                    Store (0x000D8000, EMMS)
                    Store (0x8000, EMME)
                }

                Return (CRBF)
            }

            Name (_PRT, Package (0x07)
            {
                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.LNKA, 
                    0x00
                }, 

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

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

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

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

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

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x01, 
                    \_SB.LNKB, 
                    0x00
                }
            })
            Device (PCIB)
            {
                Name (_ADR, 0x001E0000)
                OperationRegion (ICHB, PCI_Config, 0x00, 0xFF)
                Field (ICHB, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x19), 
                    BRGB,   8
                }

                Name (_PRT, Package (0x06)
                {
                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x00, 
                        \_SB.LNKE, 
                        0x00
                    }, 

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x01, 
                        \_SB.LNKD, 
                        0x00
                    }, 

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

                    Package (0x04)
                    {
                        0x000BFFFF, 
                        0x02, 
                        \_SB.LNKF, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000BFFFF, 
                        0x03, 
                        \_SB.LNKD, 
                        0x00
                    }
                })
                Device (MPC0)
                {
                    Name (_ADR, 0x00050000)
                }

                Device (MPC1)
                {
                    Name (_ADR, 0x00050001)
                }

                Device (LAN)
                {
                    Name (_ADR, 0x00080000)
                    OperationRegion (PLAN, PCI_Config, 0x00, 0xFF)
                    Field (PLAN, ByteAcc, NoLock, Preserve)
                    {
                        PLVI,   16, 
                                Offset (0xE1), 
                        PMES,   8
                    }
                }

                Device (CRD0)
                {
                    Name (_ADR, 0x000B0000)
                    Name (_SUN, 0x00)
                }

                Device (SDC)
                {
                    Name (_ADR, 0x000B0004)
                }

                Event (DKSQ)
                Event (SBSQ)
            }

            Device (FNC0)
            {
                Name (_ADR, 0x001F0000)
                OperationRegion (ICH3, PCI_Config, 0x00, 0xFF)
                Field (ICH3, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x60), 
                    IRQA,   8, 
                    IRQB,   8, 
                    IRQC,   8, 
                    IRQD,   8, 
                            Offset (0x68), 
                    IRQE,   8, 
                    IRQF,   8, 
                    IRQG,   8, 
                    IRQH,   8
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_STA, 0x0F)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0081,             // Range Minimum
                            0x0081,             // Range Maximum
                            0x01,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0087,             // Range Minimum
                            0x0087,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0089,             // Range Minimum
                            0x0089,             // Range Maximum
                            0x01,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x008F,             // Range Minimum
                            0x008F,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x00C0,             // Range Minimum
                            0x00C0,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {4}
                    })
                }

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

                Device (PIT)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_STA, 0x0F)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0040,             // Range Minimum
                            0x0040,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {0}
                    })
                }

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

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

                Device (KBC)
                {
                    Name (_HID, EisaId ("TOS7406"))
                    Name (_CID, EisaId ("PNP0303"))
                    Method (_STA, 0, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.KBCR, 0x00)) {}
                        Return (0x0F)
                    }

                    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 ("PNP0F13"))
                    Method (_STA, 0, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.KBCR, 0x00)) {}
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {12}
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_STA, 0x0F)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0070,             // Range Minimum
                            0x0070,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {8}
                    })
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_STA, 0x0F)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x002E,             // Range Minimum
                            0x002E,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0062,             // Range Minimum
                            0x0062,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0066,             // Range Minimum
                            0x0066,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0080,             // Range Minimum
                            0x0080,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0084,             // Range Minimum
                            0x0084,             // Range Maximum
                            0x01,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0088,             // Range Minimum
                            0x0088,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x008C,             // Range Minimum
                            0x008C,             // Range Maximum
                            0x01,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x01E0,             // Range Minimum
                            0x01E0,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0480,             // Range Minimum
                            0x0480,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0680,             // Range Minimum
                            0x0680,             // Range Maximum
                            0x80,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xD800,             // Range Minimum
                            0xD800,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xD880,             // Range Minimum
                            0xD880,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        IO (Decode16,
                            0xE000,             // Range Minimum
                            0xE000,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xE080,             // Range Minimum
                            0xE080,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xE400,             // Range Minimum
                            0xE400,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xE480,             // Range Minimum
                            0xE480,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xE800,             // Range Minimum
                            0xE800,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xE880,             // Range Minimum
                            0xE880,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xEC00,             // Range Minimum
                            0xEC00,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xEC80,             // Range Minimum
                            0xEC80,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0xEEB0,             // Range Minimum
                            0xEEB0,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0xEEC0,             // Range Minimum
                            0xEEC0,             // Range Maximum
                            0x01,               // Alignment
                            0x40,               // Length
                            )
                        IO (Decode16,
                            0x0010,             // Range Minimum
                            0x0010,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // 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,
                            0x0050,             // Range Minimum
                            0x0050,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // 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,
                            0x0072,             // Range Minimum
                            0x0072,             // Range Maximum
                            0x01,               // Alignment
                            0x06,               // Length
                            )
                        IO (Decode16,
                            0x0090,             // Range Minimum
                            0x0090,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // 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
                            0x06,               // 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
                            )
                    })
                    OperationRegion (SRG1, SystemIO, 0xB2, 0x01)
                    Field (SRG1, ByteAcc, NoLock, Preserve)
                    {
                        TRP4,   8
                    }

                    OperationRegion (GPIO, SystemIO, 0xEEC0, 0x40)
                    Field (GPIO, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x0C), 
                        GPLV,   32
                    }
                }

                Device (TBLT)
                {
                    Name (_HID, EisaId ("WACF004"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (STA (0x0E))
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Return (CRS (0x0E))
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (PRS (0x0E))
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        SRS (0x0E, Arg0)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        DIS (0x0E)
                    }
                }
            }

            Device (FNC1)
            {
                Name (_ADR, 0x001F0001)
                OperationRegion (IDEC, PCI_Config, 0x00, 0xFF)
                Field (IDEC, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x08), 
                    RVID,   8, 
                            Offset (0x40), 
                    PRTE,   8, 
                    PRTM,   8, 
                    SRTE,   8, 
                    SRTM,   8, 
                            Offset (0x48), 
                    PUDM,   1, 
                        ,   1, 
                    SUDM,   1, 
                            Offset (0x4A), 
                    PUDC,   2, 
                            Offset (0x4B), 
                    SUDC,   2, 
                            Offset (0x54), 
                    PCB0,   1, 
                        ,   1, 
                    SCB0,   1, 
                        ,   1, 
                    PCS0,   1, 
                    PCS1,   1, 
                    SCS0,   1, 
                    SCS1,   1, 
                        ,   2, 
                    PP_E,   1, 
                        ,   1, 
                    FPC0,   1, 
                        ,   1, 
                    FSC0,   1
                }

                Field (IDEC, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x54), 
                        ,   4, 
                    CSTS,   4
                }

                Device (IDE0)
                {
                    Name (_ADR, 0x00)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, \_SB.MEM.PPSC)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (0x01, \_SB.MEM.PPSC)
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        If (\_SB.MEM.PPSC)
                        {
                            Return (0x03)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.ID0R, 0x00)) {}
                        Store (0x01, \_SB.MEM.HTM0)
                        CreateDWordField (Arg0, 0x00, PPIO)
                        CreateDWordField (Arg0, 0x04, PDMA)
                        CreateDWordField (Arg0, 0x10, PFLG)
                        Store (PPIO, Local1)
                        Store (PDMA, Local2)
                        Store (PFLG, Local3)
                        Store (0x80, Local4)
                        Store (0x00, Local7)
                        If (LLessEqual (Local1, 0x78))
                        {
                            Store (0xA3, Local4)
                            Store (0x03, Local7)
                        }
                        Else
                        {
                            If (LLessEqual (Local1, 0xB4))
                            {
                                Store (0xA1, Local4)
                                Store (0x03, Local7)
                            }
                            Else
                            {
                                If (LLessEqual (Local1, 0xF0))
                                {
                                    Store (0x90, Local4)
                                    Store (0x01, Local7)
                                }
                            }
                        }

                        Store (Local4, \_SB.PCI0.FNC1.PRTM)
                        Store (0x00, Local4)
                        Store (0x00, Local5)
                        Store (0x00, Local6)
                        Store (0x00, Local1)
                        And (Local3, 0x01, Local3)
                        Store (Local3, \_SB.PCI0.FNC1.PUDM)
                        If (LEqual (Local3, 0x01))
                        {
                            Store (0x07, Local7)
                            Store (0x01, Local1)
                            If (LLessEqual (Local2, 0x14))
                            {
                                Store (0x01, Local6)
                                Store (0x01, Local4)
                            }
                            Else
                            {
                                If (LLessEqual (Local2, 0x1E))
                                {
                                    Store (0x02, Local4)
                                    Store (0x01, Local5)
                                }
                                Else
                                {
                                    If (LLessEqual (Local2, 0x3C))
                                    {
                                        Store (0x02, Local4)
                                    }
                                    Else
                                    {
                                        If (LLessEqual (Local2, 0x5A))
                                        {
                                            Store (0x01, Local4)
                                        }
                                    }
                                }
                            }
                        }
                        Else
                        {
                            If (LAnd (LLessEqual (Local2, 0xB4), LGreater (Local2, 0x78)))
                            {
                                Store (0x03, Local7)
                                Store (0xA3, \_SB.PCI0.FNC1.PRTM)
                            }
                        }

                        Store (Local4, \_SB.PCI0.FNC1.PUDC)
                        Store (Local5, \_SB.PCI0.FNC1.PCB0)
                        Store (Local6, \_SB.PCI0.FNC1.FPC0)
                        Store (Local7, \_SB.PCI0.FNC1.PRTE)
                        Store (Local1, \_SB.PCI0.FNC1.PCS0)
                        Store (0x01, Local1)
                        Store (\_SB.PCI0.FNC1.CSTS, Local0)
                        If (LEqual (Local0, 0x00))
                        {
                            Store (0x00, Local1)
                        }

                        Store (Local1, \_SB.PCI0.FNC1.PP_E)
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.ID0R, 0x00)) {}
                        Store (0x01, \_SB.MEM.HTM0)
                        Store (\_SB.PCI0.FNC1.PRTM, Local0)
                        Store (0xFA, Local2)
                        If (LEqual (Local0, 0xA3))
                        {
                            Store (0x78, Local2)
                        }
                        Else
                        {
                            If (LEqual (Local0, 0xA1))
                            {
                                Store (0xB4, Local2)
                            }
                            Else
                            {
                                If (LEqual (Local0, 0x90))
                                {
                                    Store (0xF0, Local2)
                                }
                            }
                        }

                        Store (\_SB.PCI0.FNC1.PUDC, Local1)
                        Store (0x02, Local4)
                        If (LEqual (\_SB.PCI0.FNC1.PUDM, 0x01))
                        {
                            Store (0x03, Local4)
                            If (LEqual (\_SB.PCI0.FNC1.FPC0, 0x01))
                            {
                                Store (0x14, Local3)
                            }
                            Else
                            {
                                If (LEqual (\_SB.PCI0.FNC1.PCB0, 0x01))
                                {
                                    Store (0x1E, Local3)
                                }
                                Else
                                {
                                    Store (0x78, Local3)
                                    If (LEqual (Local1, 0x01))
                                    {
                                        Store (0x5A, Local3)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local1, 0x02))
                                        {
                                            Store (0x3C, Local3)
                                        }
                                    }
                                }
                            }
                        }
                        Else
                        {
                            Store (0xB4, Local3)
                            If (LEqual (Local0, 0xA3))
                            {
                                Store (0x78, Local3)
                            }
                        }

                        Name (BUFF, Buffer (0x14) {})
                        CreateDWordField (BUFF, 0x00, PIO1)
                        CreateDWordField (BUFF, 0x04, DMA1)
                        CreateDWordField (BUFF, 0x08, PIO2)
                        CreateDWordField (BUFF, 0x0C, DMA2)
                        CreateDWordField (BUFF, 0x10, FLGS)
                        Store (Local2, PIO1)
                        Store (Local3, DMA1)
                        Store (0xFFFFFFFF, PIO2)
                        Store (0xFFFFFFFF, DMA2)
                        Store (Local4, FLGS)
                        Return (BUFF)
                    }

                    Device (HD_0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            While (LEqual (\_SB.MEM.ID0R, 0x00)) {}
                            Store (0x01, \_SB.MEM.HTM0)
                            Name (BUFF, Buffer (0x0E)
                            {
                                /* 0000 */    0x03, 0x0C, 0x00, 0x00, 0x00, 0x00, 0xEF, 0x03, 
                                /* 0008 */    0x23, 0x00, 0x00, 0x00, 0x00, 0xEF
                            })
                            CreateByteField (BUFF, 0x01, PIOM)
                            CreateByteField (BUFF, 0x08, DMAM)
                            Store (\_SB.PCI0.FNC1.PRTM, Local0)
                            Store (0x08, Local1)
                            If (LEqual (Local0, 0xA3))
                            {
                                Store (0x0C, Local1)
                            }
                            Else
                            {
                                If (LEqual (Local0, 0xA1))
                                {
                                    Store (0x0B, Local1)
                                }
                                Else
                                {
                                    If (LEqual (Local0, 0x90))
                                    {
                                        Store (0x0A, Local1)
                                    }
                                }
                            }

                            Store (\_SB.PCI0.FNC1.PUDM, Local2)
                            If (LEqual (Local2, 0x01))
                            {
                                Store (\_SB.PCI0.FNC1.PUDC, Local4)
                                If (LEqual (\_SB.PCI0.FNC1.FPC0, 0x01))
                                {
                                    Store (0x45, Local3)
                                }
                                Else
                                {
                                    If (LEqual (\_SB.PCI0.FNC1.PCB0, 0x01))
                                    {
                                        Store (0x44, Local3)
                                    }
                                    Else
                                    {
                                        Store (0x40, Local3)
                                        If (LEqual (Local4, 0x01))
                                        {
                                            Store (0x41, Local3)
                                        }
                                        Else
                                        {
                                            If (LEqual (Local4, 0x02))
                                            {
                                                Store (0x42, Local3)
                                            }
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x21, Local3)
                                If (LEqual (Local0, 0xA3))
                                {
                                    Store (0x22, Local3)
                                }
                            }

                            Store (Local1, PIOM)
                            Store (Local3, DMAM)
                            Return (BUFF)
                        }
                    }
                }

                Device (IDE1)
                {
                    Name (_ADR, 0x01)
                    Method (_PS0, 0, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.ID1R, 0x00)) {}
                        SMBR (0xFE00, 0x14, 0x00, 0x00, 0xB2)
                        And (\_SB.MEM.OECX, 0x02, Local0)
                        If (Local0)
                        {
                            Store (0x00, \_SB.MEM.SPSC)
                            Store (0x01, \_SB.MEM.IESI)
                            Store (0x02, \_SB.MEM.IEDI)
                            SMBR (0xFE00, 0x23, 0xF9, 0x00, 0xB2)
                            If (\_SB.MEM.OEDX)
                            {
                                Store (0x01, \_SB.MEM.IESI)
                                Store (0x02, \_SB.MEM.IEDI)
                                SMBR (0xFF00, 0x23, 0xF9, 0x00, 0xB2)
                                Store (0x01, \_SB.MEM.OECX)
                                While (\_SB.MEM.OECX)
                                {
                                    Store (0x01, \_SB.MEM.IESI)
                                    Store (0x02, \_SB.MEM.IEDI)
                                    SMBR (0xFE00, 0x23, 0xF9, 0x00, 0xB2)
                                }
                            }
                        }
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.ID1R, 0x00)) {}
                        SMBR (0xFE00, 0x14, 0x00, 0x00, 0xB2)
                        And (\_SB.MEM.OECX, 0x02, Local0)
                        If (Local0)
                        {
                            Store (0x01, \_SB.MEM.SPSC)
                        }
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.ID1R, 0x00)) {}
                        SMBR (0xFE00, 0x14, 0x00, 0x00, 0xB2)
                        And (\_SB.MEM.OECX, 0x02, Local0)
                        If (Local0)
                        {
                            If (\_SB.MEM.SPSC)
                            {
                                Return (0x03)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.ID1R, 0x00)) {}
                        SMBR (0xFE00, 0x14, 0x00, 0x00, 0xB2)
                        And (\_SB.MEM.OECX, 0x02, Local0)
                        If (Local0)
                        {
                            Store (0x01, \_SB.MEM.HTM1)
                            CreateDWordField (Arg0, 0x00, PPIO)
                            CreateDWordField (Arg0, 0x04, PDMA)
                            CreateDWordField (Arg0, 0x10, PFLG)
                            Store (PPIO, Local1)
                            Store (PDMA, Local2)
                            Store (PFLG, Local3)
                            Store (0x80, Local4)
                            Store (0x00, Local7)
                            If (LLessEqual (Local1, 0x78))
                            {
                                Store (0xA3, Local4)
                                Store (0x03, Local7)
                            }
                            Else
                            {
                                If (LLessEqual (Local1, 0xB4))
                                {
                                    Store (0xA1, Local4)
                                    Store (0x03, Local7)
                                }
                                Else
                                {
                                    If (LLessEqual (Local1, 0xF0))
                                    {
                                        Store (0x90, Local4)
                                        Store (0x01, Local7)
                                    }
                                }
                            }

                            Store (Local4, \_SB.PCI0.FNC1.SRTM)
                            Store (0x00, Local4)
                            Store (0x00, Local5)
                            Store (0x00, Local6)
                            Store (0x00, Local1)
                            And (Local3, 0x01, Local3)
                            Store (Local3, \_SB.PCI0.FNC1.SUDM)
                            If (LEqual (Local3, 0x01))
                            {
                                Store (0x07, Local7)
                                Store (0x01, Local1)
                                If (LLessEqual (Local2, 0x14))
                                {
                                    Store (0x01, Local6)
                                    Store (0x01, Local4)
                                }
                                Else
                                {
                                    If (LLessEqual (Local2, 0x1E))
                                    {
                                        Store (0x02, Local4)
                                        Store (0x01, Local5)
                                    }
                                    Else
                                    {
                                        If (LLessEqual (Local2, 0x3C))
                                        {
                                            Store (0x02, Local4)
                                        }
                                        Else
                                        {
                                            If (LLessEqual (Local2, 0x5A))
                                            {
                                                Store (0x01, Local4)
                                            }
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                If (LAnd (LLessEqual (Local2, 0xB4), LGreater (Local2, 0x78)))
                                {
                                    Store (0x03, Local7)
                                    Store (0xA3, \_SB.PCI0.FNC1.SRTM)
                                }
                            }

                            Store (Local4, \_SB.PCI0.FNC1.SUDC)
                            Store (Local5, \_SB.PCI0.FNC1.SCB0)
                            Store (Local6, \_SB.PCI0.FNC1.FSC0)
                            Store (Local7, \_SB.PCI0.FNC1.SRTE)
                            Store (Local1, \_SB.PCI0.FNC1.SCS0)
                            Store (0x01, Local1)
                            Store (\_SB.PCI0.FNC1.CSTS, Local0)
                            If (LEqual (Local0, 0x00))
                            {
                                Store (0x00, Local1)
                            }

                            Store (Local1, \_SB.PCI0.FNC1.PP_E)
                        }
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        While (LEqual (\_SB.MEM.ID1R, 0x00)) {}
                        Store (0x01, \_SB.MEM.HTM1)
                        Store (\_SB.PCI0.FNC1.SRTM, Local0)
                        Store (0xFA, Local2)
                        If (LEqual (Local0, 0xA3))
                        {
                            Store (0x78, Local2)
                        }
                        Else
                        {
                            If (LEqual (Local0, 0xA1))
                            {
                                Store (0xB4, Local2)
                            }
                            Else
                            {
                                If (LEqual (Local0, 0x90))
                                {
                                    Store (0xF0, Local2)
                                }
                            }
                        }

                        Store (\_SB.PCI0.FNC1.SUDC, Local1)
                        Store (0x02, Local4)
                        If (LEqual (\_SB.PCI0.FNC1.SUDM, 0x01))
                        {
                            Store (0x03, Local4)
                            If (LEqual (\_SB.PCI0.FNC1.FSC0, 0x01))
                            {
                                Store (0x14, Local3)
                            }
                            Else
                            {
                                If (LEqual (\_SB.PCI0.FNC1.SCB0, 0x01))
                                {
                                    Store (0x1E, Local3)
                                }
                                Else
                                {
                                    Store (0x78, Local3)
                                    If (LEqual (Local1, 0x01))
                                    {
                                        Store (0x5A, Local3)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local1, 0x02))
                                        {
                                            Store (0x3C, Local3)
                                        }
                                    }
                                }
                            }
                        }
                        Else
                        {
                            Store (0xB4, Local3)
                            If (LEqual (Local0, 0xA3))
                            {
                                Store (0x78, Local3)
                            }
                        }

                        Name (BUFF, Buffer (0x14) {})
                        CreateDWordField (BUFF, 0x00, PIO1)
                        CreateDWordField (BUFF, 0x04, DMA1)
                        CreateDWordField (BUFF, 0x08, PIO2)
                        CreateDWordField (BUFF, 0x0C, DMA2)
                        CreateDWordField (BUFF, 0x10, FLGS)
                        Store (Local2, PIO1)
                        Store (Local3, DMA1)
                        Store (0xFFFFFFFF, PIO2)
                        Store (0xFFFFFFFF, DMA2)
                        Store (Local4, FLGS)
                        Return (BUFF)
                    }

                    Device (HD_1)
                    {
                        Name (_ADR, 0x00)
                        Method (_STA, 0, NotSerialized)
                        {
                            While (LEqual (\_SB.MEM.ID1R, 0x00)) {}
                            SMBR (0xFE00, 0x14, 0x00, 0x00, 0xB2)
                            And (\_SB.MEM.OECX, 0x02, Local0)
                            If (Local0)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_EJ0, 1, NotSerialized)
                        {
                            Store (0x01, \_SB.MEM.I1EJ)
                            SMBR (0xFE00, 0x14, 0x00, 0x00, 0xB2)
                            And (\_SB.MEM.OECX, 0x02, Local0)
                            If (Local0)
                            {
                                Store (0x01, \_SB.MEM.IESI)
                                Store (0x02, \_SB.MEM.IEDI)
                                SMBR (0xFE00, 0x23, 0xF9, 0x00, 0xB2)
                                If (LNotEqual (\_SB.MEM.OEDX, 0x03))
                                {
                                    Store (0x01, \_SB.MEM.IESI)
                                    Store (0x02, \_SB.MEM.IEDI)
                                    SMBR (0xFF00, 0x23, 0xF9, 0x03, 0xB2)
                                    Store (0x01, \_SB.MEM.OECX)
                                    While (\_SB.MEM.OECX)
                                    {
                                        Store (0x01, \_SB.MEM.IESI)
                                        Store (0x02, \_SB.MEM.IEDI)
                                        SMBR (0xFE00, 0x23, 0xF9, 0x00, 0xB2)
                                    }
                                }
                            }
                        }

                        Method (_GTF, 0, NotSerialized)
                        {
                            While (LEqual (\_SB.MEM.ID1R, 0x00)) {}
                            Store (0x01, \_SB.MEM.HTM1)
                            Name (BUFF, Buffer (0x0E)
                            {
                                /* 0000 */    0x03, 0x0C, 0x00, 0x00, 0x00, 0x00, 0xEF, 0x03, 
                                /* 0008 */    0x23, 0x00, 0x00, 0x00, 0x00, 0xEF
                            })
                            CreateByteField (BUFF, 0x01, PIOM)
                            CreateByteField (BUFF, 0x08, DMAM)
                            Store (\_SB.PCI0.FNC1.SRTM, Local0)
                            Store (0x08, Local1)
                            If (LEqual (Local0, 0xA3))
                            {
                                Store (0x0C, Local1)
                            }
                            Else
                            {
                                If (LEqual (Local0, 0xA1))
                                {
                                    Store (0x0B, Local1)
                                }
                                Else
                                {
                                    If (LEqual (Local0, 0x90))
                                    {
                                        Store (0x0A, Local1)
                                    }
                                }
                            }

                            Store (\_SB.PCI0.FNC1.SUDM, Local2)
                            If (LEqual (Local2, 0x01))
                            {
                                Store (\_SB.PCI0.FNC1.SUDC, Local4)
                                If (LEqual (\_SB.PCI0.FNC1.FSC0, 0x01))
                                {
                                    Store (0x45, Local3)
                                }
                                Else
                                {
                                    If (LEqual (\_SB.PCI0.FNC1.SCB0, 0x01))
                                    {
                                        Store (0x44, Local3)
                                    }
                                    Else
                                    {
                                        Store (0x40, Local3)
                                        If (LEqual (Local4, 0x01))
                                        {
                                            Store (0x41, Local3)
                                        }
                                        Else
                                        {
                                            If (LEqual (Local4, 0x02))
                                            {
                                                Store (0x42, Local3)
                                            }
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x21, Local3)
                                If (LEqual (Local0, 0xA3))
                                {
                                    Store (0x22, Local3)
                                }
                            }

                            Store (Local1, PIOM)
                            Store (Local3, DMAM)
                            Return (BUFF)
                        }
                    }
                }
            }

            Device (VGA)
            {
                Name (_ADR, 0x00020000)
                Method (_PS0, 0, Serialized)
                {
                    While (LEqual (\_SB.MEM.VGAR, 0x00)) {}
                    Store (0x01, \_SB.MEM.IESI)
                    Store (0x00, \_SB.MEM.IEDI)
                    SMBR (0xFE00, 0x23, 0x10, 0x00, 0xB2)
                    If (LEqual (\_SB.MEM.OEAX, 0x00))
                    {
                        Store (0x01, \_SB.MEM.IESI)
                        Store (0x00, \_SB.MEM.IEDI)
                        SMBR (0xFF00, 0x23, 0x10, 0x00, 0xB2)
                        WPSX (0x10, 0x01, 0x00, 0x00)
                        Store (0x00, \_SB.MEM.VGAF)
                    }
                }

                Method (_PS1, 0, Serialized)
                {
                    While (LEqual (\_SB.MEM.VGAR, 0x00)) {}
                    Store (0x01, \_SB.MEM.IESI)
                    Store (0x00, \_SB.MEM.IEDI)
                    SMBR (0xFE00, 0x23, 0x10, 0x00, 0xB2)
                    If (LEqual (\_SB.MEM.OEAX, 0x00))
                    {
                        Store (0x01, \_SB.MEM.IESI)
                        Store (0x00, \_SB.MEM.IEDI)
                        SMBR (0xFF00, 0x23, 0x10, 0x01, 0xB2)
                        WPSX (0x10, 0x01, 0x00, 0x01)
                        Store (0x01, \_SB.MEM.VGAF)
                    }
                }

                Method (_PS3, 0, Serialized)
                {
                    While (LEqual (\_SB.MEM.VGAR, 0x00)) {}
                    Store (0x01, \_SB.MEM.IESI)
                    Store (0x00, \_SB.MEM.IEDI)
                    SMBR (0xFE00, 0x23, 0x10, 0x00, 0xB2)
                    If (LEqual (\_SB.MEM.OEAX, 0x00))
                    {
                        Store (0x01, \_SB.MEM.IESI)
                        Store (0x00, \_SB.MEM.IEDI)
                        SMBR (0xFF00, 0x23, 0x10, 0x03, 0xB2)
                        WPSX (0x10, 0x01, 0x00, 0x03)
                        Store (0x01, \_SB.MEM.VGAF)
                    }
                }

                Method (_PSC, 0, NotSerialized)
                {
                    While (LEqual (\_SB.MEM.VGAR, 0x00)) {}
                    Store (0x01, \_SB.MEM.IESI)
                    Store (0x00, \_SB.MEM.IEDI)
                    SMBR (0xFE00, 0x23, 0x10, 0x00, 0xB2)
                    Return (\_SB.MEM.OEDX)
                }

                Method (_DOS, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (0x01, \_SB.MEM.DCST)
                        Store (0x00, \_SB.MEM.DOS2)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x00, \_SB.MEM.DCST)
                            Store (0x01, \_SB.MEM.DOS2)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (0x01, \_SB.MEM.DCST)
                                Store (0x01, \_SB.MEM.DOS2)
                            }
                        }
                    }
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Name (BUFF, Package (0x03)
                    {
                        0x0110, 
                        0x0100, 
                        0x0200
                    })
                    Return (BUFF)
                }

                Method (_ROM, 2, NotSerialized)
                {
                    Add (Arg0, 0x000C0000, Local0)
                    ShiftLeft (Arg1, 0x03, Local1)
                    Name (BUFF, Buffer (Arg1) {})
                    Scope (\)
                    {
                        OperationRegion (VROM, SystemMemory, Local0, Local1)
                        Field (VROM, ByteAcc, NoLock, Preserve)
                        {
                            ROMI,   65536
                        }
                    }

                    Store (\ROMI, BUFF)
                    Return (BUFF)
                }

                Device (LCD)
                {
                    Name (_ADR, 0x0110)
                    Method (_DCS, 0, NotSerialized)
                    {
                        If (\_SB.MEM.CTLA)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x0D)
                        }
                    }

                    Method (_DDC, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x80, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (0x0100, Local0)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Store (0x00, \_SB.MEM.PRES)
                        ShiftLeft (Arg0, 0x08, Local1)
                        Or (Local1, 0x01, Local1)
                        Name (BUFF, Buffer (Local0) {})
                        SMBR (0xFE00, 0x37, Local1, 0x000EF000, 0xB2)
                        And (Local1, 0xFF00, Local1)
                        Store (0x0100, \_SB.MEM.OECX)
                        While (\_SB.MEM.OECX)
                        {
                            SMBR (0xFE00, 0x37, Local1, 0x00, 0xB2)
                        }

                        Store (\_SB.MEM.FSDP, Local0)
                        Or (Local0, 0x22, \_SB.MEM.FSDP)
                        Subtract (\_SB.MEM.FSDP, Local0, Local0)
                        Subtract (\_SB.MEM.EDCK, Local0, \_SB.MEM.EDCK)
                        Store (\_SB.MEM.PRES, BUFF)
                        Return (BUFF)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (\_SB.MEM.NXLA)
                        {
                            Return (One)
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        Store (Arg0, Local0)
                        And (Local0, 0x01, Local1)
                        If (Local1)
                        {
                            Store (0x01, \_SB.MEM.NXLA)
                        }
                        Else
                        {
                            Store (0x00, \_SB.MEM.NXLA)
                        }
                    }

                    Method (_BCL, 0, NotSerialized)
                    {
                        Name (BUFF, Package (0x0A)
                        {
                            0x64, 
                            0x0A, 
                            0x00, 
                            0x0F, 
                            0x1E, 
                            0x28, 
                            0x37, 
                            0x41, 
                            0x50, 
                            0x64
                        })
                        Return (BUFF)
                    }

                    Method (_BCM, 1, NotSerialized)
                    {
                        Multiply (Arg0, 0xFFFF, Local0)
                        Divide (Local0, 0x64, , Local0)
                        SMBR (0xFF00, 0x2A, Local0, 0x00, 0xB2)
                    }

                    Method (_PS0, 0, Serialized)
                    {
                        Store (0x00, \_SB.MEM.LCDS)
                        If (LEqual (\_SB.MEM.DNTF, 0x01))
                        {
                            Store (0x00, \_SB.MEM.DNTF)
                            If (LEqual (\_SB.MEM.DOS2, 0x00))
                            {
                                If (\_SB.MEM.DCKU)
                                {
                                    Store (0x02, \_SB.MEM.CTDD)
                                    Store (0x01, \_SB.MEM.NXDD)
                                    Notify (\_SB.PCI0.VGA, 0x80)
                                }
                            }
                        }

                        Store (0x00, \_SB.MEM.DCKU)
                    }

                    Method (_PS3, 0, Serialized)
                    {
                        Store (0x03, \_SB.MEM.LCDS)
                    }

                    Method (_PSC, 0, Serialized)
                    {
                        Return (\_SB.MEM.LCDS)
                    }
                }

                Device (CRT)
                {
                    Name (_ADR, 0x0100)
                    Method (_DCS, 0, NotSerialized)
                    {
                        If (\_SB.MEM.CTCA)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x0D)
                        }
                    }

                    Method (_DDC, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x80, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (0x0100, Local0)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Store (0x00, \_SB.MEM.PRES)
                        ShiftLeft (Arg0, 0x08, Local1)
                        Or (Local1, 0x02, Local1)
                        Name (BUFF, Buffer (Local0) {})
                        SMBR (0xFE00, 0x37, Local1, 0x000EF000, 0xB2)
                        And (Local1, 0xFF00, Local1)
                        Store (0x0100, \_SB.MEM.OECX)
                        While (\_SB.MEM.OECX)
                        {
                            SMBR (0xFE00, 0x37, Local1, 0x00, 0xB2)
                        }

                        Store (\_SB.MEM.PRES, BUFF)
                        Return (BUFF)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (\_SB.MEM.NXCA)
                        {
                            Return (One)
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        Store (Arg0, Local0)
                        And (Local0, 0x01, Local1)
                        If (Local1)
                        {
                            Store (0x01, \_SB.MEM.NXCA)
                        }
                        Else
                        {
                            Store (0x00, \_SB.MEM.NXCA)
                        }
                    }

                    Method (_PS0, 0, Serialized)
                    {
                        Store (0x00, \_SB.MEM.CRTS)
                    }

                    Method (_PS3, 0, Serialized)
                    {
                        Store (0x03, \_SB.MEM.CRTS)
                    }

                    Method (_PSC, 0, Serialized)
                    {
                        Return (\_SB.MEM.CRTS)
                    }
                }

                Device (TV)
                {
                    Name (_ADR, 0x0200)
                    Method (_DCS, 0, NotSerialized)
                    {
                        If (\_SB.MEM.CTTA)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x0D)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (\_SB.MEM.NXTA)
                        {
                            Return (One)
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        Store (Arg0, Local0)
                        And (Local0, 0x01, Local1)
                        If (Local1)
                        {
                            Store (0x01, \_SB.MEM.NXTA)
                        }
                        Else
                        {
                            Store (0x00, \_SB.MEM.NXTA)
                        }
                    }
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)
                Device (HUB1)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x03, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x01, \_SB.MEM.WED3)
                    }
                    Else
                    {
                        Store (0x00, \_SB.MEM.WED3)
                    }
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)
                Device (HUB2)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x04, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x01, \_SB.MEM.WED3)
                    }
                    Else
                    {
                        Store (0x00, \_SB.MEM.WED3)
                    }
                }
            }

            Device (USB3)
            {
                Name (_ADR, 0x001D0002)
                Device (HUB3)
                {
                    Name (_ADR, 0x00)
                }

                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x01, \_SB.MEM.WED3)
                    }
                    Else
                    {
                        Store (0x00, \_SB.MEM.WED3)
                    }
                }
            }

            Device (USB4)
            {
                Name (_ADR, 0x001D0007)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x01, \_SB.MEM.WED3)
                    }
                    Else
                    {
                        Store (0x00, \_SB.MEM.WED3)
                    }
                }

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

            Device (AMDM)
            {
                Name (_ADR, 0x001F0006)
                Method (_PS0, 0, NotSerialized)
                {
                    While (LEqual (\_SB.MEM.ACLR, 0x00)) {}
                    Store (0x00, \_SB.MEM.PMDM)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (0x01, \_SB.MEM.PMDM)
                }

                Method (_PSC, 0, NotSerialized)
                {
                    If (\_SB.MEM.PMDM)
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x01, \_SB.MEM.WED1)
                    }
                    Else
                    {
                        Store (0x00, \_SB.MEM.WED1)
                    }
                }
            }

            Device (ASND)
            {
                Name (_ADR, 0x001F0005)
                Method (_PS0, 0, NotSerialized)
                {
                    While (LEqual (\_SB.MEM.ACLR, 0x00)) {}
                    Store (0x00, \_SB.MEM.PSND)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (0x01, \_SB.MEM.PSND)
                }

                Method (_PSC, 0, NotSerialized)
                {
                    If (\_SB.MEM.PSND)
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (\_SB.MEM.BES1, \_SB.MEM.BT1F)
                Store (0x00, \_SB.MEM.DSPW)
                Store (0x00, \_SB.MEM.VGAF)
                Store (0x00, \_SB.MEM.PPSC)
                Store (0x00, \_SB.MEM.SPSC)
                Store (0x00, \_SB.MEM.GP91)
                Store (\_SB.MEM.CTDD, \_SB.MEM.DDS0)
                Store (0x00, Local0)
                If (CMPS (\_OS, "Microsoft Windows NT"))
                {
                    Store (0x03, Local0)
                    If (CondRefOf (\_OSI, Local1))
                    {
                        If (\_OSI ("Windows 2001"))
                        {
                            Store (0x04, Local0)
                        }
                    }
                }
                Else
                {
                    If (CMPS (\_OS, "Microsoft Windows"))
                    {
                        Store (0x01, Local0)
                    }

                    If (CMPS (\_OS, "Microsoft WindowsME:Millennium Edition"))
                    {
                        Store (0x02, Local0)
                    }
                }

                Store (Local0, \_SB.MEM.OSID)
                DIS (0x14)
                Store (0x02000200, \_SB.MEM.OECX)
                If (LEqual (\_SB.MEM.OSID, 0x04))
                {
                    Store (0x01040100, \_SB.MEM.OECX)
                }

                SMBR (0xFF00, 0x66, \_SB.MEM.OECX, 0x00, 0xB2)
                SMBR (0xFF00, 0x1E, 0x01, 0x00, 0xB2)
                Store (0x01, \_SB.MEM.PAR1)
                Store (0x60, \_SB.PCI0.FNC0.SYSR.TRP4)
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                Return (\_SB.MEM.LIDS)
            }

            Name (_PRW, Package (0x02)
            {
                0x1C, 
                0x04
            })
            Method (_PSW, 1, NotSerialized)
            {
                If (LEqual (Arg0, 0x00))
                {
                    Store (0x00, \_SB.MEM.EWLD)
                }
                Else
                {
                    Store (0x01, \_SB.MEM.EWLD)
                }
            }
        }

        Device (BAT1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x01)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (_STA, 0, NotSerialized)
            {
                If (\_SB.MEM.BES1)
                {
                    Return (0x1F)
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Method (_BIF, 0, NotSerialized)
            {
                Name (BUFF, Package (0x0D) {})
                Store (0x00, Index (BUFF, 0x00))
                Store (\_SB.MEM.BDV1, Local2)
                Multiply (\_SB.MEM.BDC1, Local2, Local0)
                Divide (Local0, 0x03E8, Local1, Local0)
                Store (Local0, Index (BUFF, 0x01))
                Multiply (\_SB.MEM.BLF1, Local2, Local0)
                Divide (Local0, 0x03E8, Local1, Local0)
                Store (Local0, Index (BUFF, 0x02))
                Store (\_SB.MEM.BTC1, Index (BUFF, 0x03))
                Store (\_SB.MEM.BDV1, Index (BUFF, 0x04))
                Multiply (\_SB.MEM.BCW1, Local2, Local0)
                Divide (Local0, 0x03E8, Local1, Local0)
                Store (Local0, Index (BUFF, 0x05))
                Multiply (\_SB.MEM.BCL1, Local2, Local0)
                Divide (Local0, 0x03E8, Local1, Local0)
                Store (Local0, Index (BUFF, 0x06))
                Multiply (\_SB.MEM.BG11, Local2, Local0)
                Divide (Local0, 0x03E8, Local1, Local0)
                Store (Local0, Index (BUFF, 0x07))
                Multiply (\_SB.MEM.BG21, Local2, Local0)
                Divide (Local0, 0x03E8, Local1, Local0)
                Store (Local0, Index (BUFF, 0x08))
                Store (\_SB.MEM.BMN1, Index (BUFF, 0x09))
                Store (\_SB.MEM.BSN1, Index (BUFF, 0x0A))
                Store (\_SB.MEM.BTP1, Index (BUFF, 0x0B))
                Store (\_SB.MEM.BOI1, Index (BUFF, 0x0C))
                Return (BUFF)
            }

            Method (_BST, 0, NotSerialized)
            {
                If (\_SB.MEM.BES2)
                {
                    And (\_SB.MEM.BST1, 0x03, Local0)
                    And (\_SB.MEM.BST2, 0x03, Local1)
                    If (LOr (Local0, Local1))
                    {
                        Multiply (\_SB.MEM.BPR1, \_SB.MEM.BDV1, Local0)
                        Divide (Local0, 0x07D0, Local1, Local0)
                    }
                    Else
                    {
                        Store (0x00, Local0)
                    }
                }
                Else
                {
                    If (LAnd (\_SB.MEM.BST1, 0x03))
                    {
                        Multiply (\_SB.MEM.BPR1, \_SB.MEM.BDV1, Local0)
                        Divide (Local0, 0x03E8, Local1, Local0)
                    }
                    Else
                    {
                        Store (0x00, Local0)
                    }
                }

                Name (BUFF, Package (0x04) {})
                Store (\_SB.MEM.BST1, Index (BUFF, 0x00))
                Store (Local0, Index (BUFF, 0x01))
                Multiply (\_SB.MEM.BRC1, \_SB.MEM.BDV1, Local0)
                Divide (Local0, 0x03E8, Local1, Local0)
                Store (Local0, Index (BUFF, 0x02))
                Store (\_SB.MEM.BPV1, Index (BUFF, 0x03))
                Return (BUFF)
            }

            Method (_BTP, 1, NotSerialized)
            {
                Store (0x01, \_SB.MEM.PAR1)
                Store (Arg0, \_SB.MEM.PAR2)
                Store (0x61, \_SB.PCI0.FNC0.SYSR.TRP4)
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Name (_PRW, Package (0x02)
            {
                0x08, 
                0x04
            })
            Name (_STA, 0x0B)
        }

        Device (ADP1)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x02)
            {
                \_SB, 
                \_SB.BAT1
            })
            Name (_STA, 0x0F)
            Method (_PSR, 0, NotSerialized)
            {
                Return (\_SB.MEM.ACST)
            }
        }

        Device (VALZ)
        {
            Name (_HID, EisaId ("TOS6208"))
            Name (_DDN, "VALZeneral")
            Method (_STA, 0, NotSerialized)
            {
                If (\_SB.MEM.WAKS)
                {
                    While (LEqual (\_SB.MEM.ACVA, 0x00)) {}
                    Store (0x00, \_SB.MEM.WAKS)
                }

                Return (0x0B)
            }

            Method (ENAB, 0, NotSerialized)
            {
                Store (0x01, \_SB.MEM.VALF)
                SMBR (0xFF00, 0x16, 0x01, 0x00, 0xB2)
            }

            Method (INFO, 0, NotSerialized)
            {
                Store (0x00, \_SB.MEM.OECX)
                SMBR (0xFE00, 0x16, 0x00, 0x00, 0xB2)
                If (LNotEqual (\_SB.MEM.OEAX, 0x00))
                {
                    Store (0x00, \_SB.MEM.OECX)
                }

                Return (\_SB.MEM.OECX)
            }

            Method (GHCI, 6, Serialized)
            {
                CreateDWordField (Arg0, 0x00, REAX)
                CreateWordField (Arg1, 0x00, R_BX)
                And (REAX, 0xFF00, Local0)
                If (LEqual (Local0, 0xFE00))
                {
                    If (LEqual (R_BX, 0xC000))
                    {
                        Return (G000 (Local0, R_BX, Arg2, Arg3, Arg4, Arg5))
                    }

                    If (LEqual (R_BX, 0xC800))
                    {
                        Return (G800 (Local0, R_BX, Arg2, Arg3, Arg4, Arg5))
                    }

                    If (LEqual (R_BX, 0xC801))
                    {
                        Return (G801 (Local0, R_BX, Arg2, Arg3, Arg4, Arg5))
                    }
                }

                If (LEqual (Local0, 0xFF00))
                {
                    If (LEqual (R_BX, 0xC000))
                    {
                        Return (G000 (Local0, R_BX, Arg2, Arg3, Arg4, Arg5))
                    }

                    If (LEqual (R_BX, 0xC801))
                    {
                        Return (G801 (Local0, R_BX, Arg2, Arg3, Arg4, Arg5))
                    }
                }

                Return (GCH0 (Arg0, Arg1, Arg2, Arg3, Arg4, Arg5))
            }

            Method (GCH0, 6, NotSerialized)
            {
                Store (Arg4, \_SB.MEM.IESI)
                Store (Arg5, \_SB.MEM.IEDI)
                SMBR (Arg0, Arg1, Arg2, Arg3, 0xB2)
                Name (BUFF, Package (0x06) {})
                Store (\_SB.MEM.OEAX, Index (BUFF, 0x00))
                Store (\_SB.MEM.OEBX, Index (BUFF, 0x01))
                Store (\_SB.MEM.OECX, Index (BUFF, 0x02))
                Store (\_SB.MEM.OEDX, Index (BUFF, 0x03))
                Store (\_SB.MEM.OESI, Index (BUFF, 0x04))
                Store (\_SB.MEM.OEDI, Index (BUFF, 0x05))
                Return (BUFF)
            }

            Method (G000, 6, NotSerialized)
            {
                Name (BUFF, Package (0x06) {})
                CreateDWordField (Arg2, 0x00, RECX)
                CreateDWordField (Arg3, 0x00, REDX)
                CreateDWordField (Arg4, 0x00, RESI)
                CreateDWordField (Arg5, 0x00, REDI)
                CreateByteField (Arg2, 0x00, R_CL)
                Store (0x00, Index (BUFF, 0x00))
                Store (Arg1, Index (BUFF, 0x01))
                Store (RECX, Index (BUFF, 0x02))
                Store (REDX, Index (BUFF, 0x03))
                Store (RESI, Index (BUFF, 0x04))
                Store (REDI, Index (BUFF, 0x05))
                If (\_SB.MEM.GCVS)
                {
                    If (LEqual (Arg0, 0xFE00))
                    {
                        If (LEqual (R_CL, 0x00))
                        {
                            Store (\_SB.MEM.TNVS, Local0)
                            Store (Local0, Index (BUFF, 0x02))
                        }
                        Else
                        {
                            If (LAnd (LGreaterEqual (R_CL, 0x01), LLessEqual (R_CL, 0x04)))
                            {
                                Store (R_CL, Local0)
                                Or (Local0, 0x3000, Local0)
                                SMBR (0xFA00, Local0, 0x00, 0x00, 0xB2)
                                Store (\_SB.MEM.OECX, Index (BUFF, 0x02))
                                Store (\_SB.MEM.OEDX, Index (BUFF, 0x03))
                            }
                            Else
                            {
                                If (LEqual (R_CL, 0x05))
                                {
                                    Store (0x21, Index (BUFF, 0x02))
                                }
                                Else
                                {
                                    Store (0x8300, Index (BUFF, 0x00))
                                }
                            }
                        }
                    }
                    Else
                    {
                        CreateWordField (Arg3, 0x00, R_DX)
                        If (LEqual (R_CL, 0x00))
                        {
                            If (LEqual (R_DX, 0x00))
                            {
                                Store (0x00, \_SB.MEM.TNVS)
                            }
                            Else
                            {
                                Store (0x01, \_SB.MEM.TNVS)
                            }
                        }
                        Else
                        {
                            If (LEqual (R_CL, 0x01))
                            {
                                Store (R_CL, Local0)
                                Or (Local0, 0x3080, Local0)
                                SMBR (0xFA00, Local0, R_DX, 0x00, 0xB2)
                            }
                            Else
                            {
                                If (LEqual (R_CL, 0x02))
                                {
                                    FindSetRightBit (R_DX, Local0)
                                    Store (Local0, \_SB.MEM.NXDD)
                                    If (LLess (\_SB.MEM.OSID, 0x03))
                                    {
                                        Or (Local0, 0x0100, Local0)
                                        SMBR (0xFF00, 0x1C, Local0, 0x00, 0xB2)
                                        And (\_SB.MEM.OEAX, 0xFF00, Local0)
                                        If (LEqual (Local0, 0x00))
                                        {
                                            Store (0x80, Local0)
                                            While (LEqual (Local0, 0x80))
                                            {
                                                SMBR (0xFE00, 0x1C, 0x00, 0x00, 0xB2)
                                                And (\_SB.MEM.OECX, 0x80, Local0)
                                            }

                                            If (\_SB.MEM.CTLA)
                                            {
                                                If (LEqual (\_SB.MEM.LCDS, 0x00))
                                                {
                                                    SMBR (0xFF00, 0x02, 0x01, 0x00, 0xB2)
                                                    Store (0x01, \_SB.MEM.OEDX)
                                                    While (\_SB.MEM.OEDX)
                                                    {
                                                        SMBR (0xFE00, 0x02, 0x00, 0x00, 0xB2)
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    Else
                                    {
                                        Notify (\_SB.PCI0.VGA, 0x80)
                                    }
                                }
                                Else
                                {
                                    Store (0x8300, Index (BUFF, 0x00))
                                }
                            }
                        }
                    }
                }
                Else
                {
                    Store (0x8000, Index (BUFF, 0x00))
                }

                Return (BUFF)
            }

            Method (G800, 6, NotSerialized)
            {
                Store (\_SB.MEM.OSPC, Local0)
                Name (BUFF, Package (0x06) {})
                CreateDWordField (Arg3, 0x00, REDX)
                CreateDWordField (Arg4, 0x00, RESI)
                CreateDWordField (Arg5, 0x00, REDI)
                Store (0x00, Index (BUFF, 0x00))
                Store (Arg1, Index (BUFF, 0x01))
                Store (Local0, Index (BUFF, 0x02))
                Store (REDX, Index (BUFF, 0x03))
                Store (RESI, Index (BUFF, 0x04))
                Store (REDI, Index (BUFF, 0x05))
                Return (BUFF)
            }

            Method (G801, 6, NotSerialized)
            {
                CreateDWordField (Arg2, 0x00, RECX)
                CreateDWordField (Arg3, 0x00, REDX)
                CreateDWordField (Arg4, 0x00, RESI)
                CreateDWordField (Arg5, 0x00, REDI)
                Store (0x8300, Local0)
                Store (RECX, Local1)
                If (LEqual (REDX, 0x01))
                {
                    Store (0x00, Local0)
                    If (LEqual (Arg0, 0xFE00))
                    {
                        Store (\_SB.MEM.PULD, Local1)
                        Store (\_SB.MEM.PULA, Local2)
                        ShiftLeft (Local2, 0x08, Local2)
                        Or (Local1, Local2, Local1)
                    }
                    Else
                    {
                        And (Local1, 0xFF, Local2)
                        ShiftRight (Local1, 0x08, Local3)
                        Store (Local2, \_SB.MEM.PULD)
                        Store (Local3, \_SB.MEM.PULA)
                    }
                }

                If (LEqual (REDX, 0x02))
                {
                    Store (0x00, Local0)
                    If (LEqual (Arg0, 0xFE00))
                    {
                        Store (\_SB.MEM.BCLD, Local1)
                        Store (\_SB.MEM.BCLA, Local2)
                        ShiftLeft (Local2, 0x08, Local2)
                        Or (Local1, Local2, Local1)
                    }
                    Else
                    {
                        And (Local1, 0xFF, Local2)
                        ShiftRight (Local1, 0x08, Local3)
                        Store (Local2, \_SB.MEM.BCLD)
                        Store (Local3, \_SB.MEM.BCLA)
                    }
                }

                Name (BUFF, Package (0x06) {})
                Store (Local0, Index (BUFF, 0x00))
                Store (Arg1, Index (BUFF, 0x01))
                Store (Local1, Index (BUFF, 0x02))
                Store (REDX, Index (BUFF, 0x03))
                Store (RESI, Index (BUFF, 0x04))
                Store (REDI, Index (BUFF, 0x05))
                Return (BUFF)
            }

            Method (VNTF, 1, NotSerialized)
            {
                And (Arg0, 0xFFFF, Local0)
                ShiftRight (Arg0, 0x10, Local1)
                If (LEqual (Local1, 0x01))
                {
                    Notify (\_PR.CPU0, Local0)
                }
            }

            Method (VCID, 0, NotSerialized)
            {
                Store (0x00, \_SB.MEM.RDID)
                Store (0x05, \_SB.PCI0.FNC0.SYSR.TRP4)
                Store (\_SB.MEM.RDID, \_SB.MEM.DLID)
                If (\_SB.MEM.DLID)
                {
                    Store (0x01, \_SB.MEM.DCKD)
                }

                Return (\_SB.MEM.RDID)
            }

            Method (VUID, 0, NotSerialized)
            {
                Store (0x00, \_SB.MEM.RDSN)
                Store (0x05, \_SB.PCI0.FNC0.SYSR.TRP4)
                Store (\_SB.MEM.RDSN, \_SB.MEM.DSRN)
                Return (\_SB.MEM.RDSN)
            }

            Method (VDCK, 1, NotSerialized)
            {
                If (Arg0)
                {
                    Store (0x05, \_SB.PCI0.FNC0.SYSR.TRP4)
                    If (\_SB.MEM.PAR1)
                    {
                        Store (0x41, \_SB.PCI0.FNC0.SYSR.TRP4)
                        Reset (\_SB.PCI0.PCIB.DKSQ)
                        Wait (\_SB.PCI0.PCIB.DKSQ, 0x0BB8)
                        Notify (\_SB.PCI0.VGA, 0x80)
                        Return (One)
                    }

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

            Method (VEJ0, 1, NotSerialized)
            {
                If (\_SB.MEM.DCKD)
                {
                    Store (0x00, \_SB.MEM.DCKD)
                    Store (0x40, \_SB.PCI0.FNC0.SYSR.TRP4)
                    Reset (\_SB.PCI0.PCIB.DKSQ)
                    Wait (\_SB.PCI0.PCIB.DKSQ, 0x1388)
                }

                Store (0x00, \_SB.MEM.DLID)
                Store (0x00, \_SB.MEM.DSRN)
                Notify (\_SB.VALZ, 0x83)
                Notify (\_SB.PCI0.VGA, 0x80)
                Notify (\_PR.CPU0, 0x80)
            }

            Method (DLSZ, 0, NotSerialized)
            {
                Return (0x05)
            }

            Method (DLIB, 0, NotSerialized)
            {
                Name (BUFF, Buffer (0x50)
                {
                    /* 0000 */    0x80, 0x00, 0x03, 0x0C, 0x02, 0xE8, 0x00, 0x00, 
                    /* 0008 */    0x86, 0x80, 0xC2, 0x24, 0x00, 0x00, 0x00, 0x00, 
                    /* 0010 */    0x80, 0x00, 0x03, 0x0C, 0x01, 0xE9, 0x00, 0x00, 
                    /* 0018 */    0x86, 0x80, 0xC4, 0x24, 0x00, 0x00, 0x00, 0x00, 
                    /* 0020 */    0x80, 0x20, 0x03, 0x0C, 0x02, 0xEF, 0x00, 0x00, 
                    /* 0028 */    0x86, 0x80, 0xCD, 0x24, 0x00, 0x00, 0x00, 0x00, 
                    /* 0030 */    0x80, 0x20, 0x03, 0x0C, 0x03, 0xEF, 0x00, 0x00, 
                    /* 0038 */    0x86, 0x80, 0xCD, 0x24, 0x00, 0x00, 0x00, 0x00, 
                    /* 0040 */    0x80, 0x10, 0x00, 0x0C, 0x02, 0x5A, 0xFF, 0x00, 
                    /* 0048 */    0x4C, 0x10, 0x32, 0x80, 0x00, 0x00, 0x00, 0x00
                })
                Store (\_SB.PCI0.PCIB.BRGB, Local0)
                CreateByteField (BUFF, 0x46, BNO4)
                Store (Local0, BNO4)
                Return (BUFF)
            }

            Method (ODLS, 0, NotSerialized)
            {
                Return (0x01)
            }

            Method (ODLB, 0, NotSerialized)
            {
                Name (BUFF, Buffer (0x10)
                {
                    /* 0000 */    0x86, 0x80, 0xCA, 0x24, 0x79, 0x11, 0x01, 0x00, 
                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                })
                Store (\_SB.PCI0.FNC1.RVID, Local0)
                CreateByteField (BUFF, 0x08, IREV)
                Store (Local0, IREV)
                Return (BUFF)
            }

            Method (BDDS, 0, NotSerialized)
            {
                Return (\_SB.MEM.DDS0)
            }

            Method (PLST, 0, NotSerialized)
            {
                Name (BUFF, Buffer (0x01)
                {
                    0x00
                })
                CreateBitField (BUFF, 0x00, PNL0)
                CreateBitField (BUFF, 0x01, PNL1)
                Store (\_SB.MEM.PNLS, PNL0)
                Store (\_SB.MEM.LIDS, PNL1)
                Return (BUFF)
            }
        }

        Device (HAPS)
        {
            Name (_HID, EisaId ("TOS620A"))
            Method (PTLV, 1, NotSerialized)
            {
                Store (Arg0, Local0)
                Or (Local0, 0x3500, Local0)
                SMBR (0xFA00, Local0, 0x00, 0x00, 0xB2)
            }

            Method (RSSS, 0, NotSerialized)
            {
                SMBR (0xFA00, 0x3580, 0x00, 0x00, 0xB2)
            }
        }
    }

    Scope (\_TZ)
    {
        ThermalZone (THRM)
        {
            Method (_TMP, 0, NotSerialized)
            {
                If (LLessEqual (\_SB.MEM.TMP1, 0x0B4C))
                {
                    Store (0x0B4C, \_SB.MEM.AST1)
                    Return (0x0B4C)
                }
                Else
                {
                    Store (\_SB.MEM.TMP1, \_SB.MEM.AST1)
                    Return (\_SB.MEM.TMP1)
                }
            }

            Method (_CRT, 0, NotSerialized)
            {
                Return (\_SB.MEM.CRT1)
            }
        }
    }

    Scope (\_GPE)
    {
        Method (_L03, 0, Serialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
            Store (0x00, \_SB.MEM.GP75)
        }

        Method (_L04, 0, Serialized)
        {
            Notify (\_SB.PCI0.USB2, 0x02)
            Store (0x00, \_SB.MEM.GP75)
        }

        Method (_L05, 0, Serialized)
        {
            If (\_SB.MEM.GP73)
            {
                Store (0x00, \_SB.MEM.GP73)
                Notify (\_SB.PCI0.AMDM, 0x02)
            }
        }

        Method (_L0C, 0, Serialized)
        {
            Notify (\_SB.PCI0.USB3, 0x02)
            Store (0x00, \_SB.MEM.GP75)
        }

        Method (_L0B, 0, Serialized)
        {
            Notify (\_SB.PCI0.PCIB, 0x02)
        }

        Method (_L0D, 0, Serialized)
        {
            If (\_SB.MEM.GP77)
            {
                Store (0x00, \_SB.MEM.GP77)
                Notify (\_SB.PCI0.USB4, 0x02)
            }
        }

        Method (_L1C, 0, Serialized)
        {
            Increment (Local0)
        }
    }

    Method (_PTS, 1, NotSerialized)
    {
        If (\_SB.MEM.SPSC)
        {
            SMBR (0xFE00, 0x14, 0x00, 0x00, 0xB2)
            And (\_SB.MEM.OECX, 0x02, Local0)
            If (Local0)
            {
                Store (0x01, \_SB.MEM.IESI)
                Store (0x02, \_SB.MEM.IEDI)
                SMBR (0xFE00, 0x23, 0xF9, 0x00, 0xB2)
                If (LNotEqual (\_SB.MEM.OEDX, 0x03))
                {
                    Store (0x01, \_SB.MEM.IESI)
                    Store (0x02, \_SB.MEM.IEDI)
                    SMBR (0xFF00, 0x23, 0xF9, 0x03, 0xB2)
                    Store (0x01, \_SB.MEM.OECX)
                    While (\_SB.MEM.OECX)
                    {
                        Store (0x01, \_SB.MEM.IESI)
                        Store (0x02, \_SB.MEM.IEDI)
                        SMBR (0xFE00, 0x23, 0xF9, 0x00, 0xB2)
                    }
                }
            }
        }

        If (LAnd (LGreaterEqual (Arg0, 0x01), LLessEqual (Arg0, 0x04)))
        {
            Store (\_SB.MEM.EWLD, \_SB.MEM.PAR1)
            Store (0x60, \_SB.PCI0.FNC0.SYSR.TRP4)
        }

        Store (\_SB.MEM.ACST, \_SB.MEM.ACBK)
    }

    Method (TRAP, 1, NotSerialized)
    {
        Add (Arg0, 0x12340000, Debug)
    }

    Method (SMBR, 5, NotSerialized)
    {
        Store (Arg0, \_SB.MEM.IEAX)
        Store (Arg1, \_SB.MEM.IEBX)
        Store (Arg2, \_SB.MEM.IECX)
        Store (Arg3, \_SB.MEM.IEDX)
        Store (Arg4, \_SB.PCI0.FNC0.SYSR.TRP4)
    }

    Method (STA, 1, NotSerialized)
    {
        Store (Arg0, \_SB.MEM.PAR1)
        Store (0x00, \_SB.MEM.PAR2)
        Store (0x00, \_SB.MEM.PAR3)
        Store (0x00, \_SB.MEM.PAR4)
        Store (0x00, \_SB.MEM.PAR5)
        Store (0x00, \_SB.MEM.PAR6)
        Store (0x01, \_SB.PCI0.FNC0.SYSR.TRP4)
        Return (\_SB.MEM.PAR4)
    }

    Method (CRS, 1, NotSerialized)
    {
        Store (Arg0, \_SB.MEM.PAR1)
        Store (0x00, \_SB.MEM.PAR2)
        Store (0x00, \_SB.MEM.PAR3)
        Store (0x00, \_SB.MEM.PAR4)
        Store (0x00, \_SB.MEM.PAR5)
        Store (0x00, \_SB.MEM.PAR6)
        Store (0x01, \_SB.PCI0.FNC0.SYSR.TRP4)
        If (LEqual (\_SB.MEM.PAR3, 0x00))
        {
            Return (ResourceTemplate ()
            {
            })
        }

        Name (BUFF, Buffer (\_SB.MEM.PAR3) {})
        Store (\_SB.MEM.PRES, BUFF)
        Return (BUFF)
    }

    Method (PRS, 1, NotSerialized)
    {
        Store (Arg0, \_SB.MEM.PAR1)
        Store (0x01, \_SB.MEM.PAR2)
        Store (0x00, \_SB.MEM.PAR3)
        Store (0x00, \_SB.MEM.PAR4)
        Store (0x00, \_SB.MEM.PAR5)
        Store (0x00, \_SB.MEM.PAR6)
        Store (0x01, \_SB.PCI0.FNC0.SYSR.TRP4)
        If (LEqual (\_SB.MEM.PAR3, 0x00))
        {
            Return (ResourceTemplate ()
            {
            })
        }

        Name (BUFF, Buffer (\_SB.MEM.PAR3) {})
        Store (\_SB.MEM.PRES, BUFF)
        Return (BUFF)
    }

    Method (SRS, 2, NotSerialized)
    {
        Store (Arg0, \_SB.MEM.PAR1)
        Store (0x00, \_SB.MEM.PAR2)
        Store (0x00, \_SB.MEM.PAR3)
        Store (0x00, \_SB.MEM.PAR4)
        Store (0x00, \_SB.MEM.PAR5)
        Store (0x00, \_SB.MEM.PAR6)
        Store (Arg1, \_SB.MEM.PRES)
        Store (0x02, \_SB.PCI0.FNC0.SYSR.TRP4)
    }

    Method (DIS, 1, NotSerialized)
    {
        Store (Arg0, \_SB.MEM.PAR1)
        Store (0x00, \_SB.MEM.PAR2)
        Store (0x00, \_SB.MEM.PAR3)
        Store (0x00, \_SB.MEM.PAR4)
        Store (0x00, \_SB.MEM.PAR5)
        Store (0x00, \_SB.MEM.PAR6)
        Store (0x03, \_SB.PCI0.FNC0.SYSR.TRP4)
    }

    Method (PS0, 1, NotSerialized)
    {
        Store (0x00, \_SB.MEM.IESI)
        SMBR (0xFE00, 0x23, Arg0, 0x00, 0xB2)
        If (LEqual (\_SB.MEM.OEAX, 0x00))
        {
            Store (0x00, \_SB.MEM.IESI)
            SMBR (0xFF00, 0x23, Arg0, 0x00, 0xB2)
            WPSX (Arg0, 0x00, 0x00, 0x00)
        }
    }

    Method (PS3, 1, NotSerialized)
    {
        Store (0x00, \_SB.MEM.IESI)
        SMBR (0xFE00, 0x23, Arg0, 0x00, 0xB2)
        If (LEqual (\_SB.MEM.OEAX, 0x00))
        {
            Store (0x00, \_SB.MEM.IESI)
            SMBR (0xFF00, 0x23, Arg0, 0x03, 0xB2)
            WPSX (Arg0, 0x00, 0x00, 0x03)
        }
    }

    Method (WPSX, 4, NotSerialized)
    {
        Store (Arg1, \_SB.MEM.IESI)
        Store (Arg2, \_SB.MEM.IEDI)
        SMBR (0xFE00, 0x23, Arg0, 0x00, 0xB2)
        While (LNotEqual (\_SB.MEM.OECX, 0x00))
        {
            Store (Arg1, \_SB.MEM.IESI)
            Store (Arg2, \_SB.MEM.IEDI)
            SMBR (0xFE00, 0x23, Arg0, 0x00, 0xB2)
        }
    }

    Method (PSC, 1, NotSerialized)
    {
        Store (0x00, \_SB.MEM.IESI)
        SMBR (0xFE00, 0x23, Arg0, 0x00, 0xB2)
        Return (\_SB.MEM.OEDX)
    }

    Method (CMPS, 2, NotSerialized)
    {
        If (LEqual (SizeOf (Arg0), SizeOf (Arg1)))
        {
            Return (One)
        }
        Else
        {
            Return (Zero)
        }
    }

    Method (STAL, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x80))
        {
            Return (0x09)
        }
        Else
        {
            Return (0x0B)
        }
    }

    Method (CRSL, 1, NotSerialized)
    {
        Name (IRQB, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, _Y01)
                {}
        })
        CreateWordField (IRQB, \CRSL._Y01._INT, INTX)
        If (LLess (Arg0, 0x10))
        {
            And (Arg0, 0x0F, Local0)
            ShiftLeft (0x01, Local0, INTX)
        }

        Return (IRQB)
    }

    Mutex (MTEX, 0x00)
}