/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20060912
 *
 * Disassembly of dsdt.dat, Sun Jul 29 21:48:46 2007
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x0000765B (30299)
 *     Revision         0x01
 *     OEM ID           "1ABZX"
 *     OEM Table ID     "1ABZX001"
 *     OEM Revision     0x00000001 (1)
 *     Creator ID       "INTL"
 *     Creator Revision 0x02002026 (33562662)
 */
DefinitionBlock ("dsdt.aml", "DSDT", 1, "1ABZX", "1ABZX001", 0x00000001)
{
    External (\_SB_.PCI0.P0P1.VGA_.ODSF)

    Scope (\_SB)
    {
        Name (ATKP, Zero)
        Device (ATKD)
        {
            Name (_HID, "ATK0100")
            Name (_UID, 0x01010100)
            Method (INIT, 1, NotSerialized)
            {
                Store (One, ATKP)
                Return (\MNAM)
            }

            Method (BSTS, 0, NotSerialized)
            {
                Store (\IKFG, Local0)
                If (\ACPF)
                {
                    And (Local0, 0x7F, Local0)
                }

                Return (Local0)
            }

            Method (MLED, 1, NotSerialized)
            {
                OMLD (Arg0)
            }

            Method (TMPR, 0, NotSerialized)
            {
                Store (\_TZ.GTMP (), Local0)
                Store (\_TZ.RFAN (), Local1)
                Store (RWRD (0x5D, 0x30), Local4)
                And (Local4, 0xFF, Local4)
                If (LEqual (Local4, 0x73))
                {
                    Store (0x1C, Local1)
                }

                ShiftLeft (Local1, 0x10, Local1)
                Add (\_TZ.KELV (Local0), Local1, Local0)
                Store (Zero, Local2)
                If (\TENA)
                {
                    Store (\TDTY, Local2)
                }
                Else
                {
                    Store (HKTH (), Local3)
                    If (LNotEqual (Local3, 0xFFFF))
                    {
                        Store (Local3, Local2)
                    }
                }

                ShiftLeft (Local2, 0x18, Local2)
                Add (Local0, Local2, Local0)
                Return (Local0)
            }

            Method (SFUN, 0, NotSerialized)
            {
                Store (0x37, Local0)
                Or (Local0, 0x40, Local0)
                Or (Local0, 0x80, Local0)
                Or (Local0, 0x0800, Local0)
                Return (Local0)
            }

            Method (WLED, 1, NotSerialized)
            {
                Store (Arg0, WLEN)
                OWLD (Arg0)
            }

            Method (BLED, 1, NotSerialized)
            {
                Store (Arg0, BTEN)
                OBTD (Arg0)
            }

            Method (RSTS, 0, NotSerialized)
            {
                Store (Zero, Local0)
                Or (Local0, 0x0300, Local0)
                If (BTEN)
                {
                    Or (Local0, 0x02, Local0)
                }

                If (WLEN)
                {
                    Or (Local0, 0x01, Local0)
                }

                Return (Local0)
            }

            Method (HWRS, 0, NotSerialized)
            {
                Store (Zero, Local0)
                If (\_SB.PCI0.MPCI.MPDP ())
                {
                    Or (Local0, 0x80, Local0)
                }

                If (One)
                {
                    Or (Local0, 0x0100, Local0)
                }

                Return (Local0)
            }

            Method (QMOD, 1, NotSerialized)
            {
                If (LEqual (Arg0, 0x00))
                {
                    Return (One)
                }

                If (LEqual (Arg0, 0x01))
                {
                    FFCT ()
                    \_TZ.TCHG ()
                    Return (One)
                }

                If (LEqual (Arg0, 0x02))
                {
                    AFEN ()
                    \_TZ.TCHG ()
                    Return (One)
                }

		Return (Zero)
            }

            Method (WDEV, 0, NotSerialized)
            {
                Return (\_SB.PCI0.MPCI.MPDP ())
            }

            Method (OSVR, 1, NotSerialized)
            {
                Store (Arg0, \OSFG)
            }

            Method (GPLV, 0, NotSerialized)
            {
                Return (\LBTN)
            }

            Method (SPLV, 1, NotSerialized)
            {
                Store (Arg0, \LBTN)
                \_SB.PCI0.SBRG.EC0.STBR ()
            }

            Method (SDSP, 1, NotSerialized)
            {
                If (\NATK ())
                {
                    \SWHG (Arg0)
                }
            }

            Method (GPID, 0, NotSerialized)
            {
                Return (OPID ())
            }

            Method (SMBB, 1, Serialized)
            {
                ShiftRight (Arg0, 0x10, Local0)
                And (Local0, 0xFF, Local0)
                ShiftRight (Arg0, 0x18, Local1)
                And (Arg0, 0xFF, Local2)
                If (And (Local1, 0x01))
                {
                    Return (\RBYT (Local1, Local0))
                }
                Else
                {
                    Return (\WBYT (Local1, Local0, Local2))
                }
            }

            Method (SMBW, 1, Serialized)
            {
                ShiftRight (Arg0, 0x10, Local0)
                And (Local0, 0xFF, Local0)
                ShiftRight (Arg0, 0x18, Local1)
                And (Arg0, 0xFF, Local2)
                If (And (Local1, 0x01))
                {
                    Return (\RWRD (Local1, Local0))
                }
                Else
                {
                    Return (\WWRD (Local1, Local0, Local2))
                }
            }

            Method (SMBK, 1, Serialized)
            {
                ShiftRight (Arg0, 0x08, Local0)
                And (Local0, 0xFF, Local0)
                If (Local0)
                {
                    ShiftRight (Arg0, 0x10, Local0)
                    And (Local0, 0xFF, Local0)
                    ShiftRight (Arg0, 0x18, Local1)
                    And (Local1, 0xFF, Local1)
                    And (Arg0, 0x0F, Local3)
                    If (And (Local1, 0x01))
                    {
                        RBLK (Local1, Local0, Local3)
                    }
                    Else
                    {
                        WBLK (Local1, Local0, Local3)
                    }

                    Return (0x00)
                }
                Else
                {
                    ShiftRight (Arg0, 0x10, Local2)
                    And (Local2, 0xFF, Local2)
                    ShiftRight (Arg0, 0x18, Local1)
                    If (And (Local1, 0x01))
                    {
                        Return (DerefOf (Index (RBUF, Local2)))
                    }
                    Else
                    {
                        And (Arg0, 0xFF, Local1)
                        Store (Local1, Index (RBUF, Local2))
                        Return (0x00)
                    }
                }
            }

            Method (ECRW, 1, Serialized)
            {
                ShiftRight (Arg0, 0x18, Local0)
                And (Local0, 0xFF, Local0)
                ShiftRight (Arg0, 0x10, Local1)
                And (Local1, 0xFF, Local1)
                ShiftRight (Arg0, 0x08, Local2)
                And (Local2, 0xFF, Local2)
                And (Arg0, 0xFF, Local3)
                If (LNotEqual (Acquire (\P4SM, 0xFFFF), 0x00))
                {
                    Return (Ones)
                }

                Store (Local0, \_SB.PCI0.SBRG.EC0.CDT3)
                Store (Local1, \_SB.PCI0.SBRG.EC0.CDT2)
                Store (Local2, \_SB.PCI0.SBRG.EC0.CDT1)
                Store (Local3, \_SB.PCI0.SBRG.EC0.CMD1)
                Store (0x05, Local0)
                While (LAnd (Local0, \_SB.PCI0.SBRG.EC0.CMD1))
                {
                    Sleep (0x01)
                    Decrement (Local0)
                }

                Store (\_SB.PCI0.SBRG.EC0.CDT3, Local0)
                Store (\_SB.PCI0.SBRG.EC0.CDT2, Local1)
                Store (\_SB.PCI0.SBRG.EC0.CDT1, Local2)
                Store (\_SB.PCI0.SBRG.EC0.CMD1, Local3)
                Release (\P4SM)
                ShiftLeft (Local0, 0x08, Local0)
                Or (Local0, Local1, Local0)
                ShiftLeft (Local0, 0x08, Local0)
                Or (Local0, Local2, Local0)
                ShiftLeft (Local0, 0x08, Local0)
                Or (Local0, Local3, Local0)
                Return (Local0)
            }
        }
    }

    Name (IRID, 0x10F0A34D)
    Name (SPIO, 0x2E)
    Name (IO1B, 0x0A00)
    Name (IO1L, 0x10)
    Name (APIC, 0x01)
    Name (PMBS, 0x0800)
    Name (PMLN, 0xE0)
    Name (GPBS, 0x00)
    Name (GPLN, 0x00)
    Name (SMBL, 0x20)
    Name (PCIB, 0xE0000000)
    Name (PCIL, 0x10000000)
    Name (APCB, 0xFEC00000)
    Name (APCL, 0x00100000)
    Name (SMBS, 0x08E0)
    Name (MBLF, 0x0A)
    OperationRegion (BIOS, SystemMemory, 0x3FFDE064, 0xFF)
    Field (BIOS, ByteAcc, NoLock, Preserve)
    {
        SS1,    1, 
        SS2,    1, 
        SS3,    1, 
        SS4,    1, 
                Offset (0x01), 
        IOST,   16, 
        TOPM,   32, 
        ROMS,   32, 
        MG1B,   32, 
        MG1L,   32, 
        MG2B,   32, 
        MG2L,   32, 
                Offset (0x1C), 
        ASSB,   8, 
        AOTB,   8, 
        AAXB,   32
    }

    Method (RRIO, 4, NotSerialized)
    {
        Store ("RRIO", Debug)
    }

    Method (RDMA, 3, NotSerialized)
    {
        Store ("rDMA", Debug)
    }

    Name (PICM, 0x00)
    Method (_PIC, 1, NotSerialized)
    {
        If (Arg0)
        {
            Store (0xAA, DBG8)
        }
        Else
        {
            Store (0xAC, DBG8)
        }

        Store (Arg0, PICM)
    }

    Name (OSVR, Ones)
    Method (OSFL, 0, NotSerialized)
    {
        If (LNotEqual (OSVR, Ones))
        {
            Return (OSVR)
        }

        If (LEqual (PICM, 0x00))
        {
            Store (0xAC, DBG8)
        }

        Store (0x01, OSVR)
        If (MCTH (\_OS, "Microsoft Windows NT"))
        {
            Store (0x00, OSVR)
        }
        Else
        {
            If (MCTH (\_OS, "Microsoft WindowsME: Millennium Edition"))
            {
                Store (0x02, OSVR)
            }

            If (MCTH (\_OS, "Linux"))
            {
                Store (0x03, OSVR)
            }
        }

        Return (OSVR)
    }

    Method (MCTH, 2, NotSerialized)
    {
        If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
        {
            Return (Zero)
        }

        Add (SizeOf (Arg0), 0x01, Local0)
        Name (BUF0, Buffer (Local0) {})
        Name (BUF1, Buffer (Local0) {})
        Store (Arg0, BUF0)
        Store (Arg1, BUF1)
        While (Local0)
        {
            Decrement (Local0)
            If (LNotEqual (DerefOf (Index (BUF0, Local0)), DerefOf (Index (
                BUF1, Local0))))
            {
                Return (Zero)
            }
        }

        Return (One)
    }

    Name (PRWP, Package (0x02)
    {
        Zero, 
        Zero
    })
    Method (GPRW, 2, NotSerialized)
    {
        Store (Arg0, Index (PRWP, 0x00))
        Store (ShiftLeft (SS1, 0x01), Local0)
        Or (Local0, ShiftLeft (SS2, 0x02), Local0)
        Or (Local0, ShiftLeft (SS3, 0x03), Local0)
        Or (Local0, ShiftLeft (SS4, 0x04), Local0)
        If (And (ShiftLeft (0x01, Arg1), Local0))
        {
            Store (Arg1, Index (PRWP, 0x01))
        }
        Else
        {
            ShiftRight (Local0, 0x01, Local0)
            If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))
            {
                FindSetLeftBit (Local0, Index (PRWP, 0x01))
            }
            Else
            {
                FindSetRightBit (Local0, Index (PRWP, 0x01))
            }
        }

        Return (PRWP)
    }

    Name (WAKP, Package (0x02)
    {
        Zero, 
        Zero
    })
    OperationRegion (DEB0, SystemIO, 0x80, 0x01)
    Field (DEB0, ByteAcc, NoLock, Preserve)
    {
        DBG8,   8
    }

    OperationRegion (DEB1, SystemIO, 0x90, 0x02)
    Field (DEB1, WordAcc, NoLock, Preserve)
    {
        DBG9,   16
    }

    Scope (\_SB)
    {
        Name (PR00, Package (0x16)
        {
            Package (0x04)
            {
                0x0001FFFF, 
                0x00, 
                LNKA, 
                0x00
            }, 

            Package (0x04)
            {
                0x0001FFFF, 
                0x01, 
                LNKB, 
                0x00
            }, 

            Package (0x04)
            {
                0x0001FFFF, 
                0x02, 
                LNKC, 
                0x00
            }, 

            Package (0x04)
            {
                0x0001FFFF, 
                0x03, 
                LNKD, 
                0x00
            }, 

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

            Package (0x04)
            {
                0x0002FFFF, 
                0x01, 
                LNKB, 
                0x00
            }, 

            Package (0x04)
            {
                0x0002FFFF, 
                0x02, 
                LNKC, 
                0x00
            }, 

            Package (0x04)
            {
                0x0002FFFF, 
                0x03, 
                LNKD, 
                0x00
            }, 

            Package (0x04)
            {
                0x0008FFFF, 
                0x00, 
                LNKC, 
                0x00
            }, 

            Package (0x04)
            {
                0x0008FFFF, 
                0x01, 
                LNKD, 
                0x00
            }, 

            Package (0x04)
            {
                0x0008FFFF, 
                0x02, 
                LNKA, 
                0x00
            }, 

            Package (0x04)
            {
                0x0008FFFF, 
                0x03, 
                LNKB, 
                0x00
            }, 

            Package (0x04)
            {
                0x000BFFFF, 
                0x00, 
                LNKD, 
                0x00
            }, 

            Package (0x04)
            {
                0x000AFFFF, 
                0x00, 
                LNKB, 
                0x00
            }, 

            Package (0x04)
            {
                0x000AFFFF, 
                0x01, 
                LNKC, 
                0x00
            }, 

            Package (0x04)
            {
                0x000AFFFF, 
                0x02, 
                LNKD, 
                0x00
            }, 

            Package (0x04)
            {
                0x0009FFFF, 
                0x00, 
                LNKC, 
                0x00
            }, 

            Package (0x04)
            {
                0x0009FFFF, 
                0x01, 
                LNKD, 
                0x00
            }, 

            Package (0x04)
            {
                0x0003FFFF, 
                0x03, 
                LNKH, 
                0x00
            }, 

            Package (0x04)
            {
                0x0003FFFF, 
                0x00, 
                LNKE, 
                0x00
            }, 

            Package (0x04)
            {
                0x0003FFFF, 
                0x01, 
                LNKF, 
                0x00
            }, 

            Package (0x04)
            {
                0x0003FFFF, 
                0x02, 
                LNKG, 
                0x00
            }
        })
        Name (AR00, Package (0x16)
        {
            Package (0x04)
            {
                0x0001FFFF, 
                0x00, 
                0x00, 
                0x10
            }, 

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

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

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

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

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

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

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

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

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

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

            Package (0x04)
            {
                0x0008FFFF, 
                0x03, 
                0x00, 
                0x11
            }, 

            Package (0x04)
            {
                0x000BFFFF, 
                0x00, 
                0x00, 
                0x13
            }, 

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

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

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

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

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

            Package (0x04)
            {
                0x0003FFFF, 
                0x03, 
                0x00, 
                0x17
            }, 

            Package (0x04)
            {
                0x0003FFFF, 
                0x00, 
                0x00, 
                0x14
            }, 

            Package (0x04)
            {
                0x0003FFFF, 
                0x01, 
                0x00, 
                0x15
            }, 

            Package (0x04)
            {
                0x0003FFFF, 
                0x02, 
                0x00, 
                0x16
            }
        })
        Name (PR01, Package (0x01)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                LNKA, 
                0x00
            }
        })
        Name (AR01, Package (0x01)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                0x00, 
                0x10
            }
        })
        Name (PRSA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {3,4,5,7,10,11,12,14,15}
        })
        Alias (PRSA, PRSB)
        Alias (PRSA, PRSC)
        Alias (PRSA, PRSD)
        Alias (PRSA, PRSE)
        Alias (PRSA, PRSF)
        Alias (PRSA, PRSG)
        Alias (PRSA, PRSH)
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00180000)
            Method (^BN00, 0, NotSerialized)
            {
                Return (0x00)
            }

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

            Name (_UID, 0x00)
            Method (_PRT, 0, NotSerialized)
            {
                If (PICM)
                {
                    Return (AR00)
                }

                Return (PR00)
            }

            Method (NPTS, 1, NotSerialized)
            {
            }

            Method (NWAK, 1, NotSerialized)
            {
            }

            Device (P0P1)
            {
                Name (_ADR, 0x00010000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR01)
                    }

                    Return (PR01)
                }

                Device (VGA)
                {
                    Name (_ADR, 0x00)
                    OperationRegion (VSID, PCI_Config, 0x00, 0x04)
                    Field (VSID, ByteAcc, NoLock, Preserve)
                    {
                        REG0,   32
                    }

                    Method (PRST, 0, NotSerialized)
                    {
                        If (LEqual (REG0, 0xFFFFFFFF))
                        {
                            Return (Zero)
                        }
                        Else
                        {
                            Return (One)
                        }
                    }

                    Name (UPDN, One)
                    Name (NXTD, 0x01)
                    Name (LCDM, 0x01)
                    Name (CRTM, 0x02)
                    Name (TVOM, 0x04)
                    Name (DONE, Zero)
                    Name (DOSF, One)
                    Method (_INI, 0, NotSerialized)
                    {
                        GETD ()
                    }

                    Method (_DOS, 1, NotSerialized)
                    {
                        Store (Arg0, DOSF)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Return (Package (0x03)
                        {
                            0x00010100, 
                            0x00010110, 
                            0x0200
                        })
                    }

                    Device (CRTD)
                    {
                        Name (_ADR, 0x0100)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store (\AVLD, Local0)
                            If (Local0)
                            {
                                If (And (Local0, CRTM))
                                {
                                    Return (0x1F)
                                }
                            }

                            Return (0x1D)
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (NXTD, CRTM, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }

                            Return (0x00)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            If (And (Arg0, 0x40000000))
                            {
                                If (And (Arg0, 0x80000000))
                                {
                                    Store (One, DONE)
                                }
                            }
                        }
                    }

                    Device (TVOD)
                    {
                        Name (_ADR, 0x0200)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store (\AVLD, Local0)
                            If (Local0)
                            {
                                If (And (Local0, TVOM))
                                {
                                    Return (0x1F)
                                }
                            }

                            Return (0x1D)
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (NXTD, TVOM, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }

                            Return (0x00)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            If (And (Arg0, 0x40000000))
                            {
                                If (And (Arg0, 0x80000000))
                                {
                                    Store (One, DONE)
                                }
                            }
                        }
                    }

                    Device (LCDD)
                    {
                        Name (_ADR, 0x0110)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store (\AVLD, Local0)
                            If (Local0)
                            {
                                If (And (Local0, LCDM))
                                {
                                    Return (0x1F)
                                }
                            }

                            Return (0x1D)
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            And (NXTD, LCDM, Local0)
                            If (Local0)
                            {
                                Return (0x01)
                            }

                            Return (0x00)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            If (And (Arg0, 0x40000000))
                            {
                                If (And (Arg0, 0x80000000))
                                {
                                    Store (One, DONE)
                                }
                            }
                        }

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

                        Name (BCBH, 0x00)
                        Method (_BCM, 1, NotSerialized)
                        {
                            Store (Arg0, LBTN)
                            \_SB.PCI0.SBRG.EC0.STBR ()
                            If (\_SB.ATKP)
                            {
                                If (LEqual (BCBH, 0x01))
                                {
                                    Notify (\_SB.ATKD, Add (LBTN, 0x10))
                                }

                                If (LEqual (BCBH, 0x02))
                                {
                                    Notify (\_SB.ATKD, Add (LBTN, 0x20))
                                }
                            }

                            Store (0x00, BCBH)
                        }

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

                    Method (SWHD, 1, Serialized)
                    {
                        Store (One, UPDN)
                        If (DOSF)
                        {
                            Store (Arg0, \SETD)
                            ISMI (0x94)
                        }
                        Else
                        {
                            Store (Zero, DONE)
                            Notify (VGA, 0x80)
                            Store (0x01F4, Local0)
                            While (Local0)
                            {
                                If (DONE)
                                {
                                    Store (Zero, Local0)
                                }
                                Else
                                {
                                    Sleep (0x0A)
                                    Decrement (Local0)
                                }
                            }
                        }
                    }

                    Method (GETD, 0, NotSerialized)
                    {
                        ISMI (0x95)
                        Return (\ACTD)
                    }

                    Method (ADVD, 0, NotSerialized)
                    {
                        If (UPDN)
                        {
                            GETD ()
                            Store (\ACTD, \SETD)
                            Store (Zero, UPDN)
                        }

                        ISMI (0xA0)
                        Store (\SETD, NXTD)
                        Return (\SETD)
                    }

                    Method (NATK, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }
            }

            Device (SBRG)
            {
                Name (_ADR, 0x00020000)
                Method (SPTS, 1, NotSerialized)
                {
                    Or (P42, 0x41, P42)
                }

                Method (SWAK, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x01))
                    {
                        And (RTCE, RTC1, RTCE)
                        If (RTCE)
                        {
                            Store (0xC1, DBG8)
                        }
                        Else
                        {
                        }
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        If (RTC3)
                        {
                            Store (0xC3, DBG8)
                        }
                        Else
                        {
                        }
                    }

                    Or (P42, 0x21, P42)
                    Or (Arg0, 0xA0, Local0)
                    Store (Local0, P48)
                }

                OperationRegion (PR42, SystemIO, 0x0842, 0x01)
                Field (PR42, ByteAcc, NoLock, Preserve)
                {
                    P42,    8
                }

                OperationRegion (PR48, SystemIO, 0x0848, 0x01)
                Field (PR48, ByteAcc, NoLock, Preserve)
                {
                    P48,    8
                }

                OperationRegion (S1WK, SystemIO, 0x0800, 0x02)
                Field (S1WK, ByteAcc, NoLock, Preserve)
                {
                        ,   10, 
                    RTC1,   1
                }

                OperationRegion (PP49, SystemIO, 0x0849, 0x01)
                Field (PP49, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x00), 
                    RTCE,   1
                }

                OperationRegion (S3WK, SystemIO, 0x0860, 0x02)
                Field (S3WK, ByteAcc, NoLock, Preserve)
                {
                        ,   14, 
                    RTC3,   1
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0020,             // Range Minimum
                            0x0020,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A0,             // Range Minimum
                            0x00A0,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {2}
                    })
                }

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

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

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

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CID, 0x0B03D041)
                    Method (_STA, 0, NotSerialized)
                    {
                        ShiftLeft (0x01, 0x0A, Local0)
                        If (And (IOST, Local0))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Range Minimum
                            0x0060,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0064,             // Range Minimum
                            0x0064,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {1}
                    })
                }

                Device (PS2M)
                {
                    Name (_HID, EisaId ("SYN0A04"))
                    Name (_CID, Package (0x05)
                    {
                        0x000A2E4F, 
                        0x02002E4F, 
                        0x030FD041, 
                        0x130FD041, 
                        0x120FD041
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        ShiftLeft (0x01, 0x0C, Local0)
                        If (And (IOST, Local0))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Name (CRS1, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {12}
                    })
                    Name (CRS2, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Range Minimum
                            0x0060,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0064,             // Range Minimum
                            0x0064,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {12}
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        ShiftLeft (0x01, 0x0A, Local0)
                        If (And (IOST, Local0))
                        {
                            Return (CRS1)
                        }
                        Else
                        {
                            Return (CRS2)
                        }
                    }
                }

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

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

                Device (UAR1)
                {
                    Name (_UID, 0x01)
                    Name (_HID, EisaId ("PNP0501"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR02, 0x08, Local0)
                        Store (CR24, Local1)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            If (Local1)
                            {
                                Return (0x0D)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR02, 0xF7, CR02)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        ENFG ()
                        ShiftLeft (CR24, 0x02, IO11)
                        Store (IO11, IO12)
                        ShiftRight (CR28, 0x04, Local0)
                        If (Local0)
                        {
                            ShiftLeft (0x01, Local0, IRQM)
                        }
                        Else
                        {
                            Store (0x00, IRQM)
                        }

                        Store (0x00, DMAM)
                        EXFG ()
                        Return (CRS1)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x02, IO11)
                        CreateWordField (Arg0, 0x09, IRQM)
                        ENFG ()
                        ShiftRight (IO11, 0x02, CR24)
                        If (IRQM)
                        {
                            FindSetRightBit (IRQM, Local0)
                            Subtract (Local0, 0x01, Local0)
                            ShiftLeft (Local0, 0x04, Local0)
                            And (CR28, 0x0F, CR28)
                            Or (CR28, Local0, CR28)
                        }
                        Else
                        {
                            And (CR28, 0x0F, CR28)
                        }

                        Or (CR02, 0x08, CR02)
                        EXFG ()
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        EndDependentFn ()
                    })
                }

                Device (UAR2)
                {
                    Name (_UID, 0x02)
                    Method (_HID, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR0C, 0x18, Local0)
                        Store (CR2B, Local1)
                        EXFG ()
                        If (Local0)
                        {
                            If (Local1)
                            {
                                Return (0x10F0A34D)
                            }
                            Else
                            {
                                Return (0x1005D041)
                            }
                        }
                        Else
                        {
                            Return (0x0105D041)
                        }
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR02, 0x80, Local0)
                        Store (CR25, Local1)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            If (Local1)
                            {
                                Return (0x0D)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR02, 0x7F, CR02)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        ENFG ()
                        ShiftLeft (CR25, 0x02, IO11)
                        Store (IO11, IO12)
                        Store (0x08, LEN1)
                        ShiftLeft (CR25, 0x02, IO21)
                        Store (IO21, IO22)
                        Store (0x08, LEN2)
                        Add (IO21, 0x0400, IO31)
                        Store (IO31, IO32)
                        Store (0x08, LEN3)
                        And (CR28, 0x0F, Local0)
                        If (Local0)
                        {
                            ShiftLeft (0x01, Local0, IRQM)
                            ShiftLeft (0x01, Local0, IRQE)
                        }
                        Else
                        {
                            Store (0x00, IRQM)
                            Store (0x00, IRQE)
                        }

                        And (CR2C, 0x0F, Local0)
                        If (LEqual (Local0, 0x0F))
                        {
                            Store (0x00, DMAM)
                            Store (0x00, DMAE)
                        }
                        Else
                        {
                            ShiftLeft (0x01, Local0, DMAM)
                            ShiftLeft (0x01, Local0, DMAE)
                        }

                        Store (CR2B, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (CRS2)
                        }
                        Else
                        {
                            Return (CRS1)
                        }
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x02, IO11)
                        CreateWordField (Arg0, 0x09, IRQM)
                        CreateWordField (Arg0, 0x02, IO21)
                        CreateWordField (Arg0, 0x0A, IO31)
                        CreateWordField (Arg0, 0x11, IRQF)
                        CreateByteField (Arg0, 0x14, DMAF)
                        ENFG ()
                        Store (CR2B, Local1)
                        If (Local1)
                        {
                            ShiftRight (IO21, 0x02, CR25)
                            If (IO31)
                            {
                                ShiftRight (IO31, 0x03, CR2B)
                            }
                        }
                        Else
                        {
                            ShiftRight (IO11, 0x02, CR25)
                        }

                        If (Local1)
                        {
                            If (IRQF)
                            {
                                FindSetRightBit (IRQF, Local0)
                                Subtract (Local0, 0x01, Local0)
                                And (CR28, 0xF0, CR28)
                                Or (CR28, Local0, CR28)
                            }
                            Else
                            {
                                And (CR28, 0xF0, CR28)
                            }
                        }
                        Else
                        {
                            If (IRQM)
                            {
                                FindSetRightBit (IRQM, Local0)
                                Subtract (Local0, 0x01, Local0)
                                And (CR28, 0xF0, CR28)
                                Or (CR28, Local0, CR28)
                            }
                            Else
                            {
                                And (CR28, 0xF0, CR28)
                            }
                        }

                        If (Local1)
                        {
                            If (DMAF)
                            {
                                FindSetRightBit (DMAF, Local0)
                                Subtract (Local0, 0x01, Local0)
                                And (CR2C, 0xF0, CR2C)
                                Or (CR2C, Local0, CR2C)
                            }
                            Else
                            {
                                Or (CR2C, 0x0F, CR2C)
                            }
                        }

                        Or (CR02, 0x80, CR02)
                        EXFG ()
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (CR2B, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (FPRS)
                        }
                        Else
                        {
                            Return (CPRS)
                        }
                    }

                    Name (CPRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        EndDependentFn ()
                    })
                    Name (FPRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x06F8,             // Range Minimum
                                0x06F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x07F8,             // Range Minimum
                                0x07F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x06F8,             // Range Minimum
                                0x06F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x07E8,             // Range Minimum
                                0x07E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x06E8,             // Range Minimum
                                0x06E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {1,2,3}
                        }
                        EndDependentFn ()
                    })
                }

                Device (LPTE)
                {
                    Method (_HID, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR04, 0x02, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x0104D041)
                        }
                        Else
                        {
                            Return (0x0004D041)
                        }
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR01, 0x04, Local0)
                        Store (CR23, Local1)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            If (Local1)
                            {
                                Return (0x0D)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        If (LNotEqual (\DBGG, 0xE9EFCDAB))
                        {
                            ENFG ()
                            And (CR01, 0xFB, CR01)
                            EXFG ()
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        ENFG ()
                        ShiftLeft (CR23, 0x02, IO11)
                        Store (IO11, IO12)
                        And (CR27, 0x0F, Local0)
                        If (Local0)
                        {
                            ShiftLeft (0x01, Local0, IRQM)
                        }
                        Else
                        {
                            Store (0x00, IRQM)
                        }

                        And (CR26, 0x0F, Local0)
                        ShiftRight (CR26, 0x04, Local0)
                        If (LEqual (Local0, 0x0F))
                        {
                            Store (0x00, DMAM)
                        }
                        Else
                        {
                            ShiftLeft (0x01, Local0, DMAM)
                        }

                        EXFG ()
                        Return (CRS1)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x02, IO11)
                        CreateWordField (Arg0, 0x09, IRQM)
                        ENFG ()
                        ShiftRight (IO11, 0x02, CR23)
                        If (IRQM)
                        {
                            FindSetRightBit (IRQM, Local0)
                            Subtract (Local0, 0x01, Local0)
                            And (CR27, 0xF0, CR27)
                            Or (CR27, Local0, CR27)
                        }
                        Else
                        {
                            And (CR27, 0xF0, CR27)
                        }

                        If (DMAM)
                        {
                            FindSetRightBit (DMAM, Local0)
                            Subtract (Local0, 0x01, Local0)
                            And (CR26, 0xF0, CR26)
                            Or (CR26, Local0, CR26)
                        }
                        Else
                        {
                            Or (CR26, 0x0F, CR26)
                        }

                        Or (CR01, 0x04, CR01)
                        EXFG ()
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        ENFG ()
                        And (CR04, 0x02, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (EPPR)
                        }
                        Else
                        {
                            Return (LPPR)
                        }
                    }

                    Name (LPPR, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        EndDependentFn ()
                    })
                    Name (EPPR, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0678,             // Range Minimum
                                0x0678,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IO (Decode16,
                                0x07BC,             // Range Minimum
                                0x07BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0678,             // Range Minimum
                                0x0678,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IO (Decode16,
                                0x07BC,             // Range Minimum
                                0x07BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        EndDependentFn ()
                    })
                }

                Device (SIOR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Method (_UID, 0, NotSerialized)
                    {
                        Return (SPIO)
                    }

                    Name (CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y00)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y01)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        If (LAnd (LNotEqual (SPIO, 0x03F0), LGreater (SPIO, 0xF0)))
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._MIN, GP10)
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._MAX, GP11)
                            CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._LEN, GPL1)
                            Store (SPIO, GP10)
                            Store (SPIO, GP11)
                            Store (0x02, GPL1)
                        }

                        If (IO1B)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y01._MIN, GP20)
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y01._MAX, GP21)
                            CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y01._LEN, GPL2)
                            Store (IO1B, GP20)
                            Store (IO1B, GP21)
                            Store (IO1L, GPL2)
                        }

                        Return (CRS)
                    }
                }

                Mutex (MUT0, 0x00)
                Method (ENFG, 0, NotSerialized)
                {
                    Acquire (MUT0, 0x0FFFF)
                    Store (0x55, INDX)
                }

                Method (EXFG, 0, NotSerialized)
                {
                    Store (0xAA, INDX)
                    Release (MUT0)
                }

                Method (SIOS, 1, NotSerialized)
                {
                    Store ("SIOS", Debug)
                }

                Method (SIOW, 1, NotSerialized)
                {
                    Store ("SIOW", Debug)
                }

                Method (SIOH, 0, NotSerialized)
                {
                    Store ("SIOH", Debug)
                }

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

                IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                {
                    CR00,   8, 
                    CR01,   8, 
                    CR02,   8, 
                    CR03,   8, 
                    CR04,   8, 
                    CR05,   8, 
                    CR06,   8, 
                    CR07,   8, 
                    CR08,   8, 
                    CR09,   8, 
                    CR0A,   8, 
                    CR0B,   8, 
                    CR0C,   8, 
                    CR0D,   8, 
                    CR0E,   8, 
                    CR0F,   8, 
                    CR10,   8, 
                    CR11,   8, 
                    CR12,   8, 
                    CR13,   8, 
                    CR14,   8, 
                    CR15,   8, 
                    CR16,   8, 
                    CR17,   8, 
                    CR18,   8, 
                    CR19,   8, 
                    CR1A,   8, 
                    CR1B,   8, 
                    CR1C,   8, 
                    CR1D,   8, 
                    CR1E,   8, 
                    CR1F,   8, 
                    CR20,   8, 
                    CR21,   8, 
                    CR22,   8, 
                    CR23,   8, 
                    CR24,   8, 
                    CR25,   8, 
                    CR26,   8, 
                    CR27,   8, 
                    CR28,   8, 
                    CR29,   8, 
                    CR2A,   8, 
                    CR2B,   8, 
                    CR2C,   8, 
                    CR2D,   8, 
                    CR2E,   8, 
                    CR2F,   8, 
                    CR30,   8, 
                    CR31,   8, 
                    CR32,   8, 
                    CR33,   8, 
                    CR34,   8, 
                    CR35,   8, 
                    CR36,   8, 
                    CR37,   8, 
                    CR38,   8, 
                    CR39,   8
                }

                Name (CRS1, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y02)
                    IRQNoFlags (_Y03)
                        {}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y04)
                        {}
                })
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y02._MIN, IO11)
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y02._MAX, IO12)
                CreateByteField (CRS1, \_SB.PCI0.SBRG._Y02._LEN, LEN1)
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y03._INT, IRQM)
                CreateByteField (CRS1, \_SB.PCI0.SBRG._Y04._DMA, DMAM)
                Name (CRS2, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y05)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y06)
                    IRQNoFlags (_Y07)
                        {6}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y08)
                        {2}
                })
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y05._MIN, IO21)
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y05._MAX, IO22)
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y05._LEN, LEN2)
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y06._MIN, IO31)
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y06._MAX, IO32)
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y06._LEN, LEN3)
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y07._INT, IRQE)
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y08._DMA, DMAE)
                Device (RMSC)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x10)
                    Name (CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0010,             // Range Minimum
                            0x0010,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0022,             // Range Minimum
                            0x0022,             // Range Maximum
                            0x00,               // Alignment
                            0x1E,               // Length
                            )
                        IO (Decode16,
                            0x0044,             // Range Minimum
                            0x0044,             // Range Maximum
                            0x00,               // Alignment
                            0x1C,               // Length
                            )
                        IO (Decode16,
                            0x0062,             // Range Minimum
                            0x0062,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0065,             // Range Minimum
                            0x0065,             // Range Maximum
                            0x00,               // Alignment
                            0x0B,               // Length
                            )
                        IO (Decode16,
                            0x0072,             // Range Minimum
                            0x0072,             // Range Maximum
                            0x00,               // Alignment
                            0x0E,               // Length
                            )
                        IO (Decode16,
                            0x0080,             // Range Minimum
                            0x0080,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0084,             // Range Minimum
                            0x0084,             // Range Maximum
                            0x00,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0088,             // Range Minimum
                            0x0088,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x008C,             // Range Minimum
                            0x008C,             // Range Maximum
                            0x00,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0090,             // Range Minimum
                            0x0090,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x00A2,             // Range Minimum
                            0x00A2,             // Range Maximum
                            0x00,               // Alignment
                            0x1E,               // Length
                            )
                        IO (Decode16,
                            0x00E0,             // Range Minimum
                            0x00E0,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0480,             // Range Minimum
                            0x0480,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x04D0,             // Range Minimum
                            0x04D0,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y09)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y0A)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y0B)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y0C)
                        Memory32Fixed (ReadOnly,
                            0xFFF80000,         // Address Base
                            0x00080000,         // Address Length
                            )
                        Memory32 (ReadOnly,
                            0xFFE80000,         // Range Minimum
                            0xFFE80000,         // Range Maximum
                            0x00000000,         // Alignment
                            0x00080000,         // Length
                            )
                        Memory32 (ReadOnly,
                            0xFFB80000,         // Range Minimum
                            0xFFB80000,         // Range Maximum
                            0x00000000,         // Alignment
                            0x00080000,         // Length
                            )
                        Memory32 (ReadOnly,
                            0xFED00000,         // Range Minimum
                            0xFED00000,         // Range Maximum
                            0x00000000,         // Alignment
                            0x00000400,         // Length
                            )
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._MIN, GP00)
                        CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._MAX, GP01)
                        CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._LEN, GP0L)
                        Store (PMBS, GP00)
                        Store (PMBS, GP01)
                        Store (PMLN, GP0L)
                        If (LNotEqual (SMBS, 0x08E0))
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._MIN, GP30)
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._MAX, GP31)
                            CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._LEN, GP3L)
                            Add (0x80, PMBS, Local0)
                            Store (Local0, GP30)
                            Store (Local0, GP31)
                            Store (0x80, GP3L)
                        }

                        If (SMBS)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._MIN, GP10)
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._MAX, GP11)
                            CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._LEN, GP1L)
                            Store (SMBS, GP10)
                            Store (SMBS, GP11)
                            Store (SMBL, GP1L)
                        }

                        If (GPBS)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0C._MIN, GP20)
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0C._MAX, GP21)
                            CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y0C._LEN, GP2L)
                            Store (GPBS, GP20)
                            Store (GPBS, GP21)
                            Store (GPLN, GP2L)
                        }

                        Return (CRS)
                    }
                }

                Scope (\_SB)
                {
                    Scope (PCI0)
                    {
                        Name (_PRW, Package (0x02)
                        {
                            0x0B, 
                            0x04
                        })
                        Method (_S3D, 0, NotSerialized)
                        {
                            If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))
                            {
                                Return (0x02)
                            }
                            Else
                            {
                                Return (0x03)
                            }
                        }

                        Scope (SBRG)
                        {
                            Scope (PS2K)
                            {
                                Method (_PRW, 0, NotSerialized)
                                {
                                    Return (GPRW (0x0F, 0x04))
                                }
                            }

                            Scope (PS2M)
                            {
                                Method (_PRW, 0, NotSerialized)
                                {
                                    Return (GPRW (0x0D, 0x04))
                                }
                            }

                            Scope (UAR1)
                            {
                                Method (_PRW, 0, NotSerialized)
                                {
                                    Return (GPRW (0x08, 0x04))
                                }
                            }

                            Scope (UAR2)
                            {
                                Method (_PRW, 0, NotSerialized)
                                {
                                    Return (GPRW (0x08, 0x04))
                                }
                            }

                            Scope (\_GPE)
                            {
                                Method (_L0F, 0, NotSerialized)
                                {
                                    Notify (\_SB.PCI0.SBRG.PS2K, 0x02)
                                }

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

                                Method (_L08, 0, NotSerialized)
                                {
                                    Notify (\_SB.PCI0.SBRG.UAR1, 0x02)
                                    Notify (\_SB.PCI0.SBRG.UAR2, 0x02)
                                }
                            }
                        }
                    }
                }

                Device (\_SB.PCI0.PCIE)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x11)
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0xE0000000,         // Address Base
                            0x10000000,         // Address Length
                            _Y0D)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateDWordField (CRS, \_SB.PCI0.PCIE._Y0D._BAS, BAS1)
                        CreateDWordField (CRS, \_SB.PCI0.PCIE._Y0D._LEN, LEN1)
                        Store (\PCIB, BAS1)
                        Store (\PCIL, LEN1)
                        Return (CRS)
                    }
                }

                Scope (\_PR)
                {
                    Processor (CPU1, 0x01, 0x00000810, 0x06)
                    {
                        Name (_PCT, Package (0x02)
                        {
                            ResourceTemplate ()
                            {
                                Register (FFixedHW, 
                                    0x00,               // Bit Width
                                    0x00,               // Bit Offset
                                    0x0000000000000000, // Address
                                    ,)
                            }, 

                            ResourceTemplate ()
                            {
                                Register (FFixedHW, 
                                    0x00,               // Bit Width
                                    0x00,               // Bit Offset
                                    0x0000000000000000, // Address
                                    ,)
                            }
                        })
                        Name (_PSS, Package (0x25)
                        {
                            Package (0x06)
                            {
                                0x000007D0, 
                                0x000088B8, 
                                0x00000064, 
                                0x00000007, 
                                0xE020290C, 
                                0x0000010C
                            }, 

                            Package (0x06)
                            {
                                0x00000708, 
                                0x00007210, 
                                0x00000064, 
                                0x00000007, 
                                0xE020298A, 
                                0x0000018A
                            }, 

                            Package (0x06)
                            {
                                0x00000640, 
                                0x00005E88, 
                                0x00000064, 
                                0x00000007, 
                                0xE0202A08, 
                                0x00000208
                            }, 

                            Package (0x06)
                            {
                                0x00000320, 
                                0x00001EDC, 
                                0x00000064, 
                                0x00000007, 
                                0xE0202D80, 
                                0x00000580
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            }, 

                            Package (0x06)
                            {
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000, 
                                0x00000000
                            } 
                        })
                        Method (_PPC, 0, NotSerialized)
                        {
                            Return (0x00)
                        }
                    }
                }

                Device (OMSC)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x00)
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y0E)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y0F)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        If (APIC)
                        {
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0E._LEN, ML01)
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0E._BAS, MB01)
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0F._LEN, ML02)
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0F._BAS, MB02)
                            Store (0xFEC00000, MB01)
                            Store (0x1000, ML01)
                            Store (0xFEE00000, MB02)
                            Store (0x1000, ML02)
                        }

                        Return (CRS)
                    }
                }

                Device (\_SB.RMEM)
                {
                    Name (_HID, EisaId ("PNP0C01"))
                    Name (_UID, 0x01)
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0x00000000,         // Address Base
                            0x000A0000,         // Address Length
                            )
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y10)
                        Memory32Fixed (ReadOnly,
                            0x000E0000,         // Address Base
                            0x00020000,         // Address Length
                            _Y11)
                        Memory32Fixed (ReadWrite,
                            0x00100000,         // Address Base
                            0x00000000,         // Address Length
                            _Y12)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y13)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateDWordField (CRS, \_SB.RMEM._Y10._BAS, BAS1)
                        CreateDWordField (CRS, \_SB.RMEM._Y10._LEN, LEN1)
                        CreateDWordField (CRS, \_SB.RMEM._Y11._BAS, BAS2)
                        CreateDWordField (CRS, \_SB.RMEM._Y11._LEN, LEN2)
                        CreateDWordField (CRS, \_SB.RMEM._Y12._LEN, LEN3)
                        CreateDWordField (CRS, \_SB.RMEM._Y13._BAS, BAS4)
                        CreateDWordField (CRS, \_SB.RMEM._Y13._LEN, LEN4)
                        If (OSFL ()) {}
                        Else
                        {
                            If (MG1B)
                            {
                                If (LGreater (MG1B, 0x000C0000))
                                {
                                    Store (0x000C0000, BAS1)
                                    Subtract (MG1B, BAS1, LEN1)
                                }
                            }
                            Else
                            {
                                Store (0x000C0000, BAS1)
                                Store (0x00020000, LEN1)
                            }

                            If (Add (MG1B, MG1L, Local0))
                            {
                                Store (Local0, BAS2)
                                Subtract (0x00100000, BAS2, LEN2)
                            }
                        }

                        Subtract (MG2B, 0x00100000, LEN3)
                        Add (MG2B, MG2L, BAS4)
                        Subtract (0x00, BAS4, LEN4)
                        Return (CRS)
                    }
                }
            }

            Device (IDEC)
            {
                Name (_ADR, 0x00020005)
                Name (IO5T, Package (0x03)
                {
                    Package (0x07)
                    {
                        0x78, 
                        0xB4, 
                        0x014A, 
                        0x0186, 
                        0x0258, 
                        0x78, 
                        0x96
                    }, 

                    Package (0x07)
                    {
                        0x06, 
                        0x07, 
                        0x1C, 
                        0x1C, 
                        0x1C, 
                        0x06, 
                        0x07
                    }, 

                    Package (0x07)
                    {
                        0x04, 
                        0x09, 
                        0x03, 
                        0x09, 
                        0x1E, 
                        0x04, 
                        0x06
                    }
                })
                Name (IO6T, Package (0x03)
                {
                    Package (0x07)
                    {
                        0x78, 
                        0xB4, 
                        0x014A, 
                        0x0186, 
                        0x0258, 
                        0x78, 
                        0xB4
                    }, 

                    Package (0x07)
                    {
                        0x09, 
                        0x0A, 
                        0x26, 
                        0x26, 
                        0x26, 
                        0x09, 
                        0x0A
                    }, 

                    Package (0x07)
                    {
                        0x05, 
                        0x0C, 
                        0x04, 
                        0x0C, 
                        0x28, 
                        0x05, 
                        0x0C
                    }
                })
                Name (UM5T, Package (0x06)
                {
                    0x0B, 
                    0x07, 
                    0x05, 
                    0x04, 
                    0x02, 
                    0x01
                })
                Name (UM6T, Package (0x07)
                {
                    0x0F, 
                    0x0A, 
                    0x07, 
                    0x05, 
                    0x03, 
                    0x02, 
                    0x01
                })
                Name (PIO5, Package (0x05)
                {
                    0x3A, 
                    0x25, 
                    0x1F, 
                    0x10, 
                    0x0A
                })
                Name (PIO6, Package (0x05)
                {
                    0x4E, 
                    0x32, 
                    0x2A, 
                    0x16, 
                    0x0E
                })
                Name (CRCT, Package (0x07)
                {
                    0x06, 
                    0x04, 
                    0x03, 
                    0x01, 
                    0x01, 
                    0x01, 
                    0x01
                })
                Name (INTT, Package (0x05)
                {
                    0x02, 
                    0x02, 
                    0x02, 
                    0x04, 
                    0x06
                })
                Name (DMAT, Package (0x05)
                {
                    0x00, 
                    0x01, 
                    0x01, 
                    0x01, 
                    0x02
                })
                Name (RMFL, 0x01)
                OperationRegion (CF40, PCI_Config, 0x40, 0x18)
                Field (CF40, WordAcc, NoLock, Preserve)
                {
                        ,   1, 
                    IOR0,   1, 
                    UDM0,   1, 
                    UM60,   1, 
                    UCT0,   4, 
                    CRC0,   4, 
                    INI0,   4, 
                    ATT0,   6, 
                            Offset (0x03), 
                    RCT0,   6, 
                            Offset (0x04), 
                        ,   1, 
                    IOR1,   1, 
                    UDM1,   1, 
                    UM61,   1, 
                    UCT1,   4, 
                    CRC1,   4, 
                    INI1,   4, 
                    ATT1,   6, 
                            Offset (0x07), 
                    RCT1,   6, 
                            Offset (0x08), 
                        ,   1, 
                    IOR2,   1, 
                    UDM2,   1, 
                    UM62,   1, 
                    UCT2,   4, 
                    CRC2,   4, 
                    INI2,   4, 
                    ATT2,   6, 
                            Offset (0x0B), 
                    RCT2,   6, 
                            Offset (0x0C), 
                        ,   1, 
                    IOR3,   1, 
                    UDM3,   1, 
                    UM63,   1, 
                    UCT3,   4, 
                    CRC3,   4, 
                    INI3,   4, 
                    ATT3,   6, 
                            Offset (0x0F), 
                    RCT3,   6, 
                            Offset (0x10), 
                        ,   1, 
                    CHE0,   1, 
                            Offset (0x12), 
                        ,   1, 
                    CHE1,   1, 
                            Offset (0x14), 
                        ,   30, 
                    REMP,   1, 
                            Offset (0x18)
                }

                Name (IDEP, Buffer (0x14) {})
                CreateDWordField (IDEP, 0x00, GTM0)
                CreateDWordField (IDEP, 0x04, GTM1)
                CreateDWordField (IDEP, 0x08, GTM2)
                CreateDWordField (IDEP, 0x0C, GTM3)
                CreateDWordField (IDEP, 0x10, GTM4)
                Device (IDE0)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Store (0xFFFFFFFF, Local0)
                        Store (0xFFFFFFFF, Local1)
                        Store (0xFFFFFFFF, Local2)
                        Store (0xFFFFFFFF, Local3)
                        Store (0x10, Local4)
                        Store (REMP, RMFL)
                        Store (0x00, REMP)
                        If (CHE0)
                        {
                            If (LNotEqual (ATT0, 0x00))
                            {
                                Add (RCT0, 0x01, Local5)
                                Add (ATT0, 0x01, Local6)
                                Add (Local5, Local6, Local5)
                                Multiply (UM60, 0x05, Local6)
                                Subtract (0x14, Local6, Local7)
                                Multiply (Local5, Local7, Local0)
                                ShiftRight (Local0, 0x01, Local0)
                                If (LLessEqual (Local0, 0xB4))
                                {
                                    Store (Local0, Local1)
                                }

                                If (IOR0)
                                {
                                    Or (Local4, 0x02, Local4)
                                }

                                If (UDM0)
                                {
                                    Add (UCT0, 0x01, Local5)
                                    Multiply (Local5, Local7, Local6)
                                    ShiftRight (Local6, 0x01, Local1)
                                    Or (Local4, 0x01, Local4)
                                }
                            }

                            If (LNotEqual (ATT1, 0x00))
                            {
                                Add (RCT1, 0x01, Local5)
                                Add (ATT1, 0x01, Local6)
                                Add (Local5, Local6, Local5)
                                Multiply (UM61, 0x05, Local6)
                                Subtract (0x14, Local6, Local7)
                                Multiply (Local5, Local7, Local2)
                                ShiftRight (Local2, 0x01, Local2)
                                If (LLessEqual (Local2, 0xB4))
                                {
                                    Store (Local2, Local3)
                                }

                                If (IOR1)
                                {
                                    Or (Local4, 0x08, Local4)
                                }

                                If (UDM1)
                                {
                                    Add (UCT1, 0x01, Local5)
                                    Multiply (Local5, Local7, Local6)
                                    ShiftRight (Local6, 0x01, Local3)
                                    Or (Local4, 0x04, Local4)
                                }
                            }
                        }

                        Store (RMFL, REMP)
                        Store (Local0, GTM0)
                        Store (Local1, GTM1)
                        Store (Local2, GTM2)
                        Store (Local3, GTM3)
                        Store (Local4, GTM4)
                        Return (IDEP)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, IDEP)
                        Store (GTM0, Local0)
                        Store (GTM1, Local1)
                        Store (GTM2, Local2)
                        Store (GTM3, Local3)
                        Store (GTM4, Local4)
                        Store (REMP, RMFL)
                        Store (0x00, REMP)
                        If (LAnd (LNotEqual (Local1, 0xFFFFFFFF), LNotEqual (Local1, 0x00)))
                        {
                            If (And (Local4, 0x01))
                            {
                                Store (0x01, UDM0)
                                If (LLess (Local1, 0x14))
                                {
                                    Store (0x01, UM60)
                                    Store (0x01, UCT0)
                                }
                                Else
                                {
                                    Store (0x00, UM60)
                                    Divide (Local1, 0x0A, Local6, Local5)
                                    Decrement (Local5)
                                    Store (Local5, UCT0)
                                    Store (Match (UM5T, MEQ, Local5, MTR, 0x00, 0x00), Local5)
                                    Store (DerefOf (Index (CRCT, Local5)), CRC0)
                                }
                            }
                        }

                        If (LAnd (LNotEqual (Local0, 0xFFFFFFFF), LNotEqual (Local0, 0x00)))
                        {
                            If (UM60)
                            {
                                Store (Match (DerefOf (Index (IO6T, 0x00)), MEQ, Local0, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x01)), Local6)), 
                                    ATT0)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x02)), Local6)), 
                                    RCT0)
                            }
                            Else
                            {
                                Store (Match (DerefOf (Index (IO5T, 0x00)), MEQ, Local0, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x01)), Local6)), 
                                    ATT0)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x02)), Local6)), 
                                    RCT0)
                                Store (DerefOf (Index (INTT, Local6)), INI0)
                            }
                        }

                        If (LAnd (LNotEqual (Local3, 0xFFFFFFFF), LNotEqual (Local3, 0x00)))
                        {
                            If (And (Local4, 0x04))
                            {
                                Store (0x01, UDM1)
                                If (LLess (Local3, 0x14))
                                {
                                    Store (0x01, UM61)
                                    Store (0x01, UCT1)
                                }
                                Else
                                {
                                    Store (0x00, UM61)
                                    Divide (Local3, 0x0A, Local6, Local5)
                                    Decrement (Local5)
                                    Store (Local5, UCT1)
                                    Store (Match (UM5T, MEQ, Local5, MTR, 0x00, 0x00), Local5)
                                    Store (DerefOf (Index (CRCT, Local5)), CRC1)
                                }
                            }
                        }

                        If (LAnd (LNotEqual (Local2, 0xFFFFFFFF), LNotEqual (Local2, 0x00)))
                        {
                            If (UM61)
                            {
                                Store (Match (DerefOf (Index (IO6T, 0x00)), MEQ, Local2, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x01)), Local6)), 
                                    ATT1)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x02)), Local6)), 
                                    RCT1)
                            }
                            Else
                            {
                                Store (Match (DerefOf (Index (IO5T, 0x00)), MEQ, Local2, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x01)), Local6)), 
                                    ATT1)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x02)), Local6)), 
                                    RCT1)
                                Store (DerefOf (Index (INTT, Local6)), INI1)
                            }
                        }

                        Store (RMFL, REMP)
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local6)
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local7)
                            CreateByteField (Local6, 0x01, MODE)
                            CreateByteField (Local7, 0x01, UMOD)
                            Store (REMP, RMFL)
                            Store (0x00, REMP)
                            If (LNotEqual (ATT0, 0x00))
                            {
                                Add (ATT0, RCT0, Local5)
                                If (UM60)
                                {
                                    Store (Match (PIO6, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }
                                Else
                                {
                                    Store (Match (PIO5, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }

                                If (UDM0)
                                {
                                    If (UM60)
                                    {
                                        Store (Match (UM6T, MEQ, UCT0, MTR, 0x00, 0x00), UMOD)
                                    }
                                    Else
                                    {
                                        Store (Match (UM5T, MEQ, UCT0, MTR, 0x00, 0x00), UMOD)
                                    }

                                    Or (UMOD, 0x40, UMOD)
                                }
                                Else
                                {
                                    Store (DerefOf (Index (DMAT, MODE)), UMOD)
                                    Or (UMOD, 0x20, UMOD)
                                }

                                Or (MODE, 0x08, MODE)
                            }

                            Store (RMFL, REMP)
                            Concatenate (Local6, Local7, Local5)
                            Return (Local5)
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                }, Local6)
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                }, Local7)
                            CreateByteField (Local6, 0x01, MODE)
                            CreateByteField (Local7, 0x01, UMOD)
                            Store (REMP, RMFL)
                            Store (0x00, REMP)
                            If (LNotEqual (ATT1, 0x00))
                            {
                                Add (ATT1, RCT1, Local5)
                                If (UM61)
                                {
                                    Store (Match (PIO6, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }
                                Else
                                {
                                    Store (Match (PIO5, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }

                                If (UDM1)
                                {
                                    If (UM61)
                                    {
                                        Store (Match (UM6T, MEQ, UCT1, MTR, 0x00, 0x00), UMOD)
                                    }
                                    Else
                                    {
                                        Store (Match (UM5T, MEQ, UCT1, MTR, 0x00, 0x00), UMOD)
                                    }

                                    Or (UMOD, 0x40, UMOD)
                                }
                                Else
                                {
                                    Store (DerefOf (Index (DMAT, MODE)), UMOD)
                                    Or (UMOD, 0x20, UMOD)
                                }

                                Or (MODE, 0x08, MODE)
                            }

                            Store (RMFL, REMP)
                            Concatenate (Local6, Local7, Local5)
                            Return (Local5)
                        }
                    }
                }

                Device (IDE1)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Store (0xFFFFFFFF, Local0)
                        Store (0xFFFFFFFF, Local1)
                        Store (0xFFFFFFFF, Local2)
                        Store (0xFFFFFFFF, Local3)
                        Store (0x10, Local4)
                        Store (REMP, RMFL)
                        Store (0x00, REMP)
                        If (CHE1)
                        {
                            If (LNotEqual (ATT2, 0x00))
                            {
                                Add (RCT2, 0x01, Local5)
                                Add (ATT2, 0x01, Local6)
                                Add (Local5, Local6, Local5)
                                Multiply (UM62, 0x05, Local6)
                                Subtract (0x14, Local6, Local7)
                                Multiply (Local5, Local7, Local0)
                                ShiftRight (Local0, 0x01, Local0)
                                If (LLessEqual (Local0, 0xB4))
                                {
                                    Store (Local0, Local1)
                                }

                                If (IOR2)
                                {
                                    Or (Local4, 0x02, Local4)
                                }

                                If (UDM2)
                                {
                                    Add (UCT2, 0x01, Local5)
                                    Multiply (Local5, Local7, Local6)
                                    ShiftRight (Local6, 0x01, Local1)
                                    Or (Local4, 0x01, Local4)
                                }
                            }

                            If (LNotEqual (ATT3, 0x00))
                            {
                                Add (RCT3, 0x01, Local5)
                                Add (ATT3, 0x01, Local6)
                                Add (Local5, Local6, Local5)
                                Multiply (UM63, 0x05, Local6)
                                Subtract (0x14, Local6, Local7)
                                Multiply (Local5, Local7, Local2)
                                ShiftRight (Local2, 0x01, Local2)
                                If (LLessEqual (Local2, 0xB4))
                                {
                                    Store (Local2, Local3)
                                }

                                If (IOR3)
                                {
                                    Or (Local4, 0x08, Local4)
                                }

                                If (UDM3)
                                {
                                    Add (UCT3, 0x01, Local5)
                                    Multiply (Local5, Local7, Local6)
                                    ShiftRight (Local6, 0x01, Local3)
                                    Or (Local4, 0x04, Local4)
                                }
                            }
                        }

                        Store (RMFL, REMP)
                        Store (Local0, GTM0)
                        Store (Local1, GTM1)
                        Store (Local2, GTM2)
                        Store (Local3, GTM3)
                        Store (Local4, GTM4)
                        Return (IDEP)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, IDEP)
                        Store (GTM0, Local0)
                        Store (GTM1, Local1)
                        Store (GTM2, Local2)
                        Store (GTM3, Local3)
                        Store (GTM4, Local4)
                        Store (REMP, RMFL)
                        Store (0x00, REMP)
                        If (LAnd (LNotEqual (Local1, 0xFFFFFFFF), LNotEqual (Local1, 0x00)))
                        {
                            If (And (Local4, 0x01))
                            {
                                Store (0x01, UDM2)
                                If (LLess (Local1, 0x14))
                                {
                                    Store (0x01, UM62)
                                    Store (0x01, UCT2)
                                }
                                Else
                                {
                                    Store (0x00, UM62)
                                    Divide (Local1, 0x0A, Local6, Local5)
                                    Decrement (Local5)
                                    Store (Local5, UCT2)
                                    Store (Match (UM5T, MEQ, Local5, MTR, 0x00, 0x00), Local5)
                                    Store (DerefOf (Index (CRCT, Local5)), CRC2)
                                }
                            }
                        }

                        If (LAnd (LNotEqual (Local0, 0xFFFFFFFF), LNotEqual (Local0, 0x00)))
                        {
                            If (UM62)
                            {
                                Store (Match (DerefOf (Index (IO6T, 0x00)), MEQ, Local0, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x01)), Local6)), 
                                    ATT2)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x02)), Local6)), 
                                    RCT2)
                            }
                            Else
                            {
                                Store (Match (DerefOf (Index (IO5T, 0x00)), MEQ, Local0, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x01)), Local6)), 
                                    ATT2)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x02)), Local6)), 
                                    RCT2)
                                Store (DerefOf (Index (INTT, Local6)), INI2)
                            }
                        }

                        If (LAnd (LNotEqual (Local3, 0xFFFFFFFF), LNotEqual (Local3, 0x00)))
                        {
                            If (And (Local4, 0x04))
                            {
                                Store (0x01, UDM3)
                                If (LLess (Local3, 0x14))
                                {
                                    Store (0x01, UM63)
                                    Store (0x01, UCT3)
                                }
                                Else
                                {
                                    Store (0x00, UM63)
                                    Divide (Local3, 0x0A, Local6, Local5)
                                    Decrement (Local5)
                                    Store (Local5, UCT3)
                                    Store (Match (UM5T, MEQ, Local5, MTR, 0x00, 0x00), Local5)
                                    Store (DerefOf (Index (CRCT, Local5)), CRC3)
                                }
                            }
                        }

                        If (LAnd (LNotEqual (Local2, 0xFFFFFFFF), LNotEqual (Local2, 0x00)))
                        {
                            If (UM63)
                            {
                                Store (Match (DerefOf (Index (IO6T, 0x00)), MEQ, Local2, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x01)), Local6)), 
                                    ATT3)
                                Store (DerefOf (Index (DerefOf (Index (IO6T, 0x02)), Local6)), 
                                    RCT3)
                            }
                            Else
                            {
                                Store (Match (DerefOf (Index (IO5T, 0x00)), MEQ, Local2, MTR, 
                                    0x00, 0x00), Local6)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x01)), Local6)), 
                                    ATT3)
                                Store (DerefOf (Index (DerefOf (Index (IO5T, 0x02)), Local6)), 
                                    RCT3)
                                Store (DerefOf (Index (INTT, Local6)), INI3)
                            }
                        }

                        Store (RMFL, REMP)
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local6)
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local7)
                            CreateByteField (Local6, 0x01, MODE)
                            CreateByteField (Local7, 0x01, UMOD)
                            Store (REMP, RMFL)
                            Store (0x00, REMP)
                            If (LNotEqual (ATT2, 0x00))
                            {
                                Add (ATT2, RCT2, Local5)
                                If (UM62)
                                {
                                    Store (Match (PIO6, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }
                                Else
                                {
                                    Store (Match (PIO5, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }

                                If (UDM2)
                                {
                                    If (UM62)
                                    {
                                        Store (Match (UM6T, MEQ, UCT2, MTR, 0x00, 0x00), UMOD)
                                    }
                                    Else
                                    {
                                        Store (Match (UM5T, MEQ, UCT2, MTR, 0x00, 0x00), UMOD)
                                    }

                                    Or (UMOD, 0x40, UMOD)
                                }
                                Else
                                {
                                    Store (DerefOf (Index (DMAT, MODE)), UMOD)
                                    Or (UMOD, 0x20, UMOD)
                                }

                                Or (MODE, 0x08, MODE)
                            }

                            Store (RMFL, REMP)
                            Concatenate (Local6, Local7, Local5)
                            Return (Local5)
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                }, Local6)
                            Store (Buffer (0x07)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                }, Local7)
                            CreateByteField (Local6, 0x01, MODE)
                            CreateByteField (Local7, 0x01, UMOD)
                            Store (REMP, RMFL)
                            Store (0x00, REMP)
                            If (LNotEqual (ATT3, 0x00))
                            {
                                Add (ATT3, RCT3, Local5)
                                If (UM63)
                                {
                                    Store (Match (PIO6, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }
                                Else
                                {
                                    Store (Match (PIO5, MEQ, Local5, MTR, 0x00, 0x00), MODE)
                                }

                                If (UDM3)
                                {
                                    If (UM63)
                                    {
                                        Store (Match (UM6T, MEQ, UCT3, MTR, 0x00, 0x00), UMOD)
                                    }
                                    Else
                                    {
                                        Store (Match (UM5T, MEQ, UCT3, MTR, 0x00, 0x00), UMOD)
                                    }

                                    Or (UMOD, 0x40, UMOD)
                                }
                                Else
                                {
                                    Store (DerefOf (Index (DMAT, MODE)), UMOD)
                                    Or (UMOD, 0x20, UMOD)
                                }

                                Or (MODE, 0x08, MODE)
                            }

                            Store (RMFL, REMP)
                            Concatenate (Local6, Local7, Local5)
                            Return (Local5)
                        }
                    }
                }
            }

            Device (AC97)
            {
                Name (_ADR, 0x00020007)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0A, 0x04))
                }
            }

            Device (MC97)
            {
                Name (_ADR, 0x00020006)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x05, 0x04))
                }
            }

            Device (MAC)
            {
                Name (_ADR, 0x000B0000)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0B, 0x04))
                }
            }

            Device (CBS0)
            {
                Name (_ADR, 0x000A0000)
                OperationRegion (CBSP, PCI_Config, 0x00, 0xF0)
                Field (CBSP, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x04), 
                    CB04,   8, 
                            Offset (0x14), 
                    CB14,   8, 
                            Offset (0x3C), 
                    CB3C,   8, 
                            Offset (0x3E), 
                    CB3E,   8, 
                            Offset (0x44), 
                    CB44,   32, 
                            Offset (0xE0), 
                    PME0,   8, 
                    PME1,   8
                }

                Method (_INI, 0, NotSerialized)
                {
                    Store (Zero, CB44)
                }

                Method (CBSW, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Zero, CB44)
                    }
                }

                Method (CBSR, 0, NotSerialized)
                {
                    And (PME1, 0x80, Local1)
                    If (Local1)
                    {
                        And (PME0, 0xFC, PME0)
                        Store (PME1, Local2)
                        Store (Local2, PME1)
                    }

                    Return (Local1)
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0B, 0x03))
                }
            }

            Device (P394)
            {
                Name (_ADR, 0x000A0001)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0B, 0x03))
                }
            }

            Device (MPCI)
            {
                Name (_ADR, 0x00090000)
                OperationRegion (MINP, PCI_Config, 0x00, 0x68)
                Field (MINP, ByteAcc, NoLock, Preserve)
                {
                    VNUM,   32, 
                            Offset (0x09), 
                    PINF,   8, 
                    SBCC,   8, 
                    BSCC,   8, 
                            Offset (0x2C), 
                    SNUM,   32, 
                            Offset (0x34)
                }

                Method (MPDP, 0, NotSerialized)
                {
                    If (LEqual (SNUM, 0xFFFFFFFF))
                    {
                        Return (0x00)
                    }

                    If (LNotEqual (BSCC, 0x02))
                    {
                        Return (0x00)
                    }

                    Return (One)
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0B, 0x03))
                }
            }

            Device (EUSB)
            {
                Name (_ADR, 0x00030003)
                OperationRegion (USBW, PCI_Config, 0x00, 0xF0)
                Field (USBW, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x44), 
                    UB44,   8
                }

                Method (USB1, 0, NotSerialized)
                {
                    And (UB44, 0x00, UB44)
                    Or (UB44, 0x54, UB44)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x06, 0x03))
                }
            }

            Device (USB)
            {
                Name (_ADR, 0x00030000)
                OperationRegion (USBW, PCI_Config, 0x00, 0xF0)
                Field (USBW, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x44), 
                    UB44,   8
                }

                Method (USB1, 0, NotSerialized)
                {
                    And (UB44, 0x00, UB44)
                    Or (UB44, 0x54, UB44)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0E, 0x03))
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x00030001)
                OperationRegion (USBW, PCI_Config, 0x00, 0xF0)
                Field (USBW, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x44), 
                    UB44,   8
                }

                Method (USB1, 0, NotSerialized)
                {
                    And (UB44, 0x00, UB44)
                    Or (UB44, 0x54, UB44)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x04, 0x03))
                }
            }

            Device (USB3)
            {
                Name (_ADR, 0x00030002)
                OperationRegion (USBW, PCI_Config, 0x00, 0xF0)
                Field (USBW, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x44), 
                    UB44,   8
                }

                Method (USB1, 0, NotSerialized)
                {
                    And (UB44, 0x00, UB44)
                    Or (UB44, 0x54, UB44)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x07, 0x03))
                }
            }
        }

        Scope (\_GPE)
        {
            Method (_L0A, 0, NotSerialized)
            {
                Notify (\_SB.PCI0.AC97, 0x02)
                Notify (\_SB.PWRB, 0x02)
            }

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

            Method (_L0B, 0, NotSerialized)
            {
                Notify (\_SB.PCI0.MAC, 0x02)
                Notify (\_SB.PCI0.CBS0, 0x02)
                Notify (\_SB.PCI0.P394, 0x02)
                Notify (\_SB.PCI0.MPCI, 0x02)
                Notify (\_SB.PWRB, 0x02)
            }

            Method (_L06, 0, NotSerialized)
            {
                Notify (\_SB.PCI0.EUSB, 0x02)
                Notify (\_SB.PWRB, 0x02)
            }

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

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

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

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Name (_UID, 0xAA)
            Name (_STA, 0x0B)
        }
    }

    Scope (\_SB.PCI0.SBRG)
    {
        Device (EC0)
        {
            Name (_HID, EisaId ("PNP0C09"))
            Name (_CRS, ResourceTemplate ()
            {
                IO (Decode16,
                    0x0062,             // Range Minimum
                    0x0062,             // Range Maximum
                    0x00,               // Alignment
                    0x01,               // Length
                    )
                IO (Decode16,
                    0x0066,             // Range Minimum
                    0x0066,             // Range Maximum
                    0x00,               // Alignment
                    0x01,               // Length
                    )
            })
            Name (_GPE, 0x19)
            Mutex (MUEC, 0x00)
            Name (ECFL, Zero)
            Method (ECAV, 0, NotSerialized)
            {
                If (LGreaterEqual (\SLPT, 0x04))
                {
                    Return (Zero)
                }

                Return (ECFL)
            }

            OperationRegion (ECOR, EmbeddedControl, 0x00, 0x80)
            Field (ECOR, ByteAcc, Lock, Preserve)
            {
                        Offset (0x04), 
                CMD1,   8, 
                CDT1,   8, 
                CDT2,   8, 
                CDT3,   8, 
                        Offset (0x43), 
                P50I,   1, 
                    ,   1, 
                    ,   1, 
                P43I,   1, 
                P54I,   1, 
                P55I,   1, 
                    ,   1, 
                        Offset (0x44), 
                P54D,   8, 
                P55D,   8, 
                        Offset (0x48), 
                P54S,   8, 
                P55S,   8, 
                P50S,   8, 
                P43S,   8, 
                P54T,   8, 
                P55T,   8, 
                P50T,   8, 
                P43T,   8, 
                P60S,   8, 
                P61S,   8, 
                P62S,   8, 
                P63S,   8, 
                P64S,   8, 
                P65S,   8, 
                P66S,   8, 
                P67S,   8, 
                P60T,   8, 
                P61T,   8, 
                P62T,   8, 
                P63T,   8, 
                P64T,   8, 
                P65T,   8, 
                P66T,   8, 
                P67T,   8, 
                        Offset (0x78), 
                P60I,   1, 
                P61I,   1, 
                P62I,   1, 
                P63I,   1, 
                P64I,   1, 
                P65I,   1, 
                P66I,   1, 
                P67I,   1
            }

            Name (SMBF, 0x00)
            OperationRegion (SMBX, EmbeddedControl, 0x18, 0x28)
            Field (SMBX, ByteAcc, NoLock, Preserve)
            {
                PRTC,   8, 
                SSTS,   5, 
                    ,   1, 
                ALFG,   1, 
                CDFG,   1, 
                ADDR,   8, 
                CMDB,   8, 
                BDAT,   256, 
                BCNT,   8, 
                    ,   1, 
                ALAD,   7, 
                ALD0,   8, 
                ALD1,   8
            }

            Field (SMBX, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x04), 
                DAT0,   8, 
                DAT1,   8
            }

            Field (SMBX, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x04), 
                DT2B,   16
            }

            OperationRegion (NSBS, EmbeddedControl, 0x40, 0x04)
            Field (NSBS, ByteAcc, NoLock, Preserve)
            {
                A2AD,   8, 
                A2D0,   8, 
                A2D1,   8, 
                A3AD,   8
            }

            Method (_INI, 0, NotSerialized)
            {
                If (LLessEqual (\OSFG, \OSME))
                {
                    Store (One, ECFL)
                }
            }

            Method (_REG, 2, NotSerialized)
            {
                If (LEqual (Arg0, 0x03))
                {
                    Store (Arg1, ECFL)
                }
            }

            Method (_Q69, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x52)
                }
            }

            Method (_Q6A, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x53)
                }
            }

            Method (_Q6B, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x54)
                }
            }

            Method (_Q6C, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x55)
                }
            }

            Method (_Q6D, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x56)
                }
            }

            Method (_Q0A, 0, NotSerialized)
            {
                Notify (\_SB.SLPB, 0x80)
            }

            Method (_Q0B, 0, NotSerialized)
            {
                If (\_SB.PCI0.MPCI.MPDP ())
                {
                    If (\_SB.ATKP)
                    {
                        Notify (\_SB.ATKD, 0x88)
                    }
                }
            }

            Method (_Q0E, 0, NotSerialized)
            {
                If (LEqual (OSFG, OSVT))
                {
                    If (\_SB.PCI0.P0P1.VGA.PRST ())
                    {
                        Store (0x02, \_SB.PCI0.P0P1.VGA.LCDD.BCBH)
                        Notify (\_SB.PCI0.P0P1.VGA.LCDD, 0x87)
                    }
                }
                Else
                {
                    If (LGreater (LBTN, 0x00))
                    {
                        Decrement (LBTN)
                    }

                    If (LGreater (LBTN, 0x0F))
                    {
                        Store (0x0F, LBTN)
                    }

                    STBR ()
                    If (\_SB.ATKP)
                    {
                        Notify (\_SB.ATKD, Add (LBTN, 0x20))
                    }
                }

                Return (One)
            }

            Method (_Q0F, 0, NotSerialized)
            {
                If (LEqual (OSFG, OSVT))
                {
                    If (\_SB.PCI0.P0P1.VGA.PRST ())
                    {
                        Store (0x01, \_SB.PCI0.P0P1.VGA.LCDD.BCBH)
                        Notify (\_SB.PCI0.P0P1.VGA.LCDD, 0x86)
                    }
                }
                Else
                {
                    If (LLess (LBTN, 0x0F))
                    {
                        Increment (LBTN)
                    }
                    Else
                    {
                        Store (0x0F, LBTN)
                    }

                    STBR ()
                    If (\_SB.ATKP)
                    {
                        Notify (\_SB.ATKD, Add (LBTN, 0x10))
                    }
                }

                Return (One)
            }

            Method (_Q10, 0, NotSerialized)
            {
                Store (0x01, Local0)
                Store (\RGPL (0x07, 0x01), Local0)
                XOr (Local0, 0x01, Local0)
                \SGPL (0x07, 0x01, Local0)
                If (\_SB.ATKP)
                {
                    Subtract (0x34, Local0, Local0)
                    Notify (\_SB.ATKD, Local0)
                }
            }

            Method (_Q11, 0, NotSerialized)
            {
                FHKW ()
                Store (\ADVG (), Local0)
                If (\NATK ())
                {
                    Add (Local0, 0x60, Local1)
                    If (\_SB.ATKP)
                    {
                        Notify (\_SB.ATKD, Local1)
                    }
                    Else
                    {
                        \SWHG (Local0)
                    }
                }
                Else
                {
                    \SWHG (Local0)
                }

                FHKS ()
            }

            Name (FHKM, One)
            Method (FHKW, 0, Serialized)
            {
                While (LNot (FHKM))
                {
                    Sleep (0x0A)
                }

                Store (Zero, FHKM)
            }

            Method (FHKS, 0, Serialized)
            {
                Store (One, FHKM)
            }

            Method (_Q13, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x32)
                }
            }

            Method (_Q14, 0, NotSerialized)
            {
                If (LLess (\AVOL, 0x0F))
                {
                    Increment (\AVOL)
                }

                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x31)
                }
            }

            Method (_Q15, 0, NotSerialized)
            {
                If (LGreater (\AVOL, 0x00))
                {
                    Decrement (\AVOL)
                }

                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x30)
                }
            }

            Method (_Q20, 0, NotSerialized)
            {
                If (CDFG)
                {
                    Store (One, SMBF)
                    Store (Zero, CDFG)
                }

                If (ALFG)
                {
                    \_SB.PCI0.SBRG.EC0.ALMH (ALAD)
                    Store (Zero, ALFG)
                }
            }

            Method (_Q33, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x6B)
                }
            }

            Method (_Q30, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x50)
                }
            }

            Method (_Q31, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x51)
                }
            }

            Method (_Q32, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x5C)
                }
            }

            Method (_Q36, 0, NotSerialized)
            {
                If (\_SB.ATKP)
                {
                    Notify (\_SB.ATKD, 0x4C)
                }
            }

            Name (LEDS, Ones)
            Method (EC0S, 1, NotSerialized)
            {
                If (LEqual (Arg0, 0x03))
                {
                    SPIN (0x24, 0x01)
                }

                If (Arg0)
                {
                    If (LLess (Arg0, 0x04))
                    {
                        Store (RDC3 (0x02), Local0)
                        And (Local0, 0xE0, LEDS)
                        And (LEDS, 0x80, Local1)
                        If (LNot (Local1))
                        {
                            SPIN (0x27, 0x01)
                        }

                        And (LEDS, 0x40, Local1)
                        If (LNot (Local1))
                        {
                            SPIN (0x26, 0x01)
                        }

                        And (LEDS, 0x20, Local1)
                        If (LNot (Local1))
                        {
                            SPIN (0x25, 0x01)
                        }
                    }
                }
            }

            Method (EC0W, 1, NotSerialized)
            {
                If (LEqual (Arg0, 0x03))
                {
                    SPIN (0x24, 0x00)
                }

                If (LLessEqual (Arg0, 0x04))
                {
                    Store (\ACPS (), \ACPF)
                    Store (\DCPS (0x00), \DCPF)
                }

                If (Arg0)
                {
                    If (LLess (Arg0, 0x04))
                    {
                        And (LEDS, 0x80, Local1)
                        If (LNot (Local1))
                        {
                            SPIN (0x27, 0x00)
                        }

                        And (LEDS, 0x40, Local1)
                        If (LNot (Local1))
                        {
                            SPIN (0x26, 0x00)
                        }

                        And (LEDS, 0x20, Local1)
                        If (LNot (Local1))
                        {
                            SPIN (0x25, 0x00)
                        }
                    }
                }
            }
        }
    }

    Scope (\_SB)
    {
        OperationRegion (\_SB.PCI0.SBRG.PIX0, PCI_Config, 0x41, 0x04)
        OperationRegion (\_SB.PCI0.SBRG.PIX1, PCI_Config, 0x60, 0x04)
        Field (\_SB.PCI0.SBRG.PIX0, ByteAcc, NoLock, Preserve)
        {
            PIRA,   8, 
            PIRB,   8, 
            PIRC,   8, 
            PIRD,   8
        }

        Field (\_SB.PCI0.SBRG.PIX1, ByteAcc, NoLock, Preserve)
        {
            PIRE,   8, 
            PIRF,   8, 
            PIRG,   8, 
            PIRH,   8
        }

        Name (BUFA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, _Y14)
                {15}
        })
        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x01)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRA, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRA, 0x80, PIRA)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRA, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRA)
            }
        }

        Device (LNKB)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x02)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRB, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRB, 0x80, PIRB)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRB, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRB)
            }
        }

        Device (LNKC)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x03)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRC, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRC, 0x80, PIRC)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRC, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRC)
            }
        }

        Device (LNKD)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x04)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRD, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRD, 0x80, PIRD)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRD, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRD)
            }
        }

        Device (LNKE)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x05)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRE, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRE, 0x80, PIRE)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRE, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRE)
            }
        }

        Device (LNKF)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x06)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRF, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRF, 0x80, PIRF)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRF, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRF)
            }
        }

        Device (LNKG)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x07)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRG, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRG, 0x80, PIRG)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRG, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRG)
            }
        }

        Device (LNKH)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x08)
            Method (_STA, 0, NotSerialized)
            {
                And (PIRH, 0x80, Local0)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                Or (PIRH, 0x80, PIRH)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, \_SB._Y14._INT, IRA0)
                And (PIRH, 0x0F, Local0)
                Store (One, Local1)
                ShiftLeft (Local1, Local0, IRA0)
                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Decrement (Local0)
                Store (Local0, PIRH)
            }
        }
    }

    Scope (\_SB)
    {
        Name (XCPD, 0x00)
        Name (XNPT, 0x01)
        Name (XCAP, 0x02)
        Name (XDCP, 0x04)
        Name (XDCT, 0x08)
        Name (XDST, 0x0A)
        Name (XLCP, 0x0C)
        Name (XLCT, 0x10)
        Name (XLST, 0x12)
        Name (XSCP, 0x14)
        Name (XSCT, 0x18)
        Name (XSST, 0x1A)
        Name (XRCT, 0x1C)
        Mutex (MUTE, 0x00)
        Method (RBPE, 1, NotSerialized)
        {
            Acquire (MUTE, 0x0FFFF)
            Add (Arg0, \PCIB, Local0)
            OperationRegion (PCFG, SystemMemory, Local0, 0x01)
            Field (PCFG, ByteAcc, NoLock, Preserve)
            {
                XCFG,   8
            }

            Release (MUTE)
            Return (XCFG)
        }

        Method (RWPE, 1, NotSerialized)
        {
            Acquire (MUTE, 0x0FFFF)
            And (Arg0, 0xFFFFFFFE, Arg0)
            Add (Arg0, \PCIB, Local0)
            OperationRegion (PCFG, SystemMemory, Local0, 0x02)
            Field (PCFG, WordAcc, NoLock, Preserve)
            {
                XCFG,   16
            }

            Release (MUTE)
            Return (XCFG)
        }

        Method (RDPE, 1, NotSerialized)
        {
            Acquire (MUTE, 0x0FFFF)
            And (Arg0, 0xFFFFFFFC, Arg0)
            Add (Arg0, \PCIB, Local0)
            OperationRegion (PCFG, SystemMemory, Local0, 0x04)
            Field (PCFG, DWordAcc, NoLock, Preserve)
            {
                XCFG,   32
            }

            Release (MUTE)
            Return (XCFG)
        }

        Method (WBPE, 2, NotSerialized)
        {
            Acquire (MUTE, 0x0FFFF)
            Add (Arg0, \PCIB, Local0)
            OperationRegion (PCFG, SystemMemory, Local0, 0x01)
            Field (PCFG, ByteAcc, NoLock, Preserve)
            {
                XCFG,   8
            }

            Store (Arg1, XCFG)
            Release (MUTE)
        }

        Method (WWPE, 2, NotSerialized)
        {
            Acquire (MUTE, 0x0FFFF)
            And (Arg0, 0xFFFFFFFE, Arg0)
            Add (Arg0, \PCIB, Local0)
            OperationRegion (PCFG, SystemMemory, Local0, 0x02)
            Field (PCFG, WordAcc, NoLock, Preserve)
            {
                XCFG,   16
            }

            Store (Arg1, XCFG)
            Release (MUTE)
        }

        Method (WDPE, 2, NotSerialized)
        {
            Acquire (MUTE, 0x0FFFF)
            And (Arg0, 0xFFFFFFFC, Arg0)
            Add (Arg0, \PCIB, Local0)
            OperationRegion (PCFG, SystemMemory, Local0, 0x04)
            Field (PCFG, DWordAcc, NoLock, Preserve)
            {
                XCFG,   32
            }

            Store (Arg1, XCFG)
            Release (MUTE)
        }

        Method (RWDP, 3, NotSerialized)
        {
            Acquire (MUTE, 0x0FFFF)
            And (Arg0, 0xFFFFFFFC, Arg0)
            Add (Arg0, \PCIB, Local0)
            OperationRegion (PCFG, SystemMemory, Local0, 0x04)
            Field (PCFG, DWordAcc, NoLock, Preserve)
            {
                XCFG,   32
            }

            And (XCFG, Arg2, Local1)
            Or (Local1, Arg1, XCFG)
            Release (MUTE)
        }

        Method (RPME, 1, NotSerialized)
        {
            Add (Arg0, 0x84, Local0)
            Store (\_SB.RDPE (Local0), Local1)
            If (LEqual (Local1, 0xFFFFFFFF))
            {
                Return (0x00)
            }
            Else
            {
                If (LAnd (Local1, 0x00010000))
                {
                    \_SB.WDPE (Local0, And (Local1, 0x00010000))
                    Return (0x01)
                }

                Return (0x00)
            }
        }
    }

    Scope (\_SB.PCI0.SBRG.EC0)
    {
        Method (WCMD, 1, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CMD1)
                    Release (MUEC)
                }
            }
        }

        Method (DLY0, 1, Serialized)
        {
            If (LNot (ECAV ()))
            {
                Return (Ones)
            }

            Store (Ones, Local0)
            If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
            {
                Store (Arg0, CDT1)
                Store (0x6B, CDT2)
                Store (0x00, CDT3)
                Store (0xBB, CMD1)
                Store (0x7F, Local1)
                While (LAnd (Local1, CMD1))
                {
                    Sleep (0x01)
                    Decrement (Local1)
                }

                If (LEqual (CMD1, Zero))
                {
                    Store (CDT1, Local0)
                }

                Release (MUEC)
            }

            Return (Local0)
        }

        Method (RRAM, 2, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CDT3)
                    Store (Arg1, CDT2)
                    Store (0xBA, CMD1)
                    Store (0x7F, Local0)
                    While (LAnd (Local0, CMD1))
                    {
                        Sleep (0x01)
                        Decrement (Local0)
                    }

                    If (LEqual (CMD1, Zero))
                    {
                        Store (CDT1, Local0)
                    }
                    Else
                    {
                        Store (Ones, Local0)
                    }

                    Release (MUEC)
                    Return (Local0)
                }
            }

            Return (Ones)
        }

        Method (WRAM, 3, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CDT3)
                    Store (Arg1, CDT2)
                    Store (Arg2, CDT1)
                    Store (0xBB, CMD1)
                    Store (0x7F, Local0)
                    While (LAnd (Local0, CMD1))
                    {
                        Sleep (0x01)
                        Decrement (Local0)
                    }

                    If (LEqual (CMD1, Zero))
                    {
                        Store (One, Local0)
                    }
                    Else
                    {
                        Store (Ones, Local0)
                    }

                    Release (MUEC)
                    Return (Local0)
                }
            }

            Return (Ones)
        }

        Method (STBR, 0, Serialized)
        {
            SBDA ()
        }

        Method (SBDA, 0, Serialized)
        {
            If (\ACPF)
            {
                Store (DerefOf (Index (PWAC, LBTN)), Local0)
            }
            Else
            {
                Store (DerefOf (Index (PWDC, LBTN)), Local0)
            }

            Add (0x02, 0x83, Local1)
            SADC (Local0, Local1)
        }

        Method (SADC, 2, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CDT1)
                    Store (Arg1, CDT2)
                    Store (0xC4, CMD1)
                    Store (0x7F, Local0)
                    While (LAnd (Local0, CMD1))
                    {
                        Sleep (0x01)
                        Decrement (Local0)
                    }

                    If (LEqual (CMD1, Zero))
                    {
                        Store (CDT1, Local0)
                    }
                    Else
                    {
                        Store (Ones, Local0)
                    }

                    Release (MUEC)
                    Return (Local0)
                }
            }

            Return (Ones)
        }

        Method (SBQH, 3, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CDT1)
                    Store (Arg1, CDT2)
                    Store (Arg2, CMD1)
                    Store (0x7F, Local0)
                    While (LAnd (Local0, CMD1))
                    {
                        Sleep (0x01)
                        Decrement (Local0)
                    }

                    If (LEqual (CMD1, Zero))
                    {
                        Store (CDT1, Local0)
                    }
                    Else
                    {
                        Store (Ones, Local0)
                    }

                    Release (MUEC)
                    Return (Local0)
                }
            }

            Return (Ones)
        }

        Method (STC5, 1, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CDT1)
                    Store (0xC5, CMD1)
                    Store (0x7F, Local0)
                    While (LAnd (Local0, CMD1))
                    {
                        Sleep (0x01)
                        Decrement (Local0)
                    }

                    If (LEqual (CMD1, Zero))
                    {
                        Store (CDT1, Local0)
                    }
                    Else
                    {
                        Store (Ones, Local0)
                    }

                    Release (MUEC)
                    Return (Local0)
                }
            }

            Return (Ones)
        }

        Method (SPIN, 2, Serialized)
        {
            ShiftRight (Arg0, 0x04, Local0)
            And (Arg0, 0x0F, Local1)
            If (LNotEqual (Local0, 0x05))
            {
                If (LEqual (Local0, 0x02))
                {
                    Add (Local1, 0x08, Local1)
                }
                Else
                {
                    If (LEqual (Local0, 0x04))
                    {
                        Add (Local1, 0x10, Local1)
                    }
                    Else
                    {
                        If (LEqual (Local0, 0x06))
                        {
                            Add (Local1, 0x18, Local1)
                        }
                        Else
                        {
                            Return (Ones)
                        }
                    }
                }
            }

            If (Arg1)
            {
                Or (Local1, 0x20, Local1)
            }
            Else
            {
                Or (Local1, 0x40, Local1)
            }

            STC5 (Local1)
            Return (One)
        }

        Method (RPIN, 1, Serialized)
        {
            ShiftRight (Arg0, 0x04, Local0)
            And (Local0, 0x0F, Local0)
            And (Arg0, 0x0F, Local1)
            Store (RDC3 (Local0), Local2)
            ShiftRight (Local2, Local1, Local2)
            And (Local2, 0x01, Local2)
            Return (Local2)
        }

        Method (RDC3, 1, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CDT1)
                    Store (0xC3, CMD1)
                    Store (0x7F, Local0)
                    While (LAnd (Local0, CMD1))
                    {
                        Sleep (0x01)
                        Decrement (Local0)
                    }

                    If (LEqual (CMD1, Zero))
                    {
                        Store (CDT1, Local0)
                    }
                    Else
                    {
                        Store (Ones, Local0)
                    }

                    Release (MUEC)
                    Return (Local0)
                }
            }

            Return (Ones)
        }

        Method (RBAT, 2, Serialized)
        {
            If (LNot (ECAV ()))
            {
                Return (Ones)
            }

            If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
            {
                Store (0x03, Local0)
                While (Local0)
                {
                    Store (Arg0, CDT2)
                    Store (Arg1, Local1)
                    ShiftLeft (Local1, 0x01, Local1)
                    Add (Local1, 0xDA, Local1)
                    Store (Local1, CMD1)
                    Store (0x7F, Local1)
                    While (LAnd (CMD1, Local1))
                    {
                        Decrement (Local1)
                        Sleep (0x01)
                    }

                    If (LEqual (CMD1, 0x00))
                    {
                        Store (CDT1, Local1)
                        Store (Zero, Local0)
                    }
                    Else
                    {
                        Store (Ones, Local1)
                        Decrement (Local0)
                    }
                }

                Release (MUEC)
                Return (Local1)
            }

            Return (Ones)
        }

        Method (WBAT, 3, Serialized)
        {
            Or (Arg0, 0x80, Local3)
            If (LNot (ECAV ()))
            {
                Return (Ones)
            }

            If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
            {
                Store (0x03, Local0)
                While (Local0)
                {
                    Store (Arg2, CDT1)
                    Store (Local3, CDT2)
                    Store (Arg1, Local1)
                    ShiftLeft (Local1, 0x01, Local1)
                    Add (Local1, 0xDA, Local1)
                    Store (Local1, CMD1)
                    Store (0x7F, Local1)
                    While (LAnd (CMD1, Local1))
                    {
                        Decrement (Local1)
                        Sleep (0x01)
                    }
                }

                Release (MUEC)
                Return (Local1)
            }

            Return (Ones)
        }

        Method (FNCT, 2, Serialized)
        {
            If (ECAV ())
            {
                If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
                {
                    Store (Arg0, CDT2)
                    Store (Arg1, CDT1)
                    Store (0xC4, CMD1)
                    Store (0x7F, Local0)
                    While (LAnd (Local0, CMD1))
                    {
                        Sleep (0x01)
                        Decrement (Local0)
                    }

                    Release (MUEC)
                }
            }
        }

        Name (WRQK, 0x02)
        Name (RDQK, 0x03)
        Name (SDBT, 0x04)
        Name (RCBT, 0x05)
        Name (WRBT, 0x06)
        Name (RDBT, 0x07)
        Name (WRWD, 0x08)
        Name (RDWD, 0x09)
        Name (WRBL, 0x0A)
        Name (RDBL, 0x0B)
        Name (PCLL, 0x0C)
        Name (GOOD, 0x00)
        Name (UKER, 0x07)
        Name (DAER, 0x10)
        Name (CMDN, 0x12)
        Name (UKE2, 0x13)
        Name (DADN, 0x17)
        Name (SBTO, 0x18)
        Name (USPT, 0x19)
        Name (SBBY, 0x1A)
        Method (SWTC, 2, Serialized)
        {
            Store (0x05, Local2)
            While (Local2)
            {
                Store (Arg1, PRTC)
                And (Arg0, 0xFFFF, Local1)
                While (Local1)
                {
                    If (LEqual (PRTC, 0x00))
                    {
                        Store (SSTS, Local0)
                        Store (Zero, Local1)
                        If (Local0)
                        {
                            Decrement (Local2)
                        }
                        Else
                        {
                            Store (Zero, Local2)
                        }
                    }
                    Else
                    {
                        Sleep (0x01)
                        If (LNotEqual (Local1, 0xFFFF))
                        {
                            Decrement (Local1)
                            If (LEqual (Local1, 0x00))
                            {
                                Store (Zero, PRTC)
                                Store (Zero, Local2)
                                Store (UKER, Local0)
                            }
                        }
                    }
                }
            }

            Return (Local0)
        }

        Method (SMBR, 3, Serialized)
        {
            Store (Package (0x03)
                {
                    0x07, 
                    0x00, 
                    0x00
                }, Local0)
            If (LNot (ECAV ()))
            {
                Return (Local0)
            }

            If (LNotEqual (Arg0, RDBL))
            {
                If (LNotEqual (Arg0, RDWD))
                {
                    If (LNotEqual (Arg0, RDBT))
                    {
                        If (LNotEqual (Arg0, RCBT))
                        {
                            If (LNotEqual (Arg0, RDQK))
                            {
                                Return (Local0)
                            }
                        }
                    }
                }
            }

            If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
            {
                Store (PRTC, Local1)
                Store (Zero, Local2)
                While (LNotEqual (Local1, 0x00))
                {
                    Stall (0x0A)
                    Increment (Local2)
                    If (LGreater (Local2, 0x03E8))
                    {
                        Store (SBBY, Index (Local0, 0x00))
                        Store (Zero, Local1)
                    }
                    Else
                    {
                        Store (PRTC, Local1)
                    }
                }

                If (LLessEqual (Local2, 0x03E8))
                {
                    ShiftLeft (Arg1, 0x01, Local3)
                    Or (Local3, 0x01, Local3)
                    Store (Local3, ADDR)
                    If (LNotEqual (Arg0, RDQK))
                    {
                        If (LNotEqual (Arg0, RCBT))
                        {
                            Store (Arg2, CMDB)
                        }
                    }

                    Store (SWTC (0x07D0, Arg0), Index (Local0, 0x00))
                    If (LEqual (DerefOf (Index (Local0, 0x00)), 0x00))
                    {
                        If (LEqual (Arg0, RDBL))
                        {
                            Store (BCNT, Index (Local0, 0x01))
                            Store (BDAT, Index (Local0, 0x02))
                        }

                        If (LEqual (Arg0, RDWD))
                        {
                            Store (0x02, Index (Local0, 0x01))
                            Store (DT2B, Index (Local0, 0x02))
                        }

                        If (LEqual (Arg0, RDBT))
                        {
                            Store (0x01, Index (Local0, 0x01))
                            Store (DAT0, Index (Local0, 0x02))
                        }

                        If (LEqual (Arg0, RCBT))
                        {
                            Store (0x01, Index (Local0, 0x01))
                            Store (DAT0, Index (Local0, 0x02))
                        }
                    }
                }

                Release (MUEC)
            }

            Return (Local0)
        }

        Method (SMBW, 5, Serialized)
        {
            Store (Package (0x01)
                {
                    0x07
                }, Local0)
            If (LNot (ECAV ()))
            {
                Return (Local0)
            }

            If (LNotEqual (Arg0, WRBL))
            {
                If (LNotEqual (Arg0, WRWD))
                {
                    If (LNotEqual (Arg0, WRBT))
                    {
                        If (LNotEqual (Arg0, SDBT))
                        {
                            If (LNotEqual (Arg0, WRQK))
                            {
                                Return (Local0)
                            }
                        }
                    }
                }
            }

            If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))
            {
                Store (PRTC, Local1)
                Store (Zero, Local2)
                While (LNotEqual (Local1, 0x00))
                {
                    Stall (0x0A)
                    Increment (Local2)
                    If (LGreater (Local2, 0x03E8))
                    {
                        Store (SBBY, Index (Local0, 0x00))
                        Store (Zero, Local1)
                    }
                    Else
                    {
                        Store (PRTC, Local1)
                    }
                }

                If (LLessEqual (Local2, 0x03E8))
                {
                    ShiftLeft (Arg1, 0x01, Local3)
                    Store (Local3, ADDR)
                    If (LNotEqual (Arg0, WRQK))
                    {
                        If (LNotEqual (Arg0, SDBT))
                        {
                            Store (Arg2, CMDB)
                        }
                    }

                    If (LEqual (Arg0, WRBL))
                    {
                        Store (Arg3, BCNT)
                        Store (Arg4, BDAT)
                    }

                    If (LEqual (Arg0, WRWD))
                    {
                        Store (Arg4, DT2B)
                    }

                    If (LEqual (Arg0, WRBT))
                    {
                        Store (Arg4, DAT0)
                    }

                    If (LEqual (Arg0, SDBT))
                    {
                        Store (Arg4, DAT0)
                    }

                    Store (SWTC (0x07D0, Arg0), Index (Local0, 0x00))
                }

                Release (MUEC)
            }

            Return (Local0)
        }
    }

    Scope (\_SB.PCI0.SBRG.EC0)
    {
    }

    Scope (\)
    {
        OperationRegion (\SIOG, SystemIO, IO1B, IO1L)
        Field (\SIOG, ByteAcc, NoLock, Preserve)
        {
                    Offset (0x0C), 
            PO10,   8, 
            PO20,   8, 
            PO30,   8, 
            PO40,   8
        }

        Method (RIOP, 2, Serialized)
        {
            If (LLess (Arg0, 0x20))
            {
                Store (PO10, Local0)
            }
            Else
            {
                If (LLess (Arg0, 0x30))
                {
                    Store (PO20, Local0)
                }
                Else
                {
                    If (LLess (Arg0, 0x40))
                    {
                        Store (PO30, Local0)
                    }
                    Else
                    {
                        Store (PO40, Local0)
                    }
                }
            }

            And (Arg0, 0x0F, Local1)
            ShiftRight (Local0, Local1, Local0)
            Store (Arg1, Local2)
            Store (Zero, Local3)
            While (Local2)
            {
                ShiftLeft (Local3, 0x01, Local3)
                Or (Local3, 0x01, Local3)
                Decrement (Local2)
            }

            And (Local0, Local3, Local0)
            Return (Local0)
        }

        Method (WIOP, 3, Serialized)
        {
            If (LLess (Arg0, 0x20))
            {
                Store (PO10, Local0)
            }
            Else
            {
                If (LLess (Arg0, 0x30))
                {
                    Store (PO20, Local0)
                }
                Else
                {
                    If (LLess (Arg0, 0x40))
                    {
                        Store (PO30, Local0)
                    }
                    Else
                    {
                        Store (PO40, Local0)
                    }
                }
            }

            And (Arg0, 0x0F, Local1)
            Store (Arg1, Local2)
            Store (Zero, Local3)
            While (Local2)
            {
                ShiftLeft (Local3, 0x01, Local3)
                Or (Local3, 0x01, Local3)
                Decrement (Local2)
            }

            ShiftLeft (Local3, Local1, Local3)
            Not (Local3, Local3)
            And (Local0, Local3, Local0)
            ShiftLeft (Arg2, Local1, Local4)
            Or (Local0, Local4, Local0)
            If (LLess (Arg0, 0x20))
            {
                Store (Local0, PO10)
            }
            Else
            {
                If (LLess (Arg0, 0x30))
                {
                    Store (Local0, PO20)
                }
                Else
                {
                    If (LLess (Arg0, 0x40))
                    {
                        Store (Local0, PO30)
                    }
                    Else
                    {
                        Store (Local0, PO40)
                    }
                }
            }
        }

        OperationRegion (\SIOP, SystemIO, \SPIO, 0x02)
        Field (\SIOP, ByteAcc, Lock, Preserve)
        {
            SIOI,   8, 
            SIOD,   8
        }

        IndexField (SIOI, SIOD, ByteAcc, NoLock, Preserve)
        {
                    Offset (0x07), 
            LDNP,   8, 
                    Offset (0x30), 
            LDCP,   8
        }
    }

    Scope (\)
    {
        OperationRegion (\PMIO, SystemIO, PMBS, 0x80)
        Field (\PMIO, ByteAcc, NoLock, Preserve)
        {
                    Offset (0x10), 
                ,   1, 
            TDTY,   3, 
            TENA,   1, 
                    Offset (0x2A), 
            TTDT,   3, 
            TTEN,   1, 
                    Offset (0x30), 
            G00S,   1, 
            G01S,   1, 
            G02S,   1, 
            G03S,   1, 
            G04S,   1, 
            G05S,   1, 
            G06S,   1, 
            G07S,   1, 
            G08S,   1, 
            G09S,   1, 
            G0AS,   1, 
            G0BS,   1, 
            G0CS,   1, 
            G0DS,   1, 
            G0ES,   1, 
            G0FS,   1, 
            G00E,   1, 
            G01E,   1, 
            G02E,   1, 
            G03E,   1, 
            G04E,   1, 
            G05E,   1, 
            G06E,   1, 
            G07E,   1, 
            G08E,   1, 
            G09E,   1, 
            G0AE,   1, 
            G0BE,   1, 
            G0CE,   1, 
            G0DE,   1, 
            G0EE,   1, 
            G0FE,   1, 
            G00R,   2, 
            G01R,   2, 
            G02R,   2, 
            G03R,   2, 
            G04R,   2, 
            G05R,   2, 
            G06R,   2, 
            G07R,   2, 
            G08R,   2, 
            G09R,   2, 
            G0AR,   2, 
            G0BR,   2, 
            G0CR,   2, 
            G0DR,   2, 
            G0ER,   2, 
            G0FR,   2, 
                    Offset (0x3E), 
            GP00,   16, 
                ,   6, 
            SLPS,   1, 
                    Offset (0x42), 
                ,   6, 
            SLPE,   1, 
                    Offset (0x62), 
            S3OF,   1, 
                    Offset (0x64), 
            GL00,   18
        }

        Method (RGPL, 2, Serialized)
        {
            Store (Arg1, Local0)
            Store (Zero, Local1)
            While (Local0)
            {
                ShiftLeft (Local1, 0x01, Local1)
                Or (Local1, 0x01, Local1)
                Decrement (Local0)
            }

            ShiftLeft (Local1, Arg0, Local1)
            Store (GL00, Local0)
            And (Local0, Local1, Local0)
            ShiftRight (Local0, Arg0, Local0)
            Return (Local0)
        }

        Method (SGPL, 3, Serialized)
        {
            Store (Arg1, Local0)
            Store (Zero, Local1)
            Store (Arg2, Local2)
            While (Local0)
            {
                ShiftLeft (Local1, 0x01, Local1)
                Or (Local1, 0x01, Local1)
                Decrement (Local0)
            }

            ShiftLeft (Local1, Arg0, Local1)
            Not (Local1, Local1)
            ShiftLeft (Local2, Arg0, Local2)
            Store (GL00, Local0)
            And (Local0, Local1, Local0)
            Or (Local0, Local2, GL00)
        }

        Method (RGPP, 1, Serialized)
        {
            ShiftRight (GP00, Arg0, Local0)
            And (Local0, 0x01, Local0)
            Return (Local0)
        }

        Method (TGPP, 1, Serialized)
        {
            ShiftLeft (0x01, Arg0, Local0)
            XOr (GP00, Local0, GP00)
        }

        Method (SGPP, 2, Serialized)
        {
            ShiftLeft (0x01, Arg0, Local0)
            If (Arg1)
            {
                Or (GP00, Local0, GP00)
            }
            Else
            {
                Not (Local0, Local1)
                And (GP00, Local1, GP00)
            }
        }

        Name (PMEW, Zero)
        Method (SBRS, 1, NotSerialized)
        {
        }

        Method (SBRW, 1, NotSerialized)
        {
        }

        Method (STRP, 1, NotSerialized)
        {
            If (Arg0)
            {
                Store (One, \SLPS)
                Store (One, \SLPE)
            }
            Else
            {
                Store (One, \SLPS)
                Store (Zero, \SLPT)
            }
        }

        Method (HKTH, 0, Serialized)
        {
            Return (0xFFFF)
        }
    }

    Scope (\)
    {
        OperationRegion (SMB, SystemIO, SMBS, SMBL)
        Field (SMB, ByteAcc, NoLock, Preserve)
        {
            SMB0,   8, 
            SMB1,   8, 
            SMB2,   8, 
            SMB3,   8, 
            SMB4,   8, 
            SMB5,   8, 
            SMB6,   8, 
            SMB7,   8, 
            SMB8,   8, 
            SMB9,   8, 
            SMBA,   8, 
            SMBB,   8, 
            SMBC,   8, 
            SMBD,   8, 
            SMBE,   8, 
            SMBF,   8
        }

        Name (RBUF, Package (0x20) {})
        Method (HBSY, 0, NotSerialized)
        {
            Store (0xFFFF, Local0)
            While (Local0)
            {
                And (SMB2, 0x03, Local1)
                If (LEqual (Local1, 0x00))
                {
                    Return (Zero)
                }

                Decrement (Local0)
            }

            Return (0x01)
        }

        Method (WTSB, 0, NotSerialized)
        {
            Store (0xFFFF, Local0)
            While (Local0)
            {
                Decrement (Local0)
                And (SMB0, 0x18, Local1)
                If (Local1)
                {
                    Return (0x01)
                }
            }

            Return (0x00)
        }

        Mutex (\P4SM, 0x00)
        Method (WBYT, 3, Serialized)
        {
            If (LNotEqual (Acquire (\P4SM, 0xFFFF), 0x00))
            {
                Return (Ones)
            }

            Store (0xFF, SMB0)
            And (SMB2, 0x03, Local0)
            If (Local0)
            {
                Store (0x20, SMB3)
            }

            Store (0x05, Local0)
            While (Local0)
            {
                If (HBSY ())
                {
                    Decrement (Local0)
                }
                Else
                {
                    Store (Arg0, SMB4)
                    Store (Arg1, SMB5)
                    Store (Arg2, SMB8)
                    Store (0x12, SMB3)
                    If (WTSB ())
                    {
                        Store (0xFF, SMB0)
                        Release (\P4SM)
                        Return (0x01)
                    }
                    Else
                    {
                        Decrement (Local0)
                    }
                }
            }

            Store (0xFF, SMB0)
            Release (\P4SM)
            Return (Ones)
        }

        Method (RWRD, 2, Serialized)
        {
            If (LNotEqual (Acquire (\P4SM, 0xFFFF), 0x00))
            {
                Return (Ones)
            }

            Store (0xFF, SMB0)
            And (SMB2, 0x03, Local0)
            If (Local0)
            {
                Store (0x20, SMB3)
            }

            Store (0x05, Local0)
            While (Local0)
            {
                If (HBSY ())
                {
                    Decrement (Local0)
                }
                Else
                {
                    Or (Arg0, 0x01, SMB4)
                    Store (Arg1, SMB5)
                    Store (0x12, SMB3)
                    If (WTSB ())
                    {
                        Store (0xFF, SMB0)
                        Store (SMB9, Local1)
                        ShiftLeft (Local1, 0x08, Local1)
                        Or (Local1, SMB8, Local1)
                        Release (\P4SM)
                        Return (Local1)
                    }
                    Else
                    {
                        Decrement (Local0)
                    }
                }
            }

            Store (0xFF, SMB0)
            Release (\P4SM)
            Return (Ones)
        }

        Method (WWRD, 3, Serialized)
        {
            If (LNotEqual (Acquire (\P4SM, 0xFFFF), 0x00))
            {
                Return (Ones)
            }

            Store (0xFF, SMB0)
            And (SMB2, 0x03, Local0)
            If (Local0)
            {
                Store (0x20, SMB3)
            }

            Store (0x05, Local0)
            While (Local0)
            {
                If (HBSY ())
                {
                    Decrement (Local0)
                }
                Else
                {
                    Store (Arg0, SMB4)
                    Store (Arg1, SMB5)
                    And (Arg2, 0xFF, Local1)
                    ShiftRight (Arg2, 0x08, Local2)
                    Store (Local1, SMB8)
                    Store (Local2, SMB9)
                    Store (0x13, SMB3)
                    If (WTSB ())
                    {
                        Store (0xFF, SMB0)
                        Release (\P4SM)
                        Return (0x01)
                    }
                    Else
                    {
                        Decrement (Local0)
                    }
                }
            }

            Store (0xFF, SMB0)
            Release (\P4SM)
            Return (Ones)
        }

        Method (RBYT, 2, Serialized)
        {
            If (LNotEqual (Acquire (\P4SM, 0xFFFF), 0x00))
            {
                Return (Ones)
            }

            Store (0xFF, SMB0)
            And (SMB2, 0x03, Local0)
            If (Local0)
            {
                Store (0x20, SMB3)
            }

            Store (0x05, Local0)
            While (Local0)
            {
                If (HBSY ())
                {
                    Decrement (Local0)
                }
                Else
                {
                    Or (Arg0, 0x01, SMB4)
                    Store (Arg1, SMB5)
                    Store (0x12, SMB3)
                    If (WTSB ())
                    {
                        Store (0xFF, SMB0)
                        Release (\P4SM)
                        Return (SMB8)
                    }
                    Else
                    {
                        Decrement (Local0)
                    }
                }
            }

            Store (0xFF, SMB0)
            Release (\P4SM)
            Return (Ones)
        }

        Method (RBLK, 3, Serialized)
        {
            If (LNotEqual (Acquire (\P4SM, 0xFFFF), 0x00))
            {
                Return (Ones)
            }

            Store (0xFF, SMB0)
            And (SMB2, 0x03, Local0)
            If (Local0)
            {
                Store (0x20, SMB3)
            }

            Store (0x00, Local1)
            Store (0x05, Local0)
            While (Local0)
            {
                If (HBSY ())
                {
                    Decrement (Local0)
                }
                Else
                {
                    Or (Arg0, 0x01, SMB4)
                    Store (Arg2, SMB5)
                    Store (0x15, SMB3)
                    While (0x01)
                    {
                        If (WTSB ())
                        {
                            Store (SMB8, Index (RBUF, Local1))
                            Increment (Local1)
                            Store (SMB9, Index (RBUF, Local1))
                            Increment (Local1)
                            Store (SMBA, Index (RBUF, Local1))
                            Increment (Local1)
                            Store (SMBB, Index (RBUF, Local1))
                            Increment (Local1)
                            Store (SMBC, Index (RBUF, Local1))
                            Increment (Local1)
                            Store (SMBD, Index (RBUF, Local1))
                            Increment (Local1)
                            Store (SMBE, Index (RBUF, Local1))
                            Increment (Local1)
                            Store (SMBF, Index (RBUF, Local1))
                            Increment (Local1)
                            If (LGreater (Arg1, 0x08))
                            {
                                Subtract (Arg1, 0x08, Arg1)
                                Store (0x10, SMB0)
                            }
                            Else
                            {
                                Store (0xFF, SMB0)
                                Release (\P4SM)
                                Return (0x01)
                            }
                        }
                        Else
                        {
                            Decrement (Local0)
                        }
                    }
                }
            }

            Store (0xFF, SMB0)
            Release (\P4SM)
            Return (Ones)
        }

        Method (WBLK, 3, Serialized)
        {
            If (LNotEqual (Acquire (\P4SM, 0xFFFF), 0x00))
            {
                Return (Ones)
            }

            Store (0xFF, SMB0)
            And (SMB2, 0x03, Local0)
            If (Local0)
            {
                Store (0x20, SMB3)
            }

            Store (0x00, Local1)
            Store (0x05, Local0)
            While (Local0)
            {
                If (HBSY ())
                {
                    Decrement (Local0)
                }
                Else
                {
                    Store (DerefOf (Index (RBUF, Local1)), SMB8)
                    Increment (Local1)
                    Store (DerefOf (Index (RBUF, Local1)), SMB9)
                    Increment (Local1)
                    Store (DerefOf (Index (RBUF, Local1)), SMBA)
                    Increment (Local1)
                    Store (DerefOf (Index (RBUF, Local1)), SMBB)
                    Increment (Local1)
                    Store (DerefOf (Index (RBUF, Local1)), SMBC)
                    Increment (Local1)
                    Store (DerefOf (Index (RBUF, Local1)), SMBD)
                    Increment (Local1)
                    Store (DerefOf (Index (RBUF, Local1)), SMBE)
                    Increment (Local1)
                    Store (DerefOf (Index (RBUF, Local1)), SMBF)
                    Increment (Local1)
                    And (Arg0, 0xFE, SMB4)
                    Store (Arg1, SMB7)
                    Store (Arg2, SMB5)
                    Store (0x15, SMB3)
                    If (WTSB ())
                    {
                        If (LGreater (Arg1, 0x08))
                        {
                            Subtract (Arg1, 0x08, Arg1)
                        }
                        Else
                        {
                            Store (0xFF, SMB0)
                            Release (\P4SM)
                            Return (0x01)
                        }
                    }
                    Else
                    {
                        Decrement (Local0)
                    }

                    While (Local0)
                    {
                        Store (DerefOf (Index (RBUF, Local1)), SMB8)
                        Increment (Local1)
                        Store (DerefOf (Index (RBUF, Local1)), SMB9)
                        Increment (Local1)
                        Store (DerefOf (Index (RBUF, Local1)), SMBA)
                        Increment (Local1)
                        Store (DerefOf (Index (RBUF, Local1)), SMBB)
                        Increment (Local1)
                        Store (DerefOf (Index (RBUF, Local1)), SMBC)
                        Increment (Local1)
                        Store (DerefOf (Index (RBUF, Local1)), SMBD)
                        Increment (Local1)
                        Store (DerefOf (Index (RBUF, Local1)), SMBE)
                        Increment (Local1)
                        Store (DerefOf (Index (RBUF, Local1)), SMBF)
                        Increment (Local1)
                        Store (0x10, SMB0)
                        If (WTSB ())
                        {
                            If (LGreater (Arg1, 0x08))
                            {
                                Subtract (Arg1, 0x08, Arg1)
                            }
                            Else
                            {
                                Store (0xFF, SMB0)
                                Release (\P4SM)
                                Return (0x01)
                            }
                        }
                        Else
                        {
                            Decrement (Local0)
                        }
                    }
                }
            }

            Store (0xFF, SMB0)
            Release (\P4SM)
            Return (Ones)
        }
    }

    Scope (\)
    {
        Name (TSP, 0x0A)
        Name (TC1, 0x02)
        Name (TC2, 0x0A)
    }

    Scope (\_TZ)
    {
        Name (HLMT, 0x00)
        Name (LLMT, 0x00)
        Name (F1PW, 0x00)
        Name (F2PW, 0x00)
        Name (LTMP, 0x00)
        Name (FANL, 0x00)
        Method (KELV, 1, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            If (LGreaterEqual (Local0, 0x80))
            {
                Subtract (0x0100, Local0, Local0)
                Multiply (Local0, 0x0A, Local0)
                Subtract (0x0AAC, Local0, Local0)
                Return (Local0)
            }

            Multiply (Local0, 0x0A, Local0)
            Add (Local0, 0x0AAC, Local0)
            Return (Local0)
        }

        Method (CELC, 1, NotSerialized)
        {
            Subtract (Arg0, 0x0AAC, Local0)
            Divide (Local0, 0x0A, Local1, Local0)
            Return (Local0)
        }

        Name (PLCY, 0x00)
        ThermalZone (THRM)
        {
            Method (_CRT, 0, NotSerialized)
            {
                Return (KELV (TCRT))
            }

            Method (_TMP, 0, NotSerialized)
            {
                Store (0x05, Local1)
                While (Local1)
                {
                    Store (GTMP (), Local0)
                    If (LGreater (Local0, TCRT))
                    {
                        Decrement (Local1)
                    }
                    Else
                    {
                        Store (0x00, Local1)
                    }
                }

                Return (KELV (Local0))
            }

            Name (_PSL, Package (0x01)
            {
                \_PR.CPU1
            })
            Method (_TSP, 0, NotSerialized)
            {
                Multiply (TSP, 0x0A, Local0)
                Return (Local0)
            }

            Method (_TC1, 0, NotSerialized)
            {
                Return (TC1)
            }

            Method (_TC2, 0, NotSerialized)
            {
                Return (TC2)
            }

            Method (_PSV, 0, NotSerialized)
            {
                If (PLCY)
                {
                    Return (KELV (PPSV))
                }
                Else
                {
                    Return (KELV (TPSV))
                }
            }

            Name (_AL0, Package (0x01)
            {
                FN00
            })
            Method (_AC0, 0, NotSerialized)
            {
                If (PLCY)
                {
                    Return (KELV (PAC0))
                }
                Else
                {
                    Return (KELV (TAC0))
                }
            }

            Method (_SCP, 1, NotSerialized)
            {
                TCHG ()
                Notify (THRM, 0x81)
            }
        }

        Method (TRMS, 1, NotSerialized)
        {
            If (Arg0)
            {
                \_TZ.TMSS (Arg0)
            }
        }

        Method (TRMW, 1, NotSerialized)
        {
            If (Arg0)
            {
                If (LLess (Arg0, 0x04))
                {
                    \_TZ.TMSW (Arg0)
                    \_TZ.TCHG ()
                }
            }
        }

        Method (TCHG, 0, Serialized)
        {
            MINT ()
            GTMP ()
            If (LGreaterEqual (LTMP, 0x80))
            {
                Store (0x00, LTMP)
            }

            If (PLCY)
            {
                Store (\_TZ.THRM._PSV (), Local0)
                Store (CELC (Local0), Local0)
                Store (\_TZ.THRM._AC0 (), Local1)
                Store (CELC (Local1), Local1)
                If (LGreater (LTMP, TCRT))
                {
                    Store (0x7F, HLMT)
                    Store (TCRT, LLMT)
                    Store (0x10, FANL)
                }
                Else
                {
                    If (LGreater (LTMP, Local1))
                    {
                        Store (TCRT, HLMT)
                        Store (Local1, LLMT)
                        Store (0x11, FANL)
                    }
                    Else
                    {
                        If (LGreater (LTMP, Local0))
                        {
                            Store (Local1, HLMT)
                            Store (Local0, LLMT)
                            Store (0x12, FANL)
                        }
                        Else
                        {
                            Store (Local0, HLMT)
                            Store (0xC9, LLMT)
                            Store (0x13, FANL)
                        }
                    }
                }
            }
            Else
            {
                If (LGreaterEqual (LTMP, T1HL))
                {
                    Store (T0HL, HLMT)
                    Store (T0LL, LLMT)
                    Store (T0F1, F1PW)
                    Store (T0F2, F2PW)
                    Store (0x00, FANL)
                }
                Else
                {
                    If (LGreaterEqual (LTMP, T2HL))
                    {
                        Store (T1HL, HLMT)
                        Store (T1LL, LLMT)
                        Store (T1F1, F1PW)
                        Store (T1F2, F2PW)
                        Store (0x01, FANL)
                    }
                    Else
                    {
                        If (LGreaterEqual (LTMP, T3HL))
                        {
                            Store (T2HL, HLMT)
                            Store (T2LL, LLMT)
                            Store (T2F1, F1PW)
                            Store (T2F2, F2PW)
                            Store (0x02, FANL)
                        }
                        Else
                        {
                            If (LGreaterEqual (LTMP, T4HL))
                            {
                                Store (T3HL, HLMT)
                                Store (T3LL, LLMT)
                                Store (T3F1, F1PW)
                                Store (T3F2, F2PW)
                                Store (0x03, FANL)
                            }
                            Else
                            {
                                If (LGreaterEqual (LTMP, T5HL))
                                {
                                    Store (T4HL, HLMT)
                                    Store (T4LL, LLMT)
                                    Store (T4F1, F1PW)
                                    Store (T4F2, F2PW)
                                    Store (0x04, FANL)
                                }
                                Else
                                {
                                    If (LGreaterEqual (LTMP, T6HL))
                                    {
                                        Store (T5HL, HLMT)
                                        Store (T5LL, LLMT)
                                        Store (T5F1, F1PW)
                                        Store (T5F2, F2PW)
                                        Store (0x05, FANL)
                                    }
                                    Else
                                    {
                                        If (LGreaterEqual (LTMP, T7HL))
                                        {
                                            Store (T6HL, HLMT)
                                            Store (T6LL, LLMT)
                                            Store (T6F1, F1PW)
                                            Store (T6F2, F2PW)
                                            Store (0x06, FANL)
                                        }
                                        Else
                                        {
                                            Store (T7HL, HLMT)
                                            Store (T7LL, LLMT)
                                            Store (T7F1, F1PW)
                                            Store (T7F2, F2PW)
                                            Store (0x07, FANL)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            STML (HLMT, LLMT)
            FCTR (FANL, F1PW, F2PW)
            UMIT ()
        }

        Method (GTMP, 0, Serialized)
        {
            Store (RTMP (), Local0)
            If (And (\TDO1, 0x80))
            {
                Subtract (0x0100, \TDO1, Local1)
                Subtract (Local0, Local1, Local0)
            }
            Else
            {
                Add (Local0, \TDO1, Local0)
                If (LGreater (Local0, 0x7F))
                {
                    Store (0x7F, Local0)
                }
            }

            Store (Local0, LTMP)
            Return (Local0)
        }

        Method (STML, 2, Serialized)
        {
            Store (Arg0, Local1)
            Store (Arg1, Local2)
            If (And (\TDO1, 0x80))
            {
                Subtract (0x0100, \TDO1, Local3)
                Add (Arg0, Local3, Local1)
                If (LGreater (Local1, 0x7F))
                {
                    Store (0x7F, Local1)
                }

                Add (Arg1, Local3, Local2)
                If (LGreater (Local2, 0x7F))
                {
                    Store (0x7F, Local2)
                }
            }
            Else
            {
                Subtract (Arg0, \TDO1, Local1)
                Subtract (Arg1, \TDO1, Local2)
            }

            WTML (Local1, Local2)
        }
    }

    Scope (\)
    {
        Method (TZEV, 0, Serialized)
        {
            \_TZ.TCHG ()
            Notify (\_TZ.THRM, 0x80)
        }
    }

    Scope (\)
    {
        Name (FAN1, 0x00)
        Name (FAN2, 0x00)
        Device (FN00)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_PR0, Package (0x01)
            {
                GFAN
            })
        }

        PowerResource (GFAN, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Return (FAN1)
            }

            Method (_ON, 0, NotSerialized)
            {
                Store (0x01, FAN1)
            }

            Method (_OFF, 0, NotSerialized)
            {
                Store (0x00, FAN1)
            }
        }

        Name (\_SB.PCI0.SBRG._PR0, Package (0x01)
        {
            GFAN
        })
        Method (FANW, 1, NotSerialized)
        {
            Noop
        }

        Method (FANS, 1, NotSerialized)
        {
            If (Arg0)
            {
                \GFAN._OFF ()
            }
        }
    }

    Scope (\_TZ)
    {
        Method (TMSW, 1, NotSerialized)
        {
        }

        Method (TMSS, 1, NotSerialized)
        {
            If (Arg0)
            {
                RBYT (0x5C, 0x41)
                RBYT (0x5C, 0x42)
            }
        }

        Name (PPLY, 0x00)
        Name (MSK1, 0x00)
        Name (MSK2, 0x00)
        Method (MINT, 0, Serialized)
        {
            Store (RBYT (0x5C, 0x74), MSK1)
            Store (RBYT (0x5C, 0x75), MSK2)
            WBYT (0x5C, 0x74, 0xFD)
            WBYT (0x5C, 0x75, 0xFF)
        }

        Method (WTML, 2, Serialized)
        {
            Store (Arg0, Local1)
            Store (Arg1, Local2)
            WBYT (0x5C, 0x4F, Local1)
            WBYT (0x5C, 0x4E, Local2)
            Store (0xC8, Local0)
            While (Local0)
            {
                RBYT (0x5C, 0x42)
                Store (RBYT (0x5C, 0x41), Local1)
                And (Local1, 0x10, Local1)
                If (Local1)
                {
                    Stall (0x0A)
                    Decrement (Local0)
                }
                Else
                {
                    Store (Zero, Local0)
                }
            }

            RBYT (0x5C, 0x41)
            RBYT (0x5C, 0x42)
        }

        Method (UMIT, 0, Serialized)
        {
            WBYT (0x5C, 0x74, MSK1)
            WBYT (0x5C, 0x75, MSK2)
        }

        Method (RTMP, 0, NotSerialized)
        {
            Store (RBYT (0x5C, 0x25), Local0)
            If (Not (Local0))
            {
                If (LNotEqual (Local0, 0x80))
                {
                    Store (Local0, LTMP)
                }
            }

            Return (LTMP)
        }

        Method (RFAN, 0, NotSerialized)
        {
            Store (RBYT (0x5C, 0x28), Local0)
            Store (RBYT (0x5C, 0x29), Local1)
            ShiftLeft (Local1, 0x08, Local1)
            Add (Local1, Local0, Local0)
            If (LEqual (Local0, 0xFFFF))
            {
                Return (0x00)
            }
            Else
            {
                If (LLessEqual (Local0, 0xC8))
                {
                    Return (0xFE)
                }
            }

            Store (0x005265C0, Local2)
            Divide (Local2, Local0, Local3, Local4)
            Divide (Local4, 0x64, Local3, Local4)
            Return (Local4)
        }
    }

    Scope (\_SB)
    {
        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                Return (\GLID ())
            }
        }
    }

    Scope (\)
    {
        Method (LDEV, 0, Serialized)
        {
            \TLID ()
            Notify (\_SB.LID, 0x80)
        }
    }

    Scope (\)
    {
        Method (\DIAG, 1, NotSerialized)
        {
            Store (Arg0, DBG8)
        }

        OperationRegion (\GPSC, SystemIO, 0x0848, 0x02)
        Field (\GPSC, ByteAcc, NoLock, Preserve)
        {
            SMCM,   8, 
            SMST,   8
        }

        Method (\ISMI, 1, Serialized)
        {
            Store (Arg0, SMCM)
        }

        OperationRegion (\ECMS, SystemIO, 0x2000, 0x0100)
        Field (\ECMS, ByteAcc, Lock, Preserve)
        {
                    Offset (0x80), 
            IKFG,   8, 
            FRPN,   16, 
            RAMB,   32, 
            AVOL,   8, 
            LBTN,   8, 
            ERRF,   8, 
            OCLK,   8, 
            WIDE,   1, 
            OVCK,   2, 
            SLPN,   3, 
                    Offset (0x8C), 
            CPUR,   6, 
            CPUF,   2, 
            LBT2,   8, 
            PCMS,   8, 
            ALSL,   8, 
            ALAE,   1, 
            ALDE,   1, 
            ALSP,   1, 
                    Offset (0x91), 
            RER0,   144, 
            RESF,   1, 
                    Offset (0xA4), 
            RER1,   8, 
            WLEN,   1, 
            BTEN,   1
        }

        OperationRegion (RAMW, SystemMemory, RAMB, 0x0100)
        Field (RAMW, AnyAcc, NoLock, Preserve)
        {
            TRTY,   8, 
            FSFN,   8, 
            FSTA,   16, 
            FADR,   32, 
            FSIZ,   16, 
            ACTD,   8, 
            AVLD,   8, 
            SETD,   8, 
            ACPF,   8, 
            DCPF,   8, 
            DCP2,   8, 
            DCTP,   8, 
            CTPY,   8, 
            PADL,   16, 
            CADL,   16, 
            CSTE,   16, 
            NSTE,   16, 
            SSTE,   16, 
            SFUN,   8, 
            TPSV,   8, 
            TAC0,   8, 
            TCRT,   8, 
            TDO1,   8, 
            TDO2,   8, 
            PPSV,   8, 
            PAC0,   8, 
            T0HL,   8, 
            T0LL,   8, 
            T0F1,   8, 
            T0F2,   8, 
            T1HL,   8, 
            T1LL,   8, 
            T1F1,   8, 
            T1F2,   8, 
            T2HL,   8, 
            T2LL,   8, 
            T2F1,   8, 
            T2F2,   8, 
            T3HL,   8, 
            T3LL,   8, 
            T3F1,   8, 
            T3F2,   8, 
            T4HL,   8, 
            T4LL,   8, 
            T4F1,   8, 
            T4F2,   8, 
            T5HL,   8, 
            T5LL,   8, 
            T5F1,   8, 
            T5F2,   8, 
            T6HL,   8, 
            T6LL,   8, 
            T6F1,   8, 
            T6F2,   8, 
            T7HL,   8, 
            T7LL,   8, 
            T7F1,   8, 
            T7F2,   8, 
            SLPT,   8, 
            AIBF,   8, 
            IDES,   8, 
            VGAF,   16, 
            C4CP,   8, 
            LUXS,   8, 
            LUXL,   8, 
            LUXH,   8, 
            LUXF,   8, 
            MNAM,   64, 
            DBR1,   32, 
            DBR2,   32, 
            DBR3,   32, 
            DBR4,   32, 
            LCDV,   32, 
            LCDR,   8
        }

        OperationRegion (\DBGM, SystemMemory, 0x000D0000, 0x04)
        Field (\DBGM, DWordAcc, NoLock, Preserve)
        {
            DBGG,   32
        }

        Name (OSFG, 0x00)
        Name (OS9X, 0x01)
        Name (OS98, 0x02)
        Name (OSME, 0x04)
        Name (OS2K, 0x08)
        Name (OSXP, 0x10)
        Name (OSVT, 0x20)
        Method (MSOS, 0, NotSerialized)
        {
            If (CondRefOf (\_OSI, Local0))
            {
                If (\_OSI ("Windows 2001"))
                {
                    Store (OSXP, OSFG)
                }

                If (\_OSI ("Windows 2001 SP1"))
                {
                    Store (OSXP, OSFG)
                }

                If (\_OSI ("Windows 2001 SP2"))
                {
                    Store (OSXP, OSFG)
                }

                If (\_OSI ("Windows 2006"))
                {
                    Store (OSVT, OSFG)
                }

                Return (OSFG)
            }
            Else
            {
                If (MCTH (\_OS, "Microsoft Windows"))
                {
                    Store (OS98, OSFG)
                }
                Else
                {
                    If (MCTH (\_OS, "Microsoft WindowsME: Millennium Edition"))
                    {
                        Store (OSME, OSFG)
                    }
                    Else
                    {
                        If (MCTH (\_OS, "Microsoft Windows NT"))
                        {
                            Store (OS2K, OSFG)
                        }
                        Else
                        {
                            Store (OSXP, OSFG)
                        }
                    }
                }
            }

            Return (OSFG)
        }

        Method (\DBGR, 4, NotSerialized)
        {
            Store (Arg0, DBR1)
            Store (Arg1, DBR2)
            Store (Arg2, DBR3)
            Store (Arg3, DBR4)
            \ISMI (0x96)
        }

        Name (ONAM, "ASUSTEK")
        Method (ADVG, 0, NotSerialized)
        {
            If (\_SB.PCI0.P0P1.VGA.PRST ())
            {
                Return (\_SB.PCI0.P0P1.VGA.ADVD ())
            }

            Return (0x03)
        }

        Method (SWHG, 1, Serialized)
        {
            If (\_SB.PCI0.P0P1.VGA.PRST ())
            {
                \_SB.PCI0.P0P1.VGA.SWHD (Arg0)
                Return (One)
            }

            Return (Zero)
        }

        Method (NATK, 0, NotSerialized)
        {
            If (\_SB.PCI0.P0P1.VGA.PRST ())
            {
                Return (\_SB.PCI0.P0P1.VGA.NATK ())
            }

            Return (One)
        }

        Name (PWAC, Buffer (0x10)
        {
            /* 0000 */    0x17, 0x2E, 0x3D, 0x49, 0x58, 0x60, 0x64, 0x68, 
            /* 0008 */    0x6C, 0x70, 0x73, 0x77, 0x7B, 0x7F, 0x83, 0x88
        })
        Name (PWDC, Buffer (0x10)
        {
            /* 0000 */    0x0F, 0x26, 0x36, 0x41, 0x51, 0x58, 0x5C, 0x60, 
            /* 0008 */    0x64, 0x68, 0x6C, 0x70, 0x73, 0x77, 0x7B, 0x7F
        })
    }

    Scope (\_SB.PCI0)
    {
        Method (_INI, 0, NotSerialized)
        {
            \MSOS ()
        }
    }

    Scope (\_SB.PCI0)
    {
        Device (AC0)
        {
            Name (_HID, "ACPI0003")
            Method (_PSR, 0, NotSerialized)
            {
                Return (\ACPF)
            }

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

    Scope (\)
    {
        Name (ACWA, 0x00)
        Method (ACEV, 0, NotSerialized)
        {
            If (\ACPS ())
            {
                Store (0x02, ACWA)
                Store (One, \ACPF)
                Store (0x58, Local0)
            }
            Else
            {
                Store (Zero, \ACPF)
                Store (0x57, Local0)
            }

            If (LEqual (And (\_SB.PCI0.P0P1.VGA.ODSF, 0x04), 0x00))
            {
                \_SB.PCI0.SBRG.EC0.STBR ()
            }

            Notify (\_SB.PCI0.AC0, 0x80)
            If (\_SB.ATKP)
            {
                Notify (\_SB.ATKD, Local0)
            }

            Sleep (0x64)
            \TGAC ()
            Notify (\_PR.CPU1, 0x80)
            Notify (\_PR.CPU1, 0x81)
            Sleep (0x0A)
            NBAT (0x80)
        }
    }

    Scope (\_SB.PCI0)
    {
        Device (BAT0)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x00)
            Name (_PCL, Package (0x01)
            {
                \_SB.PCI0
            })
            Method (_STA, 0, NotSerialized)
            {
                If (BATP (0x00))
                {
                    Return (0x1F)
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Name (LOW2, 0x012C)
            Name (DVOT, 0x0E)
            Name (PUNT, One)
            Name (LFCC, 0x1770)
            Name (NBIF, Package (0x0D)
            {
                0x00, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0x01, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                "", 
                "", 
                "", 
                ""
            })
            Name (PBIF, Package (0x0D)
            {
                0x01, 
                0x1770, 
                0x1770, 
                0x01, 
                0x39D0, 
                0x0258, 
                0x012C, 
                0x3C, 
                0x3C, 
                "M3N", 
                " ", 
                "LIon", 
                "ASUSTek"
            })
            Name (PBST, Package (0x04)
            {
                0x00, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0xFFFFFFFF
            })
            Method (FBIF, 5, NotSerialized)
            {
                Store (Arg0, PUNT)
                Store (Arg1, Local1)
                Store (Arg2, Local2)
                If (LEqual (PUNT, 0x00))
                {
                    Multiply (Local1, 0x0A, Local1)
                    Multiply (Local2, 0x0A, Local2)
                }

                Store (Arg0, Index (PBIF, 0x00))
                Store (Local1, Index (PBIF, 0x01))
                Store (Local2, Index (PBIF, 0x02))
                Store (Local2, LFCC)
                Store (Arg3, Index (PBIF, 0x03))
                Store (Arg4, Index (PBIF, 0x04))
                Divide (Local1, 0x0A, Local3, Local5)
                Store (Local5, Index (PBIF, 0x05))
                ShiftRight (Local5, 0x01, Local6)
                Store (Local6, Index (PBIF, 0x06))
                Store (Local6, LOW2)
                Divide (Local1, 0x64, Local3, Local7)
                Store (Local7, Index (PBIF, 0x07))
                Store (Local7, Index (PBIF, 0x08))
            }

            Method (CBIF, 0, NotSerialized)
            {
                If (PUNT)
                {
                    Store (DerefOf (Index (PBIF, 0x04)), Local0)
                    Add (Local0, 0x01F4, Local0)
                    Divide (Local0, 0x03E8, Local1, DVOT)
                    Store (Zero, Index (PBIF, 0x00))
                    Multiply (DerefOf (Index (PBIF, 0x01)), DVOT, Index (PBIF, 0x01
                        ))
                    Multiply (DerefOf (Index (PBIF, 0x02)), DVOT, Index (PBIF, 0x02
                        ))
                    Multiply (DerefOf (Index (PBIF, 0x05)), DVOT, Index (PBIF, 0x05
                        ))
                    Multiply (DerefOf (Index (PBIF, 0x06)), DVOT, Index (PBIF, 0x06
                        ))
                    Multiply (DerefOf (Index (PBIF, 0x07)), DVOT, Index (PBIF, 0x07
                        ))
                    Multiply (DerefOf (Index (PBIF, 0x08)), DVOT, Index (PBIF, 0x08
                        ))
                }
            }

            Method (_BIF, 0, NotSerialized)
            {
                If (LNot (BATP (0x00)))
                {
                    Return (NBIF)
                }

                Acquire (MMPX, 0xFFFF)
                \BATS (0x00)
                Store (\_SB.PCI0.SBRG.EC0.BIF9 (), Index (PBIF, 0x09))
                Store (\ONAM, Index (PBIF, 0x0C))
                Store (\_SB.PCI0.SBRG.EC0.BIF0 (), Local0)
                Store (\_SB.PCI0.SBRG.EC0.BIF1 (), Local1)
                Store (\_SB.PCI0.SBRG.EC0.BIF2 (), Local2)
                Store (\_SB.PCI0.SBRG.EC0.BIF3 (), Local3)
                Store (\_SB.PCI0.SBRG.EC0.BIF4 (), Local4)
                Release (MMPX)
                If (LNotEqual (Local0, Ones))
                {
                    If (LNotEqual (Local1, Ones))
                    {
                        If (LNotEqual (Local2, Ones))
                        {
                            If (LNotEqual (Local3, Ones))
                            {
                                If (LNotEqual (Local4, Ones))
                                {
                                    FBIF (Local0, Local1, Local2, Local3, Local4)
                                    CBIF ()
                                }
                            }
                        }
                    }
                }

                If (LEqual (PUNT, 0x00))
                {
                    Multiply (Local2, 0x0A, Local2)
                }

                Store (Local2, LFCC)
                Return (PBIF)
            }

            Method (FBST, 4, NotSerialized)
            {
                And (Arg1, 0xFFFF, Local1)
                If (\ACPF)
                {
                    Store (One, Local0)
                    If (Local0)
                    {
                        Store (CHGS (0x00), Local2)
                        If (LEqual (Local2, 0xFFFF))
                        {
                            If (LGreater (Local1, 0xA0))
                            {
                                Store (0x02, Local0)
                            }
                            Else
                            {
                                Store (Zero, Local0)
                            }
                        }
                        Else
                        {
                            If (Local2)
                            {
                                Store (0x02, Local0)
                            }
                            Else
                            {
                                Store (Zero, Local0)
                            }
                        }
                    }
                    Else
                    {
                        Store (0x01, Local0)
                    }
                }
                Else
                {
                    Store (0x01, Local0)
                }

                If (And (Arg0, 0x0300))
                {
                    Or (Local0, 0x04, Local0)
                }

                If (LGreaterEqual (Local1, 0x8000))
                {
                    And (Subtract (0x00, Local1), 0xFFFF, Local1)
                }

                Store (Arg2, Local2)
                If (LEqual (PUNT, 0x00))
                {
                    Multiply (Local1, DVOT, Local1)
                    Multiply (Local2, 0x0A, Local2)
                }

                And (Local0, 0x02, Local3)
                Divide (LFCC, 0xC8, Local4, Local5)
                If (LEqual (Local3, 0x00))
                {
                    Subtract (LFCC, Local2, Local3)
                    If (LLess (Local3, Local5))
                    {
                        Store (LFCC, Local2)
                    }
                }
                Else
                {
                    If (LGreaterEqual (Local2, LFCC))
                    {
                        Subtract (LFCC, Local5, Local2)
                    }
                }

                If (And (Local0, 0x01))
                {
                    Divide (Local2, \MBLF, Local3, Local4)
                    If (LLess (Local1, Local4))
                    {
                        Store (Local4, Local1)
                    }
                }

                Store (Local0, Index (PBST, 0x00))
                Store (Local1, Index (PBST, 0x01))
                Store (Local2, Index (PBST, 0x02))
                Store (Arg3, Index (PBST, 0x03))
            }

            Method (CBST, 0, NotSerialized)
            {
                If (PUNT)
                {
                    Multiply (DerefOf (Index (PBST, 0x01)), DVOT, Index (PBST, 0x01
                        ))
                    Multiply (DerefOf (Index (PBST, 0x02)), DVOT, Index (PBST, 0x02
                        ))
                }
            }

            Method (_BST, 0, NotSerialized)
            {
                If (LNot (BATP (0x00)))
                {
                    Store (Zero, Index (PBST, 0x00))
                    Store (Ones, Index (PBST, 0x01))
                    Store (Ones, Index (PBST, 0x02))
                    Store (Ones, Index (PBST, 0x03))
                    Return (PBST)
                }

                If (\MES4)
                {
                    Decrement (\MES4)
                    Return (PBST)
                }

                Acquire (MMPX, 0xFFFF)
                \BATS (0x00)
                Store (\_SB.PCI0.SBRG.EC0.BSTS (), Local0)
                If (ACWA)
                {
                    Store (0x02, Local0)
                    Decrement (ACWA)
                }

                Store (\_SB.PCI0.SBRG.EC0.BCRT (), Local1)
                Store (\_SB.PCI0.SBRG.EC0.BRCP (), Local2)
                Store (\_SB.PCI0.SBRG.EC0.BVOT (), Local3)
                Release (MMPX)
                If (LNotEqual (Local0, Ones))
                {
                    If (LNotEqual (Local1, Ones))
                    {
                        If (LNotEqual (Local2, Ones))
                        {
                            If (LNotEqual (Local3, Ones))
                            {
                                FBST (Local0, Local1, Local2, Local3)
                                CBST ()
                            }
                        }
                    }
                }

                Return (PBST)
            }
        }

        Name (B0CR, 0x00)
        Name (B1CR, 0x00)
        Method (GGCC, 1, Serialized)
        {
            Acquire (MMPX, 0xFFFF)
            \BATS (Arg0)
            Store (\_SB.PCI0.SBRG.EC0.BCRT (), Local0)
            Release (MMPX)
            If (LEqual (Local0, Ones))
            {
                If (Arg0)
                {
                    Store (B1CR, Local0)
                }
                Else
                {
                    Store (B0CR, Local0)
                }
            }

            And (Local0, 0x8000, Local1)
            If (Local1)
            {
                Store (0x00, Local0)
            }

            If (Arg0)
            {
                Store (Local0, B1CR)
            }
            Else
            {
                Store (Local0, B0CR)
            }

            Return (Local0)
        }
    }

    Scope (\_SB.PCI0.SBRG.EC0)
    {
        Name (BADR, 0x0B)
        Name (CADR, 0x09)
        Name (SADR, 0x0A)
        Method (ALMH, 1, NotSerialized)
        {
            If (LEqual (Arg0, BADR))
            {
                NBAT (0x80)
            }
        }

        Method (BIFW, 1, NotSerialized)
        {
            Store (SMBR (RDWD, BADR, Arg0), Local0)
            Store (DerefOf (Index (Local0, 0x00)), Local1)
            If (Local1)
            {
                Return (Ones)
            }
            Else
            {
                Return (DerefOf (Index (Local0, 0x02)))
            }
        }

        Method (BIF0, 0, NotSerialized)
        {
            Store (One, Local1)
            Store (One, Local2)
            While (And (LNotEqual (Local1, 0x00), LLessEqual (Local2, 0x03)
                ))
            {
                Store (SMBR (RDWD, BADR, 0x03), Local0)
                Store (DerefOf (Index (Local0, 0x00)), Local1)
                Increment (Local2)
            }

            If (Local1)
            {
                Return (Ones)
            }
            Else
            {
                Store (DerefOf (Index (Local0, 0x02)), Local2)
                ShiftRight (Local2, 0x0F, Local2)
                And (Local2, 0x01, Local2)
                XOr (Local2, 0x01, Local2)
                Return (Local2)
            }
        }

        Method (BIF1, 0, NotSerialized)
        {
            Store (Ones, Local1)
            Store (One, Local0)
            While (And (LEqual (Local1, Ones), LLessEqual (Local0, 0x03)))
            {
                Store (BIFW (0x18), Local1)
                Increment (Local0)
            }

            Return (Local1)
        }

        Method (BIF2, 0, NotSerialized)
        {
            Store (Ones, Local1)
            Store (One, Local0)
            While (And (LEqual (Local1, Ones), LLessEqual (Local0, 0x03)))
            {
                Store (BIFW (0x10), Local1)
                Increment (Local0)
            }

            Return (Local1)
        }

        Method (BIF3, 0, NotSerialized)
        {
            Store (Ones, Local1)
            Store (One, Local0)
            While (And (LEqual (Local1, Ones), LLessEqual (Local0, 0x03)))
            {
                Store (BIFW (0x03), Local1)
                Increment (Local0)
            }

            If (LNotEqual (Local1, Ones))
            {
                ShiftRight (Local1, 0x09, Local1)
                And (Local1, 0x01, Local1)
                XOr (Local1, 0x01, Local1)
            }

            Return (Local1)
        }

        Method (BIF4, 0, NotSerialized)
        {
            Store (Ones, Local1)
            Store (One, Local0)
            While (And (LEqual (Local1, Ones), LLessEqual (Local0, 0x03)))
            {
                Store (BIFW (0x19), Local1)
                Increment (Local0)
            }

            Return (Local1)
        }

        Method (BIF9, 0, NotSerialized)
        {
            Name (BSTR, Buffer (0x20) {})
            Store (SMBR (RDBL, BADR, 0x21), Local0)
            If (LNotEqual (DerefOf (Index (Local0, 0x00)), 0x00))
            {
                Store (0x00, Index (BSTR, 0x00))
            }
            Else
            {
                Store (DerefOf (Index (Local0, 0x02)), BSTR)
                Store (0x00, Index (BSTR, DerefOf (Index (Local0, 0x01))))
            }

            Return (BSTR)
        }

        Method (BSTS, 0, NotSerialized)
        {
            Return (BIFW (0x16))
        }

        Method (BCRT, 0, NotSerialized)
        {
            Return (BIFW (0x0A))
        }

        Method (BRCP, 0, NotSerialized)
        {
            Return (BIFW (0x0F))
        }

        Method (BVOT, 0, NotSerialized)
        {
            Return (BIFW (0x09))
        }
    }

    Scope (\)
    {
        Mutex (MMPX, 0x00)
        Method (BATP, 1, Serialized)
        {
            If (Arg0)
            {
                Return (\DCP2)
            }
            Else
            {
                Return (\DCPF)
            }
        }

        Method (BTEV, 0, Serialized)
        {
            Store (\DCPS (0x00), \DCPF)
            \TGDC (0x00)
            Notify (\_SB.PCI0.BAT0, 0x81)
            Notify (\_SB.PCI0.AC0, 0x80)
        }

        Method (NBAT, 1, NotSerialized)
        {
            If (BATP (0x00))
            {
                Notify (\_SB.PCI0.BAT0, Arg0)
            }
        }

        Method (BTCF, 0, Serialized)
        {
            Notify (\_SB.PCI0.BAT0, 0x81)
            Notify (\_SB.PCI0.AC0, 0x80)
        }

        Method (BLEV, 0, NotSerialized)
        {
            If (\_SB.ATKP)
            {
                Notify (\_SB.ATKD, 0x6E)
            }
            Else
            {
                If (BATP (0x00))
                {
                    Notify (\_SB.PCI0.BAT0, 0x80)
                }
            }
        }
    }

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

    Scope (\)
    {
        Name (MES4, Zero)
        Method (OEMS, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x03))
            {
                If (LLessEqual (\OSFG, \OSME))
                {
                    Store (One, \WIDE)
                }
                Else
                {
                    Store (Zero, \WIDE)
                }
            }

            SBRS (Arg0)
            \_SB.PCI0.SBRG.EC0.EC0S (Arg0)
            If (LEqual (Arg0, 0x04))
            {
                If (LEqual (OSFG, OS2K))
                {
                    Store (Arg0, SLPN)
                }
            }

            Add (Arg0, 0xD0, DBG8)
            Store (Arg0, SLPT)
            If (Arg0)
            {
                STRP (0x01)
            }

            PRJS (Arg0)
            ISMI (0x9D)
        }

        Method (OEMW, 1, NotSerialized)
        {
            Store (Zero, SLPT)
            \_SB.PCI0.SBRG.EC0.EC0W (Arg0)
            If (LEqual (Arg0, 0x04))
            {
                If (LLessEqual (\OSFG, \OSME))
                {
                    Store (0x02, MES4)
                }
                Else
                {
                    Store (Zero, MES4)
                }
            }

            \_SB.PCI0.CBS0.CBSW (Arg0)
            SBRW (Arg0)
            If (LEqual (Arg0, 0x04))
            {
                Notify (\_SB.SLPB, 0x02)
            }

            PRJW (Arg0)
            Add (Arg0, 0xF0, DBG8)
            ISMI (0x9E)
        }
    }

    Scope (\_SB.ATKD)
    {
        Method (FSMI, 1, NotSerialized)
        {
            Store (Arg0, \FSFN)
            Or (Arg0, 0xA0, Local0)
            Store (Local0, \DBG8)
            ISMI (0x90)
            Return (\FSTA)
        }

        Method (FLSH, 1, NotSerialized)
        {
            Store (Arg0, \FSTA)
            FSMI (0x00)
        }

        Method (FINI, 1, NotSerialized)
        {
            Store (Arg0, \FADR)
            Return (FSMI (0x01))
        }

        Method (FERS, 1, NotSerialized)
        {
            Store (Arg0, \FSTA)
            Return (FSMI (0x02))
        }

        Method (FWRI, 1, NotSerialized)
        {
            Store (Arg0, \FADR)
            Store (0x1000, \FSIZ)
            Return (Subtract (0x1000, FSMI (0x03)))
        }

        Method (FWRP, 0, NotSerialized)
        {
            Store (0x00, \FSIZ)
            Return (Subtract (0x1000, FSMI (0x03)))
        }

        Method (FEBW, 1, NotSerialized)
        {
            Store (Arg0, \FADR)
            Return (FSMI (0x04))
        }

        Method (FEBR, 1, NotSerialized)
        {
            Store (Arg0, \FADR)
            Return (FSMI (0x05))
        }

        Method (FEDW, 0, NotSerialized)
        {
            Return (FSMI (0x06))
        }
    }

    Scope (\)
    {
        Method (ACPS, 0, Serialized)
        {
            Store (\_SB.PCI0.SBRG.EC0.RPIN (0x64), Local0)
            XOr (Local0, 0x01, Local0)
            Return (Local0)
        }

        Method (CHGS, 1, Serialized)
        {
            Store (\_SB.PCI0.SBRG.EC0.RPIN (0x43), Local0)
            XOr (Local0, 0x01, Local0)
            Return (Local0)
        }

        Method (DCPS, 1, Serialized)
        {
            Store (\_SB.PCI0.SBRG.EC0.RPIN (0x55), Local0)
            XOr (Local0, 0x01, Local0)
            Return (Local0)
        }

        Method (BATS, 1, Serialized)
        {
        }

        Name (LCDB, 0x00)
        Method (PRJS, 1, Serialized)
        {
            If (LLessEqual (Arg0, 0x03))
            {
                Store (\RGPL (0x07, 0x01), LCDB)
                \SGPL (0x07, 0x01, 0x00)
            }

            Store (Arg0, SLPN)
        }

        Method (PRJW, 1, Serialized)
        {
            If (LLessEqual (Arg0, 0x03))
            {
                \SGPL (0x07, 0x01, LCDB)
            }
        }

        Method (GLID, 0, Serialized)
        {
            Return (\_SB.PCI0.SBRG.EC0.RPIN (0x54))
        }

        Method (TLID, 0, Serialized)
        {
        }

        Method (TGAC, 0, Serialized)
        {
        }

        Method (TGDC, 1, Serialized)
        {
        }

        Method (FCTR, 3, Serialized)
        {
            If (LEqual (Arg0, 0x04))
            {
                WBYT (0x5C, 0x5C, 0xE2)
                WBYT (0x5C, 0x30, 0x73)
            }

            If (LEqual (Arg0, 0x05))
            {
                WBYT (0x5C, 0x5C, 0xE2)
                WBYT (0x5C, 0x30, 0x00)
            }
        }

        Method (FFCT, 0, Serialized)
        {
            WBYT (0x5C, 0x5C, 0xE2)
            WBYT (0x5C, 0x30, 0x73)
            Store (0x64, T4HL)
            Subtract (TAC0, 0x05, Local0)
            Store (Local0, T4LL)
            Store (TAC0, T5HL)
            Store (0x00, T5LL)
        }

        Method (AFEN, 0, Serialized)
        {
            Store (0x00, T4HL)
            Store (0x00, T4LL)
            Store (0x00, T5HL)
            Store (0x00, T5LL)
            WBYT (0x5C, 0x5C, 0xC2)
        }

        Method (OMLD, 1, Serialized)
        {
            \_SB.PCI0.SBRG.EC0.SPIN (0x41, Arg0)
        }

        Method (OWLD, 1, Serialized)
        {
            Store (\RGPL (0x0F, 0x01), Local0)
            If (LEqual (Local0, 0x01))
            {
                Return (0x00)
            }

            XOr (Arg0, 0x01, Arg0)
            \SGPL (0x10, 0x01, Arg0)
	    Return (0x01)
        }

        Method (OBTD, 1, Serialized)
        {
            \SGPL (0x0F, 0x01, Arg0)
            XOr (Arg0, 0x01, Arg0)
            \SGPL (0x10, 0x01, Arg0)
        }

        Method (GBTL, 0, Serialized)
        {
            Return (\_SB.PCI0.SBRG.EC0.RPIN (0x22))
        }

        Method (SBTL, 1, Serialized)
        {
            \_SB.PCI0.SBRG.EC0.SPIN (0x22, Arg0)
        }

        Method (BL2C, 0, NotSerialized)
        {
            If (LNot (\_SB.PCI0.SBRG.EC0.RPIN (0x50)))
            {
                Store (0x01, Local1)
            }

            Return (Local1)
        }

        Method (OPID, 0, Serialized)
        {
            Store (RIOP (0x2C, 0x03), Local0)
            Store (DerefOf (Index (RESN, Local0)), Local1)
            Return (Local1)
        }

        Name (RESN, Package (0x10)
        {
            0x00, 
            0x00, 
            0x00, 
            0x00, 
            0x00, 
            0x00, 
            0x00, 
            0x08, 
            0x00, 
            0x00, 
            0x00, 
            0x05, 
            0x00, 
            0x03, 
            0x0A, 
            0x00
        })
        Method (STCF, 1, Serialized)
        {
            If (LEqual (Arg0, 0x01))
            {
                \_SB.PCI0.SBRG.EC0.FNCT (0x84, 0x00)
            }
        }
    }

    Scope (\_GPE)
    {
        Method (_L00, 0, NotSerialized)
        {
            TZEV ()
        }

        Method (_L13, 0, NotSerialized)
        {
        }
    }

    Scope (\_SB.PCI0.SBRG.EC0)
    {
        Method (_Q34, 0, NotSerialized)
        {
            ACEV ()
        }

        Method (_Q2F, 0, NotSerialized)
        {
            BTEV ()
        }

        Method (_Q2E, 0, NotSerialized)
        {
            LDEV ()
        }

        Method (_Q50, 0, NotSerialized)
        {
            BLEV ()
        }
    }

    Scope (\_SB.PCI0.USB)
    {
        Method (_INI, 0, NotSerialized)
        {
            If (LLess (OSFG, 0x08))
            {
                USB1 ()
            }
        }
    }

    Scope (\_SB.PCI0.USB2)
    {
        Method (_INI, 0, NotSerialized)
        {
            If (LLess (OSFG, 0x08))
            {
                USB1 ()
            }
        }
    }

    Scope (\_SB.PCI0.USB3)
    {
        Method (_INI, 0, NotSerialized)
        {
            If (LLess (OSFG, 0x08))
            {
                USB1 ()
            }
        }
    }

    Scope (\_SB)
    {
        Scope (PCI0)
        {
            Name (CRS, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x00FF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0100,             // Length
                    ,, )
                IO (Decode16,
                    0x0CF8,             // Range Minimum
                    0x0CF8,             // Range Maximum
                    0x01,               // Alignment
                    0x08,               // Length
                    )
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x0CF7,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0CF8,             // Length
                    ,, , TypeStatic)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Granularity
                    0x0D00,             // Range Minimum
                    0xFFFF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0xF300,             // Length
                    ,, , TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000A0000,         // Range Minimum
                    0x000BFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00020000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C0000,         // Range Minimum
                    0x000DFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00020000,         // Length
                    ,, _Y15, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0x00000000,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    ,, _Y16, AddressRangeMemory, TypeStatic)
            })
            CreateDWordField (CRS, \_SB.PCI0._Y15._MIN, MIN5)
            CreateDWordField (CRS, \_SB.PCI0._Y15._MAX, MAX5)
            CreateDWordField (CRS, \_SB.PCI0._Y15._LEN, LEN5)
            CreateDWordField (CRS, \_SB.PCI0._Y16._MIN, MIN6)
            CreateDWordField (CRS, \_SB.PCI0._Y16._MAX, MAX6)
            CreateDWordField (CRS, \_SB.PCI0._Y16._LEN, LEN6)
            Method (_CRS, 0, NotSerialized)
            {
                Store (MG1L, Local0)
                If (Local0)
                {
                    Store (MG1B, MIN5)
                    Store (MG1L, LEN5)
                    Add (MIN5, Decrement (Local0), MAX5)
                }

                Store (MG2B, MIN6)
                Store (MG2L, LEN6)
                Store (MG2L, Local0)
                Add (MIN6, Decrement (Local0), MAX6)
                Return (CRS)
            }
        }
    }

    Name (WOTB, 0x00)
    Name (WSSB, 0x00)
    Name (WAXB, 0x00)
    Method (_PTS, 1, NotSerialized)
    {
        Store (Arg0, DBG8)
        PTS (Arg0)
        Store (0x00, Index (WAKP, 0x00))
        Store (0x00, Index (WAKP, 0x01))
        If (LAnd (LEqual (Arg0, 0x04), LEqual (OSFL (), 0x02)))
        {
            Sleep (0x0BB8)
        }

        Store (ASSB, WSSB)
        Store (AOTB, WOTB)
        Store (AAXB, WAXB)
        Store (Arg0, ASSB)
        Store (OSFL (), AOTB)
        Store (Zero, AAXB)
    }

    Method (_WAK, 1, NotSerialized)
    {
        ShiftLeft (Arg0, 0x04, DBG8)
        WAK (Arg0)
        If (ASSB)
        {
            Store (WSSB, ASSB)
            Store (WOTB, AOTB)
            Store (WAXB, AAXB)
        }

        If (DerefOf (Index (WAKP, 0x00)))
        {
            Store (0x00, Index (WAKP, 0x01))
        }
        Else
        {
            Store (Arg0, Index (WAKP, 0x01))
        }

        Return (WAKP)
    }

    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    If (SS1)
    {
        Name (\_S1, Package (0x04)
        {
            0x01, 
            0x00, 
            0x00, 
            0x00
        })
    }

    If (SS3)
    {
        Name (\_S3, Package (0x04)
        {
            0x03, 
            0x00, 
            0x00, 
            0x00
        })
    }

    If (SS4)
    {
        Name (\_S4, Package (0x04)
        {
            0x04, 
            0x00, 
            0x00, 
            0x00
        })
    }

    Name (\_S5, Package (0x04)
    {
        0x05, 
        0x00, 
        0x00, 
        0x00
    })
    Method (PTS, 1, NotSerialized)
    {
        If (Arg0)
        {
            \_SB.PCI0.NPTS (Arg0)
            \_SB.PCI0.SBRG.SPTS (Arg0)
            \_TZ.TRMS (Arg0)
            \OEMS (Arg0)
        }
    }

    Method (WAK, 1, NotSerialized)
    {
        \_SB.PCI0.NWAK (Arg0)
        \_SB.PCI0.SBRG.SWAK (Arg0)
        \_TZ.TRMW (Arg0)
        \OEMW (Arg0)
    }
}