/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20050624
 *
 * Disassembly of u100.aml, Sat Aug 27 19:07:36 2005
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "TOSHIB", "A0029   ", 537199409)
{
    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, 
                Offset (0x401), 
                GP60,   1, 
                GP61,   1, 
                GP62,   1, 
                GP63,   1, 
                GP64,   1, 
                GP65,   1, 
                GP66,   1, 
                Offset (0x402), 
                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, 
                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, 
                IEWE,   1, 
                Offset (0x515), 
                BTMD,   1, 
                WSF0,   1, 
                WSF1,   1, 
                GP83,   1, 
                WUIE,   1, 
                    ,   1, 
                BPFE,   1, 
                BWUE,   1, 
                DVIS,   4, 
                Offset (0x517), 
                HTM0,   1, 
                HTM1,   1, 
                    ,   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 (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, 
                HVBS,   2, 
                Offset (0x708), 
                TNVS,   1, 
                OSPC,   1, 
                ACBK,   1, 
                LBAT,   1, 
                LANB,   1, 
                Offset (0x70A), 
                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, // Address Space Granularity
                        0x0000, // Address Range Minimum
                        0x00FF, // Address Range Maximum
                        0x0000, // Address Translation Offset
                        0x0100,,,)
                    IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000, // Address Space Granularity
                        0x0000, // Address Range Minimum
                        0x0CF7, // Address Range Maximum
                        0x0000, // Address Translation Offset
                        0x0CF8,,,
                        , TypeStatic)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000, // Address Space Granularity
                        0x0D00, // Address Range Minimum
                        0xFFFF, // Address Range Maximum
                        0x0000, // Address Translation Offset
                        0xF300,,,
                        , TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000, // Address Space Granularity
                        0x000A0000, // Address Range Minimum
                        0x000BFFFF, // Address Range Maximum
                        0x00000000, // Address Translation Offset
                        0x00020000,,,
                        , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000, // Address Space Granularity
                        0x000D0000, // Address Range Minimum
                        0x000DFFFF, // Address Range Maximum
                        0x00000000, // Address Translation Offset
                        0x00010000,,,
                        , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000, // Address Space Granularity
                        0x80100000, // Address Range Minimum
                        0xFEC0FFFF, // Address Range Maximum
                        0x00000000, // Address Translation Offset
                        0x7EB10000,,,
                        , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000, // Address Space Granularity
                        0xFEC20000, // Address Range Minimum
                        0xFED9FFFF, // Address Range Maximum
                        0x00000000, // Address Translation Offset
                        0x00180000,,,
                        , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000, // Address Space Granularity
                        0xFEDC0000, // Address Range Minimum
                        0xFFAFFFFF, // Address Range Maximum
                        0x00000000, // Address Translation Offset
                        0x00D40000,,,
                        , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                        0x00000000, // Address Space Granularity
                        0xFFC00000, // Address Range Minimum
                        0xFFE7FFFF, // Address Range Maximum
                        0x00000000, // Address Translation Offset
                        0x00280000,,,
                        , AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (CRBF, 0x5C, EMMS)
                CreateDWordField (CRBF, 0x68, 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
                    }

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

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

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

                Device (IEEE)
                {
                    Name (_ADR, 0x000B0002)
                }

                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, 0x0000, 0x01, 0x10)
                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x03)
                        IO (Decode16, 0x0087, 0x0087, 0x01, 0x01)
                        IO (Decode16, 0x0089, 0x0089, 0x01, 0x03)
                        IO (Decode16, 0x008F, 0x008F, 0x01, 0x01)
                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
                        DMA (Compatibility, NotBusMaster, Transfer8) {4}
                    })
                }

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

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

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800"))
                    Name (_STA, 0x0F)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
                    })
                }

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

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        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, 0x0070, 0x01, 0x02)
                        IRQ (Edge, ActiveHigh, Exclusive) {8}
                    })
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_STA, 0x0F)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x0084, 0x0084, 0x01, 0x03)
                        IO (Decode16, 0x0088, 0x0088, 0x01, 0x01)
                        IO (Decode16, 0x008C, 0x008C, 0x01, 0x03)
                        IO (Decode16, 0x01E0, 0x01E0, 0x01, 0x10)
                        IO (Decode16, 0x0480, 0x0480, 0x01, 0x10)
                        IO (Decode16, 0x0680, 0x0680, 0x80, 0x80)
                        IO (Decode16, 0xD800, 0xD800, 0x01, 0x80)
                        IO (Decode16, 0xD880, 0xD880, 0x01, 0x20)
                        IO (Decode16, 0xE000, 0xE000, 0x01, 0x80)
                        IO (Decode16, 0xE080, 0xE080, 0x01, 0x80)
                        IO (Decode16, 0xE400, 0xE400, 0x01, 0x80)
                        IO (Decode16, 0xE480, 0xE480, 0x01, 0x80)
                        IO (Decode16, 0xE800, 0xE800, 0x01, 0x80)
                        IO (Decode16, 0xE880, 0xE880, 0x01, 0x80)
                        IO (Decode16, 0xEC00, 0xEC00, 0x01, 0x80)
                        IO (Decode16, 0xEC80, 0xEC80, 0x01, 0x80)
                        IO (Decode16, 0xEEB0, 0xEEB0, 0x01, 0x10)
                        IO (Decode16, 0xEEC0, 0xEEC0, 0x01, 0x40)
                        IO (Decode16, 0x0010, 0x0010, 0x01, 0x10)
                        IO (Decode16, 0x0024, 0x0024, 0x01, 0x02)
                        IO (Decode16, 0x0028, 0x0028, 0x01, 0x02)
                        IO (Decode16, 0x002C, 0x002C, 0x01, 0x02)
                        IO (Decode16, 0x0030, 0x0030, 0x01, 0x02)
                        IO (Decode16, 0x0034, 0x0034, 0x01, 0x02)
                        IO (Decode16, 0x0038, 0x0038, 0x01, 0x02)
                        IO (Decode16, 0x003C, 0x003C, 0x01, 0x02)
                        IO (Decode16, 0x0050, 0x0050, 0x01, 0x04)
                        IO (Decode16, 0x0063, 0x0063, 0x01, 0x01)
                        IO (Decode16, 0x0065, 0x0065, 0x01, 0x01)
                        IO (Decode16, 0x0072, 0x0072, 0x01, 0x06)
                        IO (Decode16, 0x0090, 0x0090, 0x01, 0x10)
                        IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
                        IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x06)
                        IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
                        IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                    })
                    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 (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 (LNot (LGreater (Local1, 0x78)))
                        {
                            Store (0xA3, Local4)
                            Store (0x03, Local7)
                        }
                        Else
                        {
                            If (LNot (LGreater (Local1, 0xB4)))
                            {
                                Store (0xA1, Local4)
                                Store (0x03, Local7)
                            }
                            Else
                            {
                                If (LNot (LGreater (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 (LNot (LGreater (Local2, 0x14)))
                            {
                                Store (0x01, Local6)
                                Store (0x01, Local4)
                            }
                            Else
                            {
                                If (LNot (LGreater (Local2, 0x1E)))
                                {
                                    Store (0x02, Local4)
                                    Store (0x01, Local5)
                                }
                                Else
                                {
                                    If (LNot (LGreater (Local2, 0x3C)))
                                    {
                                        Store (0x02, Local4)
                                    }
                                    Else
                                    {
                                        If (LNot (LGreater (Local2, 0x5A)))
                                        {
                                            Store (0x01, Local4)
                                        }
                                    }
                                }
                            }
                        }
                        Else
                        {
                            If (LAnd (LNot (LGreater (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)
                            {
                                0x03, 0x0C, 0x00, 0x00, 0x00, 0x00, 0xEF, 0x03, 
                                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 (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 (0x02)
                    {
                        0x0400, 
                        0x0100
                    })
                    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, 0x0400)
                    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 (0x05)
                        {
                            0x64, 
                            0x28, 
                            0x00, 
                            0x28, 
                            0x64
                        })
                        If (\_SB.MEM.HPSU)
                        {
                            Store (\_SB.MEM.BCLA, Index (BUFF, 0x00))
                            Store (\_SB.MEM.BCLD, Index (BUFF, 0x01))
                        }

                        Return (BUFF)
                    }

                    Method (_BCM, 1, NotSerialized)
                    {
                        If (LEqual (\_SB.MEM.HPSU, 0x00))
                        {
                            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 (USB1)
            {
                Name (_ADR, 0x001D0000)
                Device (HUB1)
                {
                    Name (_ADR, 0x00)
                    Device (POT1)
                    {
                        Name (_ADR, 0x01)
                    }

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

                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)
                    Device (POT3)
                    {
                        Name (_ADR, 0x01)
                        Method (_EJ0, 1, NotSerialized)
                        {
                            SMBR (0xFA00, 0x3100, 0x00, 0x00, 0xB2)
                            Reset (\_SB.PCI0.PCIB.SBSQ)
                            Wait (\_SB.PCI0.PCIB.SBSQ, 0x1388)
                        }
                    }
                }
            }

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

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

                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 (PT21)
                    {
                        Name (_ADR, 0x01)
                    }

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

                    Device (PT23)
                    {
                        Name (_ADR, 0x03)
                        Method (_EJ0, 1, NotSerialized)
                        {
                            SMBR (0xFA00, 0x3100, 0x00, 0x00, 0xB2)
                            Reset (\_SB.PCI0.PCIB.SBSQ)
                            Wait (\_SB.PCI0.PCIB.SBSQ, 0x1388)
                        }
                    }

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

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

            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)
                While (LEqual (\_SB.MEM.BTRE, 0x00)) {}
                SMBR (0xFF00, 0x1E, 0x01, 0x00, 0xB2)
                Store (0x01, \_SB.MEM.PAR1)
                Store (0x60, \_SB.PCI0.FNC0.SYSR.TRP4)
            }
        }

        Device (BT)
        {
            Name (_HID, "TOS6205")
            Method (_STA, 0, NotSerialized)
            {
                If (\_SB.MEM.BTMD)
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (0x00)
                }
            }

            Method (BTST, 0, NotSerialized)
            {
                Store (0x00, \_SB.MEM.OESI)
                SMBR (0xFE00, 0x4D, 0x01, 0x7D00, 0xB2)
                Store (0x01, Local0)
                While (Local0)
                {
                    SMBR (0xFE00, 0x4D, 0x0101, 0x7D00, 0xB2)
                    Store (\_SB.MEM.OESI, Local2)
                    And (\_SB.MEM.OEAX, 0xFF00, Local1)
                    If (Local1)
                    {
                        And (\_SB.MEM.OEAX, 0xFF, Local1)
                        If (LNot (LEqual (Local1, 0x20)))
                        {
                            Store (0x00, Local2)
                            Store (0x00, Local0)
                        }
                    }
                    Else
                    {
                        Store (0x00, Local0)
                    }
                }

                And (Local2, 0x02, Local0)
                ShiftLeft (Local0, 0x06, Local0)
                And (Local2, 0x04, Local1)
                ShiftLeft (Local1, 0x04, Local1)
                Or (Local0, Local1, Local0)
                And (Local2, 0x10, Local3)
                ShiftRight (Local3, 0x04, Local3)
                Or (Local0, Local3, Local0)
                Return (Local0)
            }

            Method (AUSB, 0, NotSerialized)
            {
                If (\_SB.MEM.BTMD)
                {
                    Store (0x00, \_SB.MEM.IEDI)
                    Store (0x03, \_SB.MEM.IESI)
                    SMBR (0xFF00, 0x4D, 0x01, 0x7C00, 0xB2)
                    Store (0x01, Local0)
                    While (Local0)
                    {
                        SMBR (0xFF00, 0x4D, 0x0101, 0x7C00, 0xB2)
                        And (\_SB.MEM.OEAX, 0xFF00, Local1)
                        If (Local1)
                        {
                            And (\_SB.MEM.OEAX, 0xFF, Local1)
                            If (LNot (LEqual (Local1, 0x20)))
                            {
                                Store (0x00, Local0)
                            }
                        }
                        Else
                        {
                            Store (0x00, Local0)
                        }
                    }
                }
            }

            Method (DUSB, 0, NotSerialized)
            {
                If (\_SB.MEM.BTMD)
                {
                    Store (0x00, \_SB.MEM.IEDI)
                    Store (0x04, \_SB.MEM.IESI)
                    SMBR (0xFF00, 0x4D, 0x01, 0x7C00, 0xB2)
                    Store (0x01, Local0)
                    While (Local0)
                    {
                        SMBR (0xFF00, 0x4D, 0x0101, 0x7C00, 0xB2)
                        And (\_SB.MEM.OEAX, 0xFF00, Local1)
                        If (Local1)
                        {
                            And (\_SB.MEM.OEAX, 0xFF, Local1)
                            If (LNot (LEqual (Local1, 0x20)))
                            {
                                Store (0x00, Local0)
                            }
                        }
                        Else
                        {
                            Store (0x00, Local0)
                        }
                    }
                }
            }

            Method (BTPO, 0, NotSerialized)
            {
                If (\_SB.MEM.BTMD)
                {
                    Store (0x00, \_SB.MEM.IEDI)
                    Store (0x01, \_SB.MEM.IESI)
                    SMBR (0xFF00, 0x4D, 0x01, 0x7C00, 0xB2)
                    Store (0x01, Local0)
                    While (Local0)
                    {
                        SMBR (0xFF00, 0x4D, 0x0101, 0x7C00, 0xB2)
                        And (\_SB.MEM.OEAX, 0xFF00, Local1)
                        If (Local1)
                        {
                            And (\_SB.MEM.OEAX, 0xFF, Local1)
                            If (LNot (LEqual (Local1, 0x20)))
                            {
                                Store (0x00, Local0)
                            }
                        }
                        Else
                        {
                            Store (0x00, Local0)
                        }
                    }
                }
            }

            Method (BTPF, 0, NotSerialized)
            {
                If (\_SB.MEM.BTMD)
                {
                    Store (0x00, \_SB.MEM.IEDI)
                    Store (0x02, \_SB.MEM.IESI)
                    SMBR (0xFF00, 0x4D, 0x01, 0x7C00, 0xB2)
                    Store (0x01, Local0)
                    While (Local0)
                    {
                        SMBR (0xFF00, 0x4D, 0x0101, 0x7C00, 0xB2)
                        And (\_SB.MEM.OEAX, 0xFF00, Local1)
                        If (Local1)
                        {
                            And (\_SB.MEM.OEAX, 0xFF, Local1)
                            If (LNot (LEqual (Local1, 0x20)))
                            {
                                Store (0x00, Local0)
                            }
                        }
                        Else
                        {
                            Store (0x00, Local0)
                        }
                    }
                }
            }
        }

        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 (LNot (LEqual (\_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, 0xC004))
                    {
                        Return (G004 (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 (LNot (LLess (R_CL, 0x01)), LNot (LGreater (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 (G004, 6, NotSerialized)
            {
                CreateByteField (Arg2, 0x00, R_CL)
                Name (BUFF, Package (0x06) {})
                Store (Arg1, Index (BUFF, 0x01))
                Store (Arg4, Index (BUFF, 0x04))
                Store (Arg5, Index (BUFF, 0x05))
                If (LNot (LGreater (R_CL, 0x01)))
                {
                    And (Arg2, 0xFFFF00FF, Local0)
                    Store (Local0, Index (BUFF, 0x02))
                    And (Arg3, 0xFFFF0000, Local0)
                    Store (Local0, Index (BUFF, 0x03))
                    Store (0x00, Local0)
                }
                Else
                {
                    Store (Arg2, Index (BUFF, 0x02))
                    Store (Arg3, Index (BUFF, 0x03))
                    Store (0x8300, Local0)
                }

                Store (Local0, 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 (EHSS, 0, NotSerialized)
            {
                Name (BUFF, Buffer (0x20)
                {
                    0x07, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 
                    0x32, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
                    0x03, 0x00, 0x00, 0x00, 0x5E, 0x01, 0x00, 0x00, 
                    0x3C, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00
                })
                If (LNot (LEqual (\_SB.MEM.MSP0, 0x00)))
                {
                    CreateWordField (BUFF, 0x00, INF0)
                    CreateDWordField (BUFF, 0x04, SSP0)
                    CreateDWordField (BUFF, 0x08, SSP1)
                    CreateDWordField (BUFF, 0x0C, SSCH)
                    CreateDWordField (BUFF, 0x10, SSCL)
                    CreateDWordField (BUFF, 0x14, SSSI)
                    CreateDWordField (BUFF, 0x18, SSS0)
                    CreateDWordField (BUFF, 0x1C, SSR0)
                    Divide (SizeOf (BUFF), 0x04, Local1, Local0)
                    Decrement (Local0)
                    Store (Local0, INF0)
                    Store (\_SB.MEM.MSP0, SSP0)
                    Store (\_SB.MEM.MSP1, SSP1)
                    Store (\_SB.MEM.MSC0, SSCH)
                    Store (\_SB.MEM.MSC1, SSCL)
                    Store (\_SB.MEM.MSSI, SSSI)
                    Store (\_SB.MEM.MSSS, SSS0)
                    Store (\_SB.MEM.MSSR, SSR0)
                }

                Return (BUFF)
            }

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

        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 (LNot (LGreater (\_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 (_L05, 0, Serialized)
        {
            If (\_SB.MEM.GP73)
            {
                Store (0x00, \_SB.MEM.GP73)
                Notify (\_SB.PCI0.AMDM, 0x02)
            }
        }

        Method (_L08, 0, Serialized)
        {
            Store (\_SB.PCI0.FNC0.SYSR.GPLV, Local0)
            Or (Local0, 0x08000000, Local0)
            Store (Local0, \_SB.PCI0.FNC0.SYSR.GPLV)
            While (LOr (\_SB.MEM.GP50, LOr (\_SB.MEM.GP52, LOr (\_SB.MEM.GP53, LOr (\_SB.MEM.GP54, LOr (\_SB.MEM.GP56, LOr (\_SB.MEM.GP61, LOr (\_SB.MEM.GP62, LOr (\_SB.MEM.GP70, LOr (\_SB.MEM.GP71, LOr (\_SB.MEM.GP93, LOr (\_SB.MEM.GP94, LOr (\_SB.MEM.BPFE, \_SB.MEM.GP95)))))))))))))
            {
                If (\_SB.MEM.GP50)
                {
                    Store (0x00, \_SB.MEM.GP50)
                    Notify (\_SB.ADP1, 0x80)
                    Notify (\_PR.CPU0, 0x80)
                }

                If (\_SB.MEM.GP52)
                {
                    Store (0x00, \_SB.MEM.GP52)
                    If (LEqual (\_SB.MEM.BES1, \_SB.MEM.BT1F))
                    {
                        Notify (\_SB.BAT1, 0x80)
                    }
                    Else
                    {
                        Store (\_SB.MEM.BES1, \_SB.MEM.BT1F)
                        If (\_SB.MEM.BES1)
                        {
                            Notify (\_SB.BAT1, 0x00)
                        }
                        Else
                        {
                            Notify (\_SB.BAT1, 0x01)
                        }
                    }
                }

                If (\_SB.MEM.GP53)
                {
                    Store (0x00, \_SB.MEM.GP53)
                    If (LNot (LEqual (\_SB.MEM.TMP1, \_SB.MEM.AST1)))
                    {
                        Notify (\_TZ.THRM, 0x80)
                    }
                }

                If (\_SB.MEM.GP54)
                {
                    Store (0x00, \_SB.MEM.GP54)
                    If (\_SB.MEM.LANA)
                    {
                        Store (0x00, \_SB.MEM.LANA)
                        Notify (\_SB.PCI0.PCIB.LAN, 0x01)
                    }
                }

                If (\_SB.MEM.GP56)
                {
                    Store (0x00, \_SB.MEM.GP56)
                    Notify (\_SB.BAT1, 0x80)
                }

                If (\_SB.MEM.GP61)
                {
                    Store (0x00, \_SB.MEM.GP61)
                    Signal (\_SB.PCI0.PCIB.SBSQ)
                }

                If (\_SB.MEM.GP62)
                {
                    Store (0x00, \_SB.MEM.GP62)
                    Notify (\_SB.PCI0.USB2.HUB2.POT3, 0x03)
                    Notify (\_SB.PCI0.USB4.HUB0.PT23, 0x03)
                }

                If (\_SB.MEM.GP70)
                {
                    Store (0x00, \_SB.MEM.GP70)
                    If (\_SB.MEM.VALF)
                    {
                        Notify (\_SB.VALZ, 0x80)
                    }

                    If (LEqual (\_SB.MEM.HKCD, 0x3D))
                    {
                        TRAP (\_SB.MEM.HKCD)
                    }

                    If (LEqual (\_SB.MEM.DOS2, 0x00))
                    {
                        If (LEqual (\_SB.MEM.HKCD, 0x3F))
                        {
                            If (LEqual (\_SB.MEM.TNVS, 0x00))
                            {
                                Notify (\_SB.PCI0.VGA, 0x80)
                            }
                        }
                    }
                }

                If (\_SB.MEM.GP71)
                {
                    Store (0x00, \_SB.MEM.GP71)
                    Notify (\_SB.LID, 0x80)
                }

                If (\_SB.MEM.BPFE)
                {
                    Store (0x00, \_SB.MEM.BPFE)
                    Notify (\_SB.BT, 0x90)
                }

                If (\_SB.MEM.GP93)
                {
                    Store (0x00, \_SB.MEM.GP93)
                    Notify (\_SB.HAPS, 0x80)
                }

                If (\_SB.MEM.GP94)
                {
                    Store (0x00, \_SB.MEM.GP94)
                    Notify (\_SB.HAPS, 0x81)
                }
            }
        }

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

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

        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 (LNot (LEqual (\_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 (LNot (LLess (Arg0, 0x01)), LNot (LGreater (Arg0, 0x04))))
        {
            Store (\_SB.MEM.EWLD, \_SB.MEM.PAR1)
            Store (0x60, \_SB.PCI0.FNC0.SYSR.TRP4)
        }

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

    Method (_WAK, 1, NotSerialized)
    {
        Store (\_SB.MEM.CTDD, \_SB.MEM.DDS0)
        DIS (0x14)
        SMBR (0xFF00, 0x1E, 0x01, 0x00, 0xB2)
        If (LNot (LGreater (\_SB.MEM.OSID, 0x03)))
        {
            While (LEqual (\_SB.MEM.KBCR, 0x00)) {}
        }

        If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04)))
        {
            Store (0x01, \_SB.MEM.DNTF)
        }

        Store (0x01, \_SB.MEM.WAKS)
        Store (0x01, \_SB.MEM.PAR1)
        Store (0x60, \_SB.PCI0.FNC0.SYSR.TRP4)
        If (LNot (LEqual (\_SB.MEM.ACST, \_SB.MEM.ACBK)))
        {
            Notify (\_PR.CPU0, 0x80)
        }

        Name (BUFF, Package (0x02)
        {
            0x00, 
            0x01
        })
        If (LEqual (\_SB.MEM.ACST, 0x00))
        {
            And (\_SB.MEM.BST1, 0x04, Local0)
            If (LEqual (Local0, 0x04))
            {
                Store (0x01, Index (BUFF, 0x00))
            }
        }

        If (\_SB.MEM.GP91)
        {
            Store (0x00, \_SB.MEM.GP91)
            If (LEqual (Arg0, 0x04))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        Return (BUFF)
    }

    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 (LNot (LEqual (\_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) {}
        })
        CreateWordField (IRQB, 0x01, INTX)
        If (LLess (Arg0, 0x10))
        {
            And (Arg0, 0x0F, Local0)
            ShiftLeft (0x01, Local0, INTX)
        }

        Return (IRQB)
    }

    Mutex (MTEX, 0x00)
}