/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20020725
 *
 * Disassembly of dsdt1.dat, Thu Aug  1 04:26:20 2002
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "COMAPQ", "EAGLES", 100925440)
{
    Scope (\_PR)
    {
        Processor (CPU0, 0x01, 0x8010, 0x06) {}
    }

    Name (\_S0, Package (0x02)
    {
        0x00, 
        0x00
    })
    Name (\_S3, Package (0x02)
    {
        0x01, 
        0x01
    })
    Name (\_S4, Package (0x02)
    {
        0x02, 
        0x02
    })
    Name (\_S5, Package (0x02)
    {
        0x02, 
        0x02
    })
    Mutex (SLP, 0x00)
    Method (\_PTS, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x03))
        {
            Store ("------------- System S0 to S3 mode -------------", Debug)
            Acquire (SLP, 0xFFFF)
            If (\_SB.PCI0.PIB.EC.ECOK)
            {
                Store (\_SB.PCI0.PM.LIDI, \_SB.PCI0.PM.LPOL)
                Store (0x01, \_SB.PCI0.PIB.EC.SLPT)
                Store (0x00, \_SB.PCI0.PIB.EC.Z000)
            }

            Store (0x01, \_SB.PCI0.PM.USBP)
            Store (0x00, \_SB.PCI0.PM.SUSC)
            Store (0x01, \_SB.PCI0.CRD0.PMST)
            \_SB.Z001 (0x82)
            Release (SLP)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store ("------------- System S0 to S4 mode -------------", Debug)
            Store (0x01, \_SB.PCI0.PM.SUSC)
        }
    }

    Mutex (WAKE, 0x00)
    Method (\_WAK, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x03))
        {
            Store ("------------- System S3 to S0 mode -------------", Debug)
            Acquire (WAKE, 0xFFFF)
            If (\_SB.PCI0.PIB.EC.ECOK)
            {
                Store (0x00, \_SB.PCI0.PIB.EC.SLPT)
            }

            \_SB.Z001 (0x83)
            Release (WAKE)
            If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
            {
                Store ("Microsoft Windows 2001", Debug)
            }
            Else
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        If (LEqual (Arg0, 0x04))
        {
            Store ("------------- System S4 to S0 mode -------------", Debug)
            Notify (\_SB.PWRB, 0x02)
            \_SB.Z001 (0x88)
        }

        Notify (\_SB.AC, 0x80)
        Notify (\_SB.BAT0, 0x80)
    }

    Scope (\_SI)
    {
    }

    Scope (\_GPE)
    {
        Method (_L0B, 0, NotSerialized)
        {
            If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
            {
                Store ("Microsoft Windows 2001", Debug)
                Store ("EC  runtime event", Debug)
                If (\_SB.PCI0.PM.LPOL)
                {
                    Store (0x00, \_SB.PCI0.PM.LPOL)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.PM.LPOL)
                }

                Notify (\_SB.PWRB, 0x02)
            }
            Else
            {
                Store ("EC  runtime event", Debug)
                If (\_SB.PCI0.PM.LPOL)
                {
                    Store (0x00, \_SB.PCI0.PM.LPOL)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.PM.LPOL)
                }

                If (\_SB.PCI0.PIB.EC.Z000)
                {
                    Notify (\_SB.PWRB, 0x02)
                }

                If (\_SB.PCI0.PIB.EC.DETF)
                {
                    Notify (\_SB.PWRB, 0x02)
                }
            }
        }

        Method (_L0E, 0, NotSerialized)
        {
            Store ("USB runtime event", Debug)
            Notify (\_SB.PCI0.USB0, 0x02)
            Notify (\_SB.PCI0.USB1, 0x02)
            If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        Method (_L09, 0, NotSerialized)
        {
            Store ("USB runtime event", Debug)
            Notify (\_SB.PCI0.USB0, 0x02)
            Notify (\_SB.PCI0.USB1, 0x02)
            If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        Method (_L05, 0, NotSerialized)
        {
            If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
            {
                Store ("PCI PME# runtime event", Debug)
            }
            Else
            {
                Notify (\_SB.PCI0.CRD0, 0x02)
            }
        }
    }

    OperationRegion (VGAM, SystemMemory, 0xC0002, 0x01)
    Field (VGAM, ByteAcc, NoLock, Preserve)
    {
        VGA1,   8
    }

    Scope (\_SB)
    {
        Device (SLPB)
        {
            Name (_HID, EisaId ("PNP0C0E"))
            Name (_PRW, Package (0x02)
            {
                0x0B, 
                0x03
            })
        }

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

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                Store ("-------------- VIA LID Switch --------------", Debug)
                If (\_SB.PCI0.PIB.EC.ECOK)
                {
                    If (\_SB.PCI0.PIB.EC.LIDS)
                    {
                        Return (0x01)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }
                Else
                {
                    Return (0x01)
                }
            }
        }

        Mutex (VSMX, 0x00)
        Method (Z001, 1, Serialized)
        {
            Store ("--------- VIA SOFTWARE SMI PMIO 2Fh ------------", Debug)
            Acquire (VSMX, 0xFFFF)
            Store (Arg0, \_SB.PCI0.PM.BCMD)
            Release (VSMX)
        }

        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (ACP, 0x00)
            Method (_STA, 0, NotSerialized)
            {
                Store ("---------------------------- AC _STA", Debug)
                Return (0x0F)
            }

            Method (_PSR, 0, NotSerialized)
            {
                Store ("---------------------------- AC _PSR", Debug)
                Store (ACP, Local0)
                If (\_SB.PCI0.PIB.EC.ECOK)
                {
                    Acquire (\_SB.PCI0.PIB.EC.MTX0, 0xFFFF)
                    Store (\_SB.PCI0.PIB.EC.ADP, Local0)
                    Release (\_SB.PCI0.PIB.EC.MTX0)
                    If (LNot (LEqual (Local0, ACP)))
                    {
                        FLPA ()
                    }
                }

                If (Local0)
                {
                    Store ("---------------------------- AC on line", Debug)
                }
                Else
                {
                    Store ("---------------------------- AC off line", Debug)
                }

                Return (Local0)
            }

            Method (CHAC, 0, NotSerialized)
            {
                Store ("---------------------------- AC _CHAC", Debug)
                If (\_SB.PCI0.PIB.EC.ECOK)
                {
                    Acquire (\_SB.PCI0.PIB.EC.MTX0, 0xFFFF)
                    Store (\_SB.PCI0.PIB.EC.ADP, Local0)
                    Release (\_SB.PCI0.PIB.EC.MTX0)
                    If (LNot (LEqual (Local0, ACP)))
                    {
                        FLPA ()
                    }
                }
            }

            Method (FLPA, 0, NotSerialized)
            {
                Store ("---------------------------- AC _FLPA", Debug)
                If (ACP)
                {
                    Store (0x00, ACP)
                }
                Else
                {
                    Store (0x01, ACP)
                }

                Notify (\_SB.AC, 0x00)
            }
        }

        Device (BAT0)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x01)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (BIFB, Package (0x0D)
            {
                0x01, 
                0x514, 
                0x514, 
                0x01, 
                0x2A30, 
                0x138, 
                0x9C, 
                0x0D, 
                0x0D, 
                "6000", 
                Zero, 
                Zero, 
                Zero, 
                "1", 
                " ", 
                " COMPAQ "
            })
            Name (BSTB, Package (0x04)
            {
                0x00, 
                Ones, 
                Ones, 
                0x2710
            })
            Name (MDLS, Package (0x07)
            {
                "Unknown", 
                " 3500", 
                " 3800", 
                " 4500", 
                " 2600", 
                " 3000", 
                " 3200"
            })
            Name (CHAR, Package (0x10)
            {
                "0", 
                "1", 
                "2", 
                "3", 
                "4", 
                "5", 
                "6", 
                "7", 
                "8", 
                "9", 
                "A", 
                "B", 
                "C", 
                "D", 
                "E", 
                "F"
            })
            Method (PBFE, 3, NotSerialized)
            {
                CreateByteField (Arg0, Arg1, TIDX)
                Store (Arg2, TIDX)
            }

            Method (ITOS, 1, NotSerialized)
            {
                Store ("", Local0)
                Store (0x08, Local1)
                While (Local1)
                {
                    Decrement (Local1)
                    And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
                    Store (DerefOf (Index (CHAR, Local4)), Local2)
                    Concatenate (Local0, Local2, Local5)
                    Store (Local5, Local0)
                }

                Return (Local0)
            }

            Method (Z002, 1, NotSerialized)
            {
                Store ("", Local0)
                Store (0x04, Local1)
                While (Local1)
                {
                    Decrement (Local1)
                    And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
                    Store (DerefOf (Index (CHAR, Local4)), Local2)
                    Concatenate (Local0, Local2, Local5)
                    Store (Local5, Local0)
                }

                Return (Local0)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (\_SB.PCI0.PIB.EC.ECOK)
                {
                    If (\_SB.PCI0.PIB.EC.DETF)
                    {
                        Store (0x00, \_SB.PCI0.PIB.EC.DETF)
                        Notify (\_SB.PWRB, 0x80)
                    }

                    Store (\_SB.PCI0.PIB.EC.BATP, Local0)
                    If (Or (Local0, Local0))
                    {
                        Return (0x1F)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Method (_BIF, 0, NotSerialized)
            {
                If (\_SB.PCI0.PIB.EC.ECOK)
                {
                    \_SB.Z001 (0x84)
                    Acquire (\_SB.PCI0.PIB.EC.MTX0, 0xFFFF)
                    Store (0x00, Index (BIFB, 0x00))
                    Store (\_SB.PCI0.BDV, Local1)
                    Store (\_SB.PCI0.BDC, Local0)
                    Multiply (Local0, Local1, Local0)
                    Divide (Local0, 0x3E8, Local2, Local0)
                    Store (Local0, Index (BIFB, 0x01))
                    Store (\_SB.PCI0.BFC, Local0)
                    Multiply (Local0, Local1, Local0)
                    Divide (Local0, 0x3E8, Local2, Local0)
                    Store (Local0, Index (BIFB, 0x02))
                    Store (\_SB.PCI0.BTC, Index (BIFB, 0x03))
                    Store (\_SB.PCI0.BDV, Index (BIFB, 0x04))
                    Store (\_SB.PCI0.BCW, Local0)
                    Multiply (Local0, Local1, Local0)
                    Divide (Local0, 0x3E8, Local2, Local0)
                    Store (Local0, Index (BIFB, 0x05))
                    Store (\_SB.PCI0.BCL, Local0)
                    Multiply (Local0, Local1, Local0)
                    Divide (Local0, 0x3E8, Local2, Local0)
                    Store (Local0, Index (BIFB, 0x06))
                    Store (\_SB.PCI0.BCG, Local0)
                    Multiply (Local0, Local1, Local0)
                    Divide (Local0, 0x3E8, Local2, Local0)
                    Store (Local0, Index (BIFB, 0x07))
                    Store (\_SB.PCI0.BG2, Local0)
                    Multiply (Local0, Local1, Local0)
                    Divide (Local0, 0x3E8, Local2, Local0)
                    Store (Local0, Index (BIFB, 0x08))
                    Store (\_SB.PCI0.BMO, Local5)
                    Store (\_SB.PCI0.NABT, Local5)
                    And (Local5, 0x0F, Local5)
                    If (LGreater (Local5, 0x06))
                    {
                        Store (DerefOf (Index (MDLS, 0x00)), Index (BIFB, 0x09))
                    }
                    Else
                    {
                        Store ("---------------- NABT < 6 ", Debug)
                        Store (\_SB.PCI0.NABT, Local5)
                        And (Local5, 0x0F, Local5)
                        Store (0x00, Local1)
                        If (LEqual (Local5, 0x01))
                        {
                            Store (0x01, Local1)
                        }

                        If (LEqual (Local5, 0x04))
                        {
                            Store (0x01, Local1)
                        }

                        Store (\_SB.PCI0.BDC, Local0)
                        If (LEqual (Local1, 0x01))
                        {
                            Store ("---------------------NiMH battery, NABT =1,4 ", Debug)
                            If (LNot (LLess (Local0, 0xED8)))
                            {
                                Store (Z002 (ToBCD (Local0)), Local1)
                                Store (Local1, Index (BIFB, 0x09))
                                Store ("-------------------- DC > 3800 ", Debug)
                            }
                            Else
                            {
                                Store ("3800", Index (BIFB, 0x09))
                                Store ("-------------------- DC <= 3800 ", Debug)
                            }

                            Store (\_SB.PCI0.BDC, Local0)
                            If (LEqual (Local0, 0x11C6))
                            {
                                Store ("3800", Index (BIFB, 0x09))
                                Store ("-------------------- DC =4550 ", Debug)
                            }
                        }
                        Else
                        {
                            Store ("---------------- Li Battery ", Debug)
                            If (LNot (LLess (Local0, 0xBB8)))
                            {
                                Store (Z002 (ToBCD (Local0)), Local1)
                                Store (Local1, Index (BIFB, 0x09))
                                Store ("--------------------- DC >= 3000 ", Debug)
                            }
                            Else
                            {
                                Store ("2600", Index (BIFB, 0x09))
                                Store ("--------------------- DC < 3000 ", Debug)
                            }
                        }
                    }

                    Store (\_SB.PCI0.BSN0, Local0)
                    Store (\_SB.PCI0.BSN1, Local1)
                    Store (\_SB.PCI0.BTY0, Local0)
                    Store (\_SB.PCI0.BTY1, Local1)
                    Store (\_SB.PCI0.BTY2, Local2)
                    Store (\_SB.PCI0.BTY3, Local3)
                    Store (Buffer (0x05) {}, Local4)
                    PBFE (Local4, 0x00, Local0)
                    PBFE (Local4, 0x01, Local1)
                    PBFE (Local4, 0x02, Local2)
                    PBFE (Local4, 0x03, Local3)
                    PBFE (Local4, 0x04, 0x00)
                    Name (Z003, "4")
                    Zero
                    Zero
                    Zero
                    Zero
                    Zero
                    Zero
                    Zero
                    Store (Local4, Z003)
                    Store (Z003, Index (BIFB, 0x0B))
                    If (\_SB.PCI0.BATP)
                    {
                        Store (" COMPAQ ", Index (BIFB, 0x0C))
                    }
                    Else
                    {
                        Store (" ", Index (BIFB, 0x0C))
                    }

                    Release (\_SB.PCI0.PIB.EC.MTX0)
                }
                Else
                {
                    Store (0x01, Index (BIFB, 0x00))
                    Store (0x514, Index (BIFB, 0x01))
                    Store (0x514, Index (BIFB, 0x02))
                    Store (0x01, Index (BIFB, 0x03))
                    Store (0x2A30, Index (BIFB, 0x04))
                    Store (0x138, Index (BIFB, 0x05))
                    Store (0x9C, Index (BIFB, 0x06))
                    Store (0x0D, Index (BIFB, 0x07))
                    Store (0x0D, Index (BIFB, 0x08))
                    Store ("CA54200", Index (BIFB, 0x09))
                    Store ("1", Index (BIFB, 0x0A))
                    Store (" ", Index (BIFB, 0x0B))
                    Store (" COMPAQ ", Index (BIFB, 0x0C))
                }

                Return (BIFB)
            }

            Method (_BST, 0, NotSerialized)
            {
                UBST ()
                Return (BSTB)
            }

            Name (CRIT, 0x00)
            Method (UBST, 0, NotSerialized)
            {
                If (\_SB.PCI0.PIB.EC.ECOK)
                {
                    \_SB.Z001 (0x85)
                    Store (\_SB.PCI0.BST, Index (BSTB, 0x00))
                    Store (\_SB.PCI0.BPR, Local0)
                    Store (\_SB.PCI0.BDV, Local1)
                    If (LNot (LLess (Local0, 0x8000)))
                    {
                        Subtract (0x10000, Local0, Local0)
                        Multiply (Local0, Local1, Local0)
                        Divide (Local0, 0x3E8, Local2, Local0)
                        Store (Local0, Index (BSTB, 0x01))
                    }
                    Else
                    {
                        Multiply (Local0, Local1, Local0)
                        Divide (Local0, 0x3E8, Local2, Local0)
                        Store (Local0, Index (BSTB, 0x01))
                    }

                    Store (\_SB.PCI0.BRC, Local0)
                    Multiply (Local0, Local1, Local0)
                    Divide (Local0, 0x3E8, Local2, Local0)
                    Store (Local0, Index (BSTB, 0x02))
                    Store (\_SB.PCI0.BPV, Index (BSTB, 0x03))
                    Store (DerefOf (Index (BSTB, 0x00)), Local0)
                    Store (\_SB.PCI0.PIB.EC.BATC, Local1)
                    And (Local0, 0xFFFB, Local0)
                    ShiftLeft (Local1, 0x02, Local1)
                    Add (Local0, Local1, Local0)
                    Store (Local0, Index (BSTB, 0x00))
                }
                Else
                {
                    Store (Ones, Index (BSTB, 0x00))
                    Store (Ones, Index (BSTB, 0x01))
                    Store (Ones, Index (BSTB, 0x02))
                    Store (Ones, Index (BSTB, 0x03))
                }
            }

            Method (Z004, 0, NotSerialized)
            {
                Acquire (\_SB.PCI0.PIB.EC.MTX1, 0xFFFF)
                If (LEqual (_STA (), 0x1F))
                {
                    UBST ()
                    _BIF ()
                    Notify (\_SB.AC, 0x00)
                    Notify (\_SB.BAT0, 0x00)
                    Notify (\_SB.BAT0, 0x80)
                    Notify (\_SB.BAT0, 0x81)
                }
                Else
                {
                    UBST ()
                    Notify (\_SB.AC, 0x00)
                    Notify (\_SB.BAT0, 0x00)
                    Notify (\_SB.BAT0, 0x80)
                    Notify (\_SB.BAT0, 0x81)
                }

                \_SB.AC.FLPA ()
                Release (\_SB.PCI0.PIB.EC.MTX1)
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_BBN, 0x00)
            Method (_INI, 0, NotSerialized)
            {
                If (CondRefOf (_OSI, Local0))
                {
                    If (\_OSI)
                    {
                        "Windows 2001"
                        Store (0x03, \_SB.PCI0.OSF)
                    }
                }
                Else
                {
                    If (LEqual (SizeOf (_OS), 0x14))
                    {
                        Store (0x02, \_SB.PCI0.OSF)
                    }
                    Else
                    {
                        If (LEqual (SizeOf (_OS), 0x27))
                        {
                            Store (0x01, \_SB.PCI0.OSF)
                        }
                        Else
                        {
                            Store (0x00, \_SB.PCI0.OSF)
                        }
                    }
                }

                \_SB.Z001 (0x88)
            }

            Method (_S3D, 0, NotSerialized)
            {
                If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
                {
                    Return (0x03)
                }
                Else
                {
                    Return (0x02)
                }
            }

            OperationRegion (NB00, PCI_Config, 0x00, 0x100)
            Field (NB00, ByteAcc, NoLock, Preserve)
            {
                Offset (0x10), 
                BAR0,   32, 
                Offset (0x5F), 
                EADD,   8, 
                Offset (0x84), 
                GAS,    32
            }

            OperationRegion (ECSM, SystemMemory, 0xDEFFDFD, 0x150)
            Field (ECSM, AnyAcc, NoLock, Preserve)
            {
                ADP,    1, 
                    ,   1, 
                BATP,   1, 
                Offset (0x01), 
                BDC,    32, 
                BFC,    32, 
                BTC,    32, 
                BDV,    32, 
                BST,    32, 
                BPR,    32, 
                BRC,    32, 
                BPV,    32, 
                BCW,    32, 
                BCL,    32, 
                BCG,    32, 
                BG2,    32, 
                BMO,    32, 
                BSN0,   32, 
                BSN1,   32, 
                BTY0,   8, 
                BTY1,   8, 
                BTY2,   8, 
                BTY3,   8, 
                NABT,   8, 
                DISD,   8, 
                OSF,    8
            }

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

            Name (CRES, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,
                    0x0000,
                    0x00FF,
                    0x0000,
                    0x0100)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,
                    0x0000,
                    0x0CF7,
                    0x0000,
                    0x0CF8)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,
                    0x0D00,
                    0xFFFF,
                    0x0000,
                    0xF300)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000A0000,
                    0x000BFFFF,
                    0x00000000,
                    0x00020000)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000CC000,
                    0x000DBFFF,
                    0x00000000,
                    0x00010000)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x00100000,
                    0xFFF7FFFF,
                    0x00000000,
                    0xFFF00000)
            })
            Method (_CRS, 0, NotSerialized)
            {
                CreateDWordField (CRES, 0x76, TCMM)
                CreateDWordField (CRES, 0x82, TOMM)
                Multiply (\_SB.PCI0.EADD, 0x1000000, Local0)
                Store (Local0, TCMM)
                Subtract (0xFFF80000, TCMM, TOMM)
                Return (CRES)
            }

            Name (_PRT, Package (0x0A)
            {
                Package (0x04)
                {
                    0x1FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x7FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x7FFFF, 
                    0x01, 
                    \_SB.PCI0.PIB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x7FFFF, 
                    0x02, 
                    \_SB.PCI0.PIB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x7FFFF, 
                    0x03, 
                    \_SB.PCI0.PIB.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x9FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x9FFFF, 
                    0x01, 
                    \_SB.PCI0.PIB.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xAFFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xBFFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x13FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }
            })
            Device (AGP)
            {
                Name (_ADR, 0x10000)
                Device (VGA)
                {
                    Name (_ADR, 0x00)
                    Name (SWIT, 0x01)
                    Name (CRTA, 0x01)
                    Name (LCDA, 0x01)
                    Name (TVOA, 0x01)
                    Name (TOGF, 0x00)
                    OperationRegion (CMOS, SystemIO, 0x70, 0x02)
                    Field (CMOS, ByteAcc, NoLock, Preserve)
                    {
                        CMID,   8, 
                        CMDA,   8
                    }

                    Method (_DOS, 1, NotSerialized)
                    {
                        Store ("VGA --_DOS", Debug)
                        Store (Arg0, SWIT)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Store ("VGA --_DOD", Debug)
                        Return (Package (0x03)
                        {
                            0x10100, 
                            0x10110, 
                            0x10200
                        })
                    }

                    Device (CRT)
                    {
                        Name (_ADR, 0x100)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store ("CRT --_DCS", Debug)
                            If (CRTA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Store ("CRT --_DGS", Debug)
                            Store (CRTA, Local0)
                            If (CRTA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

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

                    Device (LCD)
                    {
                        Name (_ADR, 0x110)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store ("LCD --_DCS", Debug)
                            If (LCDA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Store ("LCD --_DGS", Debug)
                            Store (LCDA, Local0)
                            If (LCDA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

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

                    Device (TVO)
                    {
                        Name (_ADR, 0x200)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store ("TVO --_DCS", Debug)
                            If (TVOA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Store ("TVO --_DGS", Debug)
                            Store (TVOA, Local0)
                            If (TVOA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

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

            Method (MIN, 2, NotSerialized)
            {
                If (LLess (Arg0, Arg1))
                {
                    Return (Arg0)
                }
                Else
                {
                    Return (Arg1)
                }
            }

            Method (SLEN, 1, NotSerialized)
            {
                Return (SizeOf (Arg0))
            }

            Method (S2BF, 1, Serialized)
            {
                Add (SLEN (Arg0), One, Local0)
                Name (BUFF, Buffer (Local0) {})
                Store (Arg0, BUFF)
                Return (BUFF)
            }

            Method (SCMP, 2, NotSerialized)
            {
                Store (S2BF (Arg0), Local0)
                Store (S2BF (Arg1), Local1)
                Store (Zero, Local4)
                Store (SLEN (Arg0), Local5)
                Store (SLEN (Arg1), Local6)
                Store (MIN (Local5, Local6), Local7)
                While (LLess (Local4, Local7))
                {
                    Store (DerefOf (Index (Local0, Local4)), Local2)
                    Store (DerefOf (Index (Local1, Local4)), Local3)
                    If (LGreater (Local2, Local3))
                    {
                        Return (One)
                    }
                    Else
                    {
                        If (LLess (Local2, Local3))
                        {
                            Return (Ones)
                        }
                    }

                    Increment (Local4)
                }

                If (LLess (Local4, Local5))
                {
                    Return (One)
                }
                Else
                {
                    If (LLess (Local4, Local6))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }
            }

            Device (PIB)
            {
                Name (_ADR, 0x70000)
                OperationRegion (IRQR, PCI_Config, 0x00, 0x88)
                Field (IRQR, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x48), 
                        ,   2, 
                    EUSB,   1, 
                    Offset (0x50), 
                    FDDA,   2, 
                    LPDA,   2, 
                    Offset (0x51), 
                    FDIQ,   4, 
                    LPIQ,   4, 
                    SAIQ,   4, 
                    SBIQ,   4, 
                    Offset (0x55), 
                        ,   4, 
                    PIRA,   4, 
                    PIRB,   4, 
                    PIRC,   4, 
                        ,   4, 
                    PIRD,   4, 
                    USBA,   2, 
                    A97A,   2, 
                    Offset (0x81), 
                    PDC1,   8, 
                    PDC2,   8, 
                    PDC3,   8, 
                    PDC4,   8, 
                    EP3C,   1, 
                    EN3C,   1, 
                    EACF,   1, 
                    EMCF,   1, 
                    ESB1,   1
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {4}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRA)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRA, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFA, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFA, 0x01, IRA1)
                        CreateByteField (BUFA, 0x02, IRA2)
                        Store (\_SB.PCI0.PIB.PIRA, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local0)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRA2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRA1)
                            }
                        }

                        Return (BUFA)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRA1)
                        CreateByteField (Arg0, 0x02, IRA2)
                        If (LGreater (IRA2, Zero))
                        {
                            FindSetLeftBit (IRA2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRA1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRA)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {11}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRB)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRB, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFB, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFB, 0x01, IRB1)
                        CreateByteField (BUFB, 0x02, IRB2)
                        Store (\_SB.PCI0.PIB.PIRB, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local0)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRB2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRB1)
                            }
                        }

                        Return (BUFB)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRB1)
                        CreateByteField (Arg0, 0x02, IRB2)
                        If (LGreater (IRB2, Zero))
                        {
                            FindSetLeftBit (IRB2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRB1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRB)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {5}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRC, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFC, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFC, 0x01, IRC1)
                        CreateByteField (BUFC, 0x02, IRC2)
                        Store (\_SB.PCI0.PIB.PIRC, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local0)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRC2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRC1)
                            }
                        }

                        Return (BUFC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRC1)
                        CreateByteField (Arg0, 0x02, IRC2)
                        If (LGreater (IRC2, Zero))
                        {
                            FindSetLeftBit (IRC2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRC1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRC)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRD)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRD, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFD, 0x01, IRD1)
                        CreateByteField (BUFD, 0x02, IRD2)
                        Store (\_SB.PCI0.PIB.PIRD, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local2)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local2, Local3)
                                Store (Local3, IRD2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, Local2)
                                Store (Local2, IRD1)
                            }
                        }

                        Return (BUFD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRD1)
                        CreateByteField (Arg0, 0x02, IRD2)
                        If (LGreater (IRD2, Zero))
                        {
                            FindSetLeftBit (IRD2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRD1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRD)
                    }
                }

                Device (DMA1)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        DMA (Compatibility, BusMaster, Transfer8) {4}
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x10)
                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode10, 0x0070, 0x0070, 0x01, 0x06)
                        IRQNoFlags () {8}
                    })
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
                        IRQNoFlags () {2}
                    })
                }

                Device (COPR)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x10)
                        IRQNoFlags () {13}
                    })
                }

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                        IRQNoFlags () {0}
                    })
                }

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

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (SMEM, ResourceTemplate ()
                        {
                            Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000)
                            Memory32Fixed (ReadWrite, 0x000DC000, 0x00004000)
                            Memory32Fixed (ReadOnly, 0x07000000, 0x01000000)
                        })
                        Return (SMEM)
                    }
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                    })
                }

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

                IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                {
                    Offset (0xE2), 
                    CRE2,   8, 
                    CRE3,   8, 
                    Offset (0xE6), 
                    CRE6,   8, 
                    CRE7,   8, 
                    CRE8,   8, 
                    Offset (0xEE), 
                    CREE,   8
                }

                Method (ENCG, 0, NotSerialized)
                {
                    Store (0x01, \_SB.PCI0.PIB.EN3C)
                }

                Method (EXCG, 0, NotSerialized)
                {
                    Store (0x00, \_SB.PCI0.PIB.EN3C)
                }

                Device (FDC0)
                {
                    Name (_HID, EisaId ("PNP0700"))
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x06)
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x01)
                        IRQNoFlags () {}
                        DMA (Compatibility, NotBusMaster, Transfer8) {}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNot (\_SB.PCI0.PIB.EP3C))
                        {
                            Return (0x00)
                        }

                        ENCG ()
                        Store (CRE2, Local0)
                        And (Local0, 0x10, Local0)
                        If (Local0)
                        {
                            Store (CRE3, Local1)
                            EXCG ()
                            If (LEqual (Local1, 0x00))
                            {
                                Return (0x0D)
                            }

                            Return (0x0F)
                        }

                        EXCG ()
                        Return (0x0D)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENCG ()
                        Store (Zero, CRE3)
                        EXCG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        If (LEqual (And (_STA (), 0x04), Zero))
                        {
                            Return (RSRC)
                        }

                        Name (BUF0, ResourceTemplate ()
                        {
                            IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
                            IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
                            IRQNoFlags () {6}
                            DMA (Compatibility, NotBusMaster, Transfer8) {2}
                        })
                        CreateByteField (BUF0, 0x02, IOLO)
                        CreateByteField (BUF0, 0x03, IOHI)
                        CreateByteField (BUF0, 0x04, IORL)
                        CreateByteField (BUF0, 0x05, IORH)
                        CreateByteField (BUF0, 0x0A, DALO)
                        CreateByteField (BUF0, 0x0B, DAHI)
                        CreateByteField (BUF0, 0x0C, DRLO)
                        CreateByteField (BUF0, 0x0D, DRHI)
                        CreateByteField (BUF0, 0x11, IRQL)
                        CreateByteField (BUF0, 0x14, DMAV)
                        Store (DATA, Local0)
                        And (Local0, 0x20, Local0)
                        If (LEqual (Local0, 0x00))
                        {
                            Store (0x70, IOLO)
                            Store (0x03, IOHI)
                            Store (IOLO, IORL)
                            Store (IOHI, IORH)
                            Store (0x77, DALO)
                            Store (0x03, DAHI)
                            Store (DALO, DRLO)
                            Store (DAHI, DRHI)
                        }

                        Store (\_SB.PCI0.PIB.FDIQ, Local0)
                        Store (0x01, Local1)
                        ShiftLeft (Local1, Local0, IRQL)
                        Store (\_SB.PCI0.PIB.FDDA, Local0)
                        Store (0x01, Local1)
                        ShiftLeft (Local1, Local0, DMAV)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
                            IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
                            IRQNoFlags () {6}
                            DMA (Compatibility, NotBusMaster, Transfer8) {2}
                        }
                        EndDependentFn ()
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateWordField (Arg0, 0x11, IRQL)
                        CreateByteField (Arg0, 0x14, DMAV)
                        ENCG ()
                        Store (CRE2, Local1)
                        And (Local1, 0xEF, Local1)
                        Store (Local1, CRE2)
                        If (LEqual (IOLO, 0xF0))
                        {
                            Store (0xF0, Local0)
                        }
                        Else
                        {
                            Store (0x70, Local0)
                        }

                        ShiftRight (Local0, 0x02, Local0)
                        And (Local0, 0xFC, Local0)
                        Store (IOHI, Local1)
                        ShiftLeft (Local1, 0x06, Local1)
                        Or (Local0, Local1, Local0)
                        Store (Local0, CRE3)
                        FindSetRightBit (IRQL, Local0)
                        Decrement (Local0)
                        Store (Local0, \_SB.PCI0.PIB.FDIQ)
                        FindSetRightBit (DMAV, Local0)
                        Decrement (Local0)
                        Store (Local0, \_SB.PCI0.PIB.FDDA)
                        Store (CRE2, Local1)
                        Or (Local1, 0x10, Local1)
                        Store (Local1, CRE2)
                        EXCG ()
                    }
                }

                Device (LPT)
                {
                    Name (PIOM, Buffer (0x01)
                    {
                        0x00
                    })
                    CreateByteField (PIOM, 0x00, LPTM)
                    Name (_HID, EisaId ("PNP0400"))
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNot (\_SB.PCI0.PIB.EP3C))
                        {
                            Return (0x00)
                        }

                        ENCG ()
                        Store (CRE2, Local0)
                        And (Local0, 0x03, Local0)
                        If (LEqual (Local0, 0x01))
                        {
                            EXCG ()
                            Return (0x00)
                        }

                        If (LNot (LEqual (Local0, 0x03)))
                        {
                            Store (Local0, LPTM)
                        }

                        Store (CRE6, Local0)
                        If (LEqual (Local0, 0x00))
                        {
                            EXCG ()
                            Return (0x0D)
                        }

                        EXCG ()
                        Return (0x0F)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENCG ()
                        Store (Zero, CRE6)
                        EXCG ()
                        Store (Zero, \_SB.PCI0.PIB.LPIQ)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IO (Decode16, 0x0000, 0x0000, 0x01, 0x00)
                            IRQNoFlags () {}
                        })
                        If (LEqual (_STA (), 0x0F))
                        {
                            CreateByteField (BUF0, 0x02, IOLO)
                            CreateByteField (BUF0, 0x03, IOHI)
                            CreateByteField (BUF0, 0x04, IORL)
                            CreateByteField (BUF0, 0x05, IORH)
                            CreateByteField (BUF0, 0x07, RGLN)
                            CreateByteField (BUF0, 0x09, IRQL)
                            ENCG ()
                            Store (CRE6, Local0)
                            Store (Local0, Local1)
                            And (Local1, 0xC0, Local1)
                            ShiftRight (Local1, 0x06, Local1)
                            And (Local0, 0x3F, Local0)
                            ShiftLeft (Local0, 0x02, Local0)
                            Store (Local0, IOLO)
                            Store (Local1, IOHI)
                            Store (IOLO, IORL)
                            Store (IOHI, IORH)
                            Store (0x08, RGLN)
                            EXCG ()
                            Store (\_SB.PCI0.PIB.LPIQ, Local0)
                            Store (0x01, Local1)
                            ShiftLeft (Local1, Local0, IRQL)
                        }

                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                            IRQNoFlags () {7}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                            IRQNoFlags () {5}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                            IRQNoFlags () {7}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                            IRQNoFlags () {5}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                            IRQNoFlags () {7}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                            IRQNoFlags () {5}
                        }
                        EndDependentFn ()
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateByteField (Arg0, 0x09, IRQL)
                        ENCG ()
                        Store (CRE2, Local0)
                        Or (Local0, 0x03, Local0)
                        Store (Local0, CRE2)
                        Store (IOLO, Local0)
                        ShiftRight (Local0, 0x02, Local0)
                        Store (IOHI, Local1)
                        ShiftLeft (Local1, 0x06, Local1)
                        Or (Local0, Local1, Local0)
                        Store (Local0, CRE6)
                        FindSetRightBit (IRQL, Local0)
                        If (Local0)
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.LPIQ)
                        Store (CRE2, Local0)
                        And (Local0, 0xFC, Local0)
                        Store (LPTM, Local1)
                        Or (Local0, Local1, Local1)
                        Store (Local1, CRE2)
                        EXCG ()
                    }
                }

                Device (ECP)
                {
                    Name (_HID, EisaId ("PNP0401"))
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNot (\_SB.PCI0.PIB.EP3C))
                        {
                            Return (0x00)
                        }

                        ENCG ()
                        Store (CRE2, Local0)
                        And (Local0, 0x03, Local0)
                        If (LEqual (Local0, 0x01))
                        {
                            Store (CRE6, Local1)
                            EXCG ()
                            If (LNot (LEqual (Local1, 0x00)))
                            {
                                Return (0x0F)
                            }

                            Return (0x0D)
                        }

                        EXCG ()
                        Return (0x00)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENCG ()
                        Store (Zero, CRE6)
                        EXCG ()
                        Store (Zero, \_SB.PCI0.PIB.LPDA)
                        Store (Zero, \_SB.PCI0.PIB.LPIQ)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IO (Decode16, 0x0000, 0x0000, 0x01, 0x04)
                            IO (Decode16, 0x0000, 0x0000, 0x01, 0x04)
                            IRQNoFlags () {}
                            DMA (Compatibility, NotBusMaster, Transfer8) {}
                        })
                        CreateByteField (BUF0, 0x02, IOLO)
                        CreateByteField (BUF0, 0x03, IOHI)
                        CreateByteField (BUF0, 0x04, IORL)
                        CreateByteField (BUF0, 0x05, IORH)
                        CreateByteField (BUF0, 0x0A, DALO)
                        CreateByteField (BUF0, 0x0B, DAHI)
                        CreateByteField (BUF0, 0x0C, DRLO)
                        CreateByteField (BUF0, 0x0D, DRHI)
                        CreateByteField (BUF0, 0x11, IRQL)
                        CreateByteField (BUF0, 0x14, DMAC)
                        ENCG ()
                        Store (CRE6, Local0)
                        Store (Local0, Local1)
                        And (Local1, 0xC0, Local1)
                        ShiftRight (Local1, 0x06, Local1)
                        And (Local0, 0x3F, Local0)
                        ShiftLeft (Local0, 0x02, Local0)
                        Store (Local0, IOLO)
                        Store (Local1, IOHI)
                        Add (Local1, 0x04, Local1)
                        Store (IOLO, IORL)
                        Store (IOHI, IORH)
                        Store (IOLO, DALO)
                        Store (Local1, DAHI)
                        Store (DALO, DRLO)
                        Store (DAHI, DRHI)
                        EXCG ()
                        Store (\_SB.PCI0.PIB.LPIQ, Local0)
                        Store (0x01, Local1)
                        ShiftLeft (Local1, Local0, IRQL)
                        Store (\_SB.PCI0.PIB.LPDA, Local0)
                        Store (0x01, Local1)
                        ShiftLeft (Local1, Local0, DMAC)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x04)
                            IO (Decode16, 0x0778, 0x0778, 0x01, 0x04)
                            IRQNoFlags () {5,7}
                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                        }
                        StartDependentFn (0x01, 0x01)
                        {
                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x04)
                            IO (Decode16, 0x0678, 0x0678, 0x01, 0x04)
                            IRQNoFlags () {5,7}
                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                        }
                        StartDependentFn (0x02, 0x02)
                        {
                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                            IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
                            IRQNoFlags () {5,7}
                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                        }
                        EndDependentFn ()
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateByteField (Arg0, 0x11, IRQL)
                        CreateByteField (Arg0, 0x14, DMAC)
                        ENCG ()
                        Store (CRE2, Local0)
                        Or (Local0, 0x03, Local0)
                        Store (Local0, CRE2)
                        Store (IOLO, Local0)
                        ShiftRight (Local0, 0x02, Local0)
                        Store (IOHI, Local1)
                        ShiftLeft (Local1, 0x06, Local1)
                        Or (Local0, Local1, Local0)
                        Store (Local0, CRE6)
                        FindSetRightBit (IRQL, Local0)
                        If (Local0)
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.LPIQ)
                        FindSetRightBit (DMAC, Local0)
                        Decrement (Local0)
                        Store (Local0, \_SB.PCI0.PIB.LPDA)
                        Store (CRE2, Local0)
                        And (Local0, 0xFC, Local0)
                        Or (Local0, 0x01, Local0)
                        Store (Local0, CRE2)
                        EXCG ()
                    }
                }

                Device (PS2M)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags () {12}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQNoFlags () {1}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (EC)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_GPE, 0x06)
                    Name (ECOK, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, ECOK)
                        }
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
                    })
                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x04), 
                        CMCM,   8, 
                        CMD1,   8, 
                        CMD2,   8, 
                        CMD3,   8
                    }

                    Field (ERAM, AnyAcc, NoLock, Preserve)
                    {
                        Offset (0x80), 
                        NMSG,   8, 
                        SLED,   4, 
                        SLPT,   4, 
                        MODE,   1, 
                        Z000,   1, 
                        ACPI,   1, 
                        PWBN,   1, 
                        TME0,   1, 
                        TME1,   1, 
                        FANC,   1, 
                        DETF,   1, 
                        LIDS,   1, 
                        LWKE,   1, 
                        IWKE,   1, 
                        INTM,   1, 
                        MWKE,   1, 
                        COMM,   1, 
                        PME,    1, 
                        Offset (0x84), 
                        ADP,    1, 
                        AFLT,   1, 
                        BATP,   1, 
                            ,   1, 
                        BATL,   1, 
                        BATC,   1, 
                        Offset (0x85), 
                        BPU,    32, 
                        BDC,    32, 
                        BFC,    32, 
                        BTC,    32, 
                        BDV,    32, 
                        BST,    32, 
                        BPR,    32, 
                        BRC,    32, 
                        BPV,    32, 
                        BTP,    32, 
                        BCW,    32, 
                        BCL,    32, 
                        BCG,    32, 
                        BG2,    32, 
                        BMO,    32, 
                        BIF,    64, 
                        BSN0,   32, 
                        BSN1,   32, 
                        BTY0,   8, 
                        BTY1,   8, 
                        BTY2,   8, 
                        BTY3,   8, 
                        AC0,    16, 
                        PSV,    16, 
                        CRT,    16, 
                        TMP,    16, 
                        NABT,   8, 
                        Offset (0xE2)
                    }

                    Mutex (MTX0, 0x00)
                    Mutex (MTX1, 0x00)
                    Method (_Q11, 0, NotSerialized)
                    {
                        Notify (\_SB.SLPB, 0x80)
                    }

                    Method (_Q06, 0, NotSerialized)
                    {
                        Store ("AC Adapter In/Out", Debug)
                        If (\_SB.PCI0.PIB.EC.ECOK)
                        {
                            Acquire (MTX0, 0xFFFF)
                            Store (ADP, Debug)
                            Release (MTX0)
                            If (ADP)
                            {
                                Notify (\_SB.AC, 0x00)
                            }
                            Else
                            {
                                Notify (\_SB.AC, 0x01)
                            }
                        }
                        Else
                        {
                            Notify (\_SB.AC, 0x00)
                        }
                    }

                    Method (_Q08, 0, NotSerialized)
                    {
                        Store ("Battery In/Out", Debug)
                        \_SB.BAT0.Z004 ()
                    }

                    Method (_Q09, 0, NotSerialized)
                    {
                        Store ("Battery charge/discharge", Debug)
                        \_SB.BAT0.UBST ()
                        Notify (\_SB.BAT0, 0x80)
                    }

                    Method (_Q03, 0, NotSerialized)
                    {
                        Store ("Low Batt 1", Debug)
                        Notify (\_SB.BAT0, 0x80)
                    }

                    Method (_Q04, 0, NotSerialized)
                    {
                        Store ("Low Batt 2", Debug)
                        Notify (\_SB.BAT0, 0x80)
                    }

                    Method (_Q0A, 0, NotSerialized)
                    {
                        Store ("Lid runtime event", Debug)
                        Sleep (0x3E8)
                        Notify (\_SB.LID, 0x80)
                    }

                    Method (_Q10, 0, NotSerialized)
                    {
                        Store ("==== Fn+F3 hot key handler ====", Debug)
                        Store ("Change between LCD, CRT, or both LCD and CRT displays", Debug)
                        Store (\_SB.PCI0.AGP.VGA.SWIT, Local0)
                        If (LEqual (Local0, 0x00))
                        {
                            \_SB.Z001 (0x87)
                            Store (\_SB.PCI0.DISD, Local1)
                            If (LEqual (Local1, 0x00))
                            {
                                Store ("LCD Without  CRT  Connect", Debug)
                                Store (One, \_SB.PCI0.AGP.VGA.LCDA)
                                Store (Zero, \_SB.PCI0.AGP.VGA.CRTA)
                                Store (Zero, \_SB.PCI0.AGP.VGA.TVOA)
                            }

                            If (LEqual (Local1, 0x01))
                            {
                                Store ("LCD", Debug)
                                Store (One, \_SB.PCI0.AGP.VGA.LCDA)
                                Store (Zero, \_SB.PCI0.AGP.VGA.CRTA)
                                Store (Zero, \_SB.PCI0.AGP.VGA.TVOA)
                            }

                            If (LEqual (Local1, 0x02))
                            {
                                Store ("CRT", Debug)
                                Store (Zero, \_SB.PCI0.AGP.VGA.LCDA)
                                Store (One, \_SB.PCI0.AGP.VGA.CRTA)
                                Store (Zero, \_SB.PCI0.AGP.VGA.TVOA)
                            }

                            If (LEqual (Local1, 0x03))
                            {
                                Store ("CRT And LCD", Debug)
                                Store (One, \_SB.PCI0.AGP.VGA.LCDA)
                                Store (One, \_SB.PCI0.AGP.VGA.CRTA)
                                Store (Zero, \_SB.PCI0.AGP.VGA.TVOA)
                            }

                            If (LEqual (Local1, 0x04))
                            {
                                Store ("TV Only ", Debug)
                                Store (Zero, \_SB.PCI0.AGP.VGA.LCDA)
                                Store (Zero, \_SB.PCI0.AGP.VGA.CRTA)
                                Store (One, \_SB.PCI0.AGP.VGA.TVOA)
                            }

                            Store (\_SB.PCI0.AGP.VGA.SWIT, Local0)
                            If (LEqual (Local0, 0x00))
                            {
                                Notify (\_SB.PCI0.AGP.VGA, 0x80)
                            }
                            Else
                            {
                                \_SB.Z001 (0x86)
                            }
                        }
                        Else
                        {
                            \_SB.Z001 (0x86)
                        }
                    }
                }
            }

            Name (REGT, Package (0x15)
            {
                0x10, 
                0x20, 
                0x21, 
                0x22, 
                0x23, 
                0x33, 
                0x34, 
                0x35, 
                0x36, 
                0x37, 
                0x47, 
                0x48, 
                0x49, 
                0x4A, 
                0x4B, 
                0x4C, 
                0x5C, 
                0x5D, 
                0x5E, 
                0x5F, 
                0x6F
            })
            Name (DMTB, Package (0x08)
            {
                0x05, 
                0x04, 
                0x03, 
                0x02, 
                0x02, 
                0x01, 
                0x01, 
                0x00
            })
            Name (PIOT, Package (0x07)
            {
                0x258, 
                0x17F, 
                0xF0, 
                0xB4, 
                0x78, 
                0x5A, 
                0x00
            })
            Device (IDE)
            {
                Name (_ADR, 0x70001)
                OperationRegion (PCI, PCI_Config, 0x48, 0x60)
                Field (PCI, DWordAcc, NoLock, Preserve)
                {
                    SDR1,   8, 
                    SDR0,   8, 
                    PDR1,   8, 
                    PDR0,   8, 
                    SDST,   4, 
                    PDST,   4, 
                    Offset (0x08), 
                    UDMS,   16, 
                    UDMP,   16
                }

                Method (GTM, 3, NotSerialized)
                {
                    Store (Buffer (0x14) {}, Local0)
                    CreateDWordField (Local0, 0x00, PIO0)
                    CreateDWordField (Local0, 0x04, DMA0)
                    CreateDWordField (Local0, 0x08, PIO1)
                    CreateDWordField (Local0, 0x0C, DMA1)
                    CreateDWordField (Local0, 0x10, FLAG)
                    Store (Zero, FLAG)
                    Or (FLAG, 0x10, FLAG)
                    Add (And (Arg1, 0x0F), ShiftRight (Arg1, 0x04), Local1)
                    Add (Local1, 0x02, Local1)
                    Multiply (Local1, 0x1E, PIO0)
                    Or (FLAG, 0x02, FLAG)
                    Add (And (Arg2, 0x0F), ShiftRight (Arg2, 0x04), Local1)
                    Add (Local1, 0x02, Local1)
                    Multiply (Local1, 0x1E, PIO1)
                    Or (FLAG, 0x08, FLAG)
                    If (And (Arg0, 0xE0))
                    {
                        Or (FLAG, 0x04, FLAG)
                    }

                    Add (And (Arg0, 0x07), 0x02, Local1)
                    Multiply (Local1, 0x0A, DMA1)
                    If (And (Arg0, 0xE000))
                    {
                        Or (FLAG, 0x01, FLAG)
                    }

                    Add (ShiftRight (And (Arg0, 0x700), 0x08), 0x02, Local1)
                    Multiply (Local1, 0x0A, DMA0)
                    Return (Local0)
                }

                Method (STM, 3, NotSerialized)
                {
                    Store (Buffer (0x05) {}, Local7)
                    CreateWordField (Local7, 0x00, UDMT)
                    CreateWordField (Local7, 0x02, PIOT)
                    CreateByteField (Local7, 0x04, R4CT)
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Store (FLAG, Local4)
                    Store (0x707, Local1)
                    If (And (Local4, 0x01))
                    {
                        And (Local1, 0x07, Local1)
                        Divide (DMA0, 0x0A, , Local3)
                        Subtract (Local3, 0x02, Local3)
                        Or (Local3, 0xE0, Local3)
                        Or (ShiftLeft (Local3, 0x08, Local3), Local1, Local1)
                    }

                    If (And (Local4, 0x04))
                    {
                        And (Local1, 0x700, Local1)
                        Divide (DMA1, 0x0A, , Local3)
                        Subtract (Local3, 0x02, Local3)
                        Or (Or (Local3, 0xE0), Local1, Local1)
                    }

                    Store (Local1, UDMT)
                    Store (0x0A, Local2)
                    If (And (Local4, 0x02))
                    {
                        Divide (PIO0, 0x1E, , Local3)
                        Subtract (Local3, 0x03, Local3)
                        If (LLess (Local3, 0x0C))
                        {
                            And (Local2, 0x03, Local2)
                            Or (Local2, 0x04, Local2)
                        }

                        Store (ShiftLeft (DerefOf (Index (^^REGT, Local3)), 0x08), Local6)
                    }
                    Else
                    {
                        Store (0x00, Local6)
                    }

                    If (And (Local4, 0x08))
                    {
                        Divide (PIO1, 0x1E, , Local3)
                        Subtract (Local3, 0x03, Local3)
                        If (LLess (Local3, 0x0C))
                        {
                            And (Local2, 0x0C, Local2)
                            Or (Local2, 0x01, Local2)
                        }

                        Store (DerefOf (Index (^^REGT, Local3)), Local6)
                    }
                    Else
                    {
                        Store (And (Local6, 0xFF00), Local6)
                    }

                    Store (Local2, R4CT)
                    Store (Local6, PIOT)
                    Return (Local7)
                }

                Method (GTF, 2, NotSerialized)
                {
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                        }, Local7)
                    CreateByteField (Local7, 0x01, MODE)
                    Add (And (Arg0, 0x0F), ShiftRight (Arg0, 0x04), Local1)
                    Add (Local1, 0x02, Local1)
                    Multiply (Local1, 0x1E, Local0)
                    Store (Match (^^PIOT, MLT, Local0, MTR, 0x00, 0x00), Local1)
                    If (Local1)
                    {
                        Decrement (Local1)
                    }

                    If (And (Arg1, 0xE0))
                    {
                        Store (DerefOf (Index (^^DMTB, And (Arg1, 0x07))), Local0)
                        Or (Local0, 0x40, MODE)
                    }
                    Else
                    {
                        Or (Local1, 0x08, MODE)
                    }

                    Concatenate (Local7, Local7, Local6)
                    Or (Local1, 0x08, MODE)
                    Concatenate (Local6, Local7, Local5)
                    Return (Local5)
                }

                Device (PRIM)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Store ("GTM - Primary Controller", Debug)
                        Store (^^GTM (^^UDMP, ^^PDR0, ^^PDR1), Local0)
                        Return (Local0)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store ("STM - Primary Controller", Debug)
                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
                        CreateWordField (Local0, 0x00, UDMA)
                        CreateWordField (Local0, 0x02, PIOM)
                        CreateByteField (Local0, 0x04, ADST)
                        Store (UDMA, ^^UDMP)
                        Store (And (PIOM, 0xFF), Local1)
                        If (Local1)
                        {
                            Store (Local1, ^^PDR1)
                        }

                        ShiftRight (PIOM, 0x08, Local1)
                        If (Local1)
                        {
                            Store (Local1, ^^PDR0)
                        }

                        Store (ADST, ^^PDST)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Name (H15F, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Primary Master", Debug)
                            ShiftRight (^^^UDMP, 0x08, Local0)
                            Store (^^^GTF (^^^PDR0, Local0), Local0)
                            Return (Local0)
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Primary Slave", Debug)
                            Store (^^^GTF (^^^PDR1, ^^^UDMP), Local0)
                            Return (Local0)
                        }
                    }
                }

                Device (SECN)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Store ("GTM - Secondary Controller", Debug)
                        Store (^^GTM (^^UDMS, ^^SDR0, ^^SDR1), Local0)
                        Return (Local0)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store ("STM - Secondary Controller", Debug)
                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
                        CreateWordField (Local0, 0x00, UDMS)
                        CreateWordField (Local0, 0x02, PIOS)
                        CreateByteField (Local0, 0x04, ADSS)
                        Store (UDMS, ^^UDMS)
                        And (PIOS, 0xFF, Local1)
                        If (Local1)
                        {
                            Store (Local1, ^^SDR1)
                        }

                        ShiftRight (PIOS, 0x08, Local1)
                        If (Local1)
                        {
                            Store (Local1, ^^SDR0)
                        }

                        Store (ADSS, ^^SDST)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Name (H15F, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Secondary Master", Debug)
                            ShiftRight (^^^UDMS, 0x08, Local0)
                            Store (^^^GTF (^^^SDR0, Local0), Local0)
                            Return (Local0)
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Secondary Slave", Debug)
                            Store (^^^GTF (^^^SDR1, ^^^UDMS), Local0)
                            Return (Local0)
                        }
                    }
                }
            }

            Device (USB0)
            {
                Name (_ADR, 0x70002)
                OperationRegion (SB72, PCI_Config, 0x00, 0xC2)
                Field (SB72, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x04), 
                    UA04,   8, 
                    Offset (0x20), 
                    UA20,   8, 
                    UA21,   8, 
                    UA22,   8, 
                    UA23,   8, 
                    Offset (0x3C), 
                    U0IR,   4
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (\_SB.PCI0.PIB.EUSB)
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x70003)
                OperationRegion (SB72, PCI_Config, 0x00, 0xC2)
                Field (SB72, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x04), 
                    UB04,   8, 
                    Offset (0x20), 
                    UB20,   8, 
                    UB21,   8, 
                    UB22,   8, 
                    UB23,   8, 
                    Offset (0x3C), 
                    U1IR,   4
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (\_SB.PCI0.PIB.ESB1)
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    If (LNot (LLess (\_SB.PCI0.OSF, 0x02)))
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }
            }

            Device (PM)
            {
                Name (_ADR, 0x70004)
                OperationRegion (SB74, PCI_Config, 0x00, 0x100)
                Field (SB74, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x44), 
                    PIR0,   8, 
                    PIR8,   8, 
                    Offset (0x54), 
                        ,   4, 
                    SUSC,   1, 
                    Offset (0x55), 
                    USBP,   1
                }

                OperationRegion (PMIO, SystemIO, 0x8000, 0x50)
                Field (PMIO, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x28), 
                        ,   7, 
                    PIRS,   1, 
                    Offset (0x2A), 
                        ,   7, 
                    PIEN,   1, 
                    Offset (0x2C), 
                        ,   7, 
                    LPOL,   1, 
                    Offset (0x2F), 
                    BCMD,   8, 
                    Offset (0x48), 
                    EXMI,   1, 
                        ,   2, 
                    LIDI,   1
                }

                OperationRegion (SMIO, SystemIO, 0x8080, 0x07)
                Field (SMIO, ByteAcc, NoLock, Preserve)
                {
                    HSTS,   8, 
                    SSTS,   8, 
                    CTLR,   8, 
                    CMDR,   8, 
                    ADDR,   8, 
                    DAT0,   8, 
                    DAT1,   8
                }
            }

            Device (AUDI)
            {
                Name (_ADR, 0x70005)
                OperationRegion (SB75, PCI_Config, 0x00, 0x85)
                Field (SB75, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x3C), 
                    ACIR,   4
                }
            }

            Device (CRD0)
            {
                Name (_ADR, 0xA0000)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Method (_INI, 0, NotSerialized)
                {
                    Or (PMEE, 0x01, PMEE)
                }

                Method (_PSC, 0, NotSerialized)
                {
                    Store (PWST, Local0)
                    Return (Local0)
                }

                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                OperationRegion (CCRD, PCI_Config, 0x00, 0xA7)
                Field (CCRD, DWordAcc, Lock, Preserve)
                {
                    Offset (0x80), 
                    PMEE,   1, 
                    Offset (0x81), 
                    Offset (0xA4), 
                    PWST,   2, 
                    Offset (0xA5), 
                        ,   7, 
                    PMST,   1
                }
            }

            Device (LMDM)
            {
                Name (_ADR, 0x90000)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
            }

            Device (RLAN)
            {
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Name (_ADR, 0xB0000)
            }
        }
    }
}