/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20100528
 *
 * Disassembly of DSDT.dat, Sun Nov  4 00:20:39 2012
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x0001AC19 (109593)
 *     Revision         0x01 **** ACPI 1.0, no 64-bit math support
 *     Checksum         0x89
 *     OEM ID           "TOSASU"
 *     OEM Table ID     "TOSASU00"
 *     OEM Revision     0xF0000000 (4026531840)
 *     Compiler ID      "ACPI"
 *     Compiler Version 0x00040000 (262144)
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "TOSASU", "TOSASU00", 0xF0000000)
{
    External (ALIB, MethodObj)    // 2 Arguments
    External (\_SB_.AWAK, MethodObj)    // 1 Arguments
    External (\_SB_.APTS, MethodObj)    // 1 Arguments
    External (\_SB_.ALIB, MethodObj)    // 2 Arguments
    External (\_PR_.C003.PPCV)
    External (\_PR_.C002.PPCV)
    External (\_PR_.C001.PPCV)
    External (\_PR_.C000.PPCV)

    OperationRegion (DBG0, SystemIO, 0x80, One)
    Field (DBG0, ByteAcc, NoLock, Preserve)
    {
        IO80,   8
    }

    OperationRegion (DBG1, SystemIO, 0x80, 0x02)
    Field (DBG1, WordAcc, NoLock, Preserve)
    {
        P80H,   16
    }

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

    IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
    {
                Offset (0x83), 
        RTCD,   8, 
        RTCH,   8, 
        RTCM,   8, 
        RTSS,   8, 
        STRT,   16, 
        STPT,   16, 
        PBT4,   8, 
                Offset (0xE3), 
        LDSZ,   8, 
        RTCE,   8
    }

    OperationRegion (PSMI, SystemIO, 0xB0, 0x02)
    Field (PSMI, ByteAcc, NoLock, Preserve)
    {
        APMC,   8, 
        APMD,   8
    }

    OperationRegion (PMRG, SystemIO, 0x0CD6, 0x02)
    Field (PMRG, ByteAcc, NoLock, Preserve)
    {
        PMRI,   8, 
        PMRD,   8
    }

    IndexField (PMRI, PMRD, ByteAcc, NoLock, Preserve)
    {
                Offset (0x24), 
        MMSO,   32, 
                Offset (0x50), 
        HPAD,   32, 
                Offset (0x60), 
        P1EB,   16, 
                Offset (0xC8), 
            ,   2, 
        SPRE,   1, 
        TPDE,   1, 
                Offset (0xF0), 
            ,   3, 
        RSTU,   1
    }

    OperationRegion (GSMM, SystemMemory, MMSO, 0x1000)
    Field (GSMM, AnyAcc, NoLock, Preserve)
    {
                Offset (0x132), 
            ,   7, 
        GP51,   1, 
                Offset (0x136), 
            ,   7, 
        GP55,   1, 
                Offset (0x13A), 
            ,   7, 
        GP59,   1, 
                Offset (0x13F), 
            ,   7, 
        GP64,   1, 
                Offset (0x160), 
            ,   7, 
        GE01,   1, 
                Offset (0x16A), 
            ,   7, 
        GE11,   1, 
            ,   7, 
        GE12,   1, 
                Offset (0x16E), 
            ,   7, 
        BATS,   1, 
                Offset (0x1FF), 
            ,   1, 
        G01S,   1, 
                Offset (0x203), 
            ,   1, 
        G01E,   1, 
                Offset (0x207), 
            ,   1, 
        TR01,   1, 
                Offset (0x20B), 
            ,   1, 
        TL01,   1, 
                Offset (0x20D), 
            ,   7, 
        ACIR,   1, 
                Offset (0x287), 
            ,   1, 
        CLPS,   1, 
                Offset (0x298), 
            ,   7, 
        G15A,   1, 
                Offset (0x2AF), 
            ,   2, 
        SLPS,   2, 
                Offset (0x376), 
        EPNM,   1, 
        DPPF,   1, 
                Offset (0x3BA), 
            ,   6, 
        PWDE,   1, 
                Offset (0x3BD), 
            ,   5, 
        ALLS,   1, 
                Offset (0x3DE), 
        BLNK,   2, 
                Offset (0x3EF), 
        PHYD,   1, 
                Offset (0xE80), 
            ,   2, 
        ECES,   1
    }

    OperationRegion (P1E0, SystemIO, P1EB, 0x04)
    Field (P1E0, ByteAcc, NoLock, Preserve)
    {
            ,   14, 
        PEWS,   1, 
        WSTA,   1, 
            ,   14, 
        PEWD,   1
    }

    OperationRegion (IOCC, SystemIO, 0x0400, 0x80)
    Field (IOCC, ByteAcc, NoLock, Preserve)
    {
                Offset (0x01), 
            ,   2, 
        RTCS,   1
    }

    Name (PRWP, Package (0x02)
    {
        Zero, 
        Zero
    })
    Method (GPRW, 2, NotSerialized)
    {
        Store (Arg0, Index (PRWP, Zero))
        Store (Arg1, Index (PRWP, One))
        If (LAnd (LEqual (DAS3, Zero), LEqual (DAS1, Zero)))
        {
            If (LLessEqual (Arg1, 0x03))
            {
                Store (Zero, Index (PRWP, One))
            }
        }
        Else
        {
            If (LAnd (LEqual (DAS3, Zero), LEqual (Arg1, 0x03)))
            {
                Store (One, Index (PRWP, One))
            }

            If (LAnd (LEqual (DAS1, Zero), LEqual (Arg1, One)))
            {
                Store (Zero, Index (PRWP, One))
            }
        }

        Return (PRWP)
    }

    Method (SPTS, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x03))
        {
            Store (Zero, RSTU)
        }

        Store (One, CLPS)
        Store (One, SLPS)
        Store (PEWS, PEWS)
    }

    Method (SWAK, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x03))
        {
            Store (One, RSTU)
        }

        Store (PEWS, PEWS)
        Store (One, PWDE)
        Store (Zero, PEWD)
    }

    Method (CHKH, 0, NotSerialized)
    {
        If (\_SB.PCI0.SMBS.GE05)
        {
            Store (Zero, \_SB.PCI0.SMBS.G05T)
        }
        Else
        {
            Store (One, \_SB.PCI0.SMBS.G05T)
        }

        Store (Not (\_SB.PCI0.SMBS.GE06), \_SB.PCI0.SMBS.G06T)
    }

    OperationRegion (ABIO, SystemIO, 0x0CD8, 0x08)
    Field (ABIO, DWordAcc, NoLock, Preserve)
    {
        INAB,   32, 
        DAAB,   32
    }

    Method (RDAB, 1, NotSerialized)
    {
        Store (Arg0, INAB)
        Return (DAAB)
    }

    Method (WTAB, 2, NotSerialized)
    {
        Store (Arg0, INAB)
        Store (Arg1, DAAB)
    }

    Method (RWAB, 3, NotSerialized)
    {
        And (RDAB (Arg0), Arg1, Local0)
        Or (Local0, Arg2, Local1)
        WTAB (Arg0, Local1)
    }

    Method (CABR, 3, NotSerialized)
    {
        ShiftLeft (Arg0, 0x05, Local0)
        Add (Local0, Arg1, Local1)
        ShiftLeft (Local1, 0x18, Local2)
        Add (Local2, Arg2, Local3)
        Return (Local3)
    }

    OperationRegion (PEBA, SystemMemory, 0xF8000000, 0x02000000)
    Field (PEBA, AnyAcc, NoLock, Preserve)
    {
                Offset (0xA807A), 
        PMS0,   1, 
                Offset (0xA8088), 
        TLS0,   4, 
                Offset (0xA907A), 
        PMS1,   1, 
                Offset (0xA9088), 
        TLS1,   4, 
                Offset (0xAA07A), 
        PMS2,   1, 
                Offset (0xAA088), 
        TLS2,   4, 
                Offset (0xAB07A), 
        PMS3,   1, 
                Offset (0xAB088), 
        TLS3,   4
    }

    OperationRegion (GNVS, SystemMemory, 0xAFBBBF18, 0x00000013)
    Field (GNVS, AnyAcc, NoLock, Preserve)
    {
        DAS1,   8, 
        DAS3,   8, 
        TNBH,   8, 
        TCP0,   8, 
        TCP1,   8, 
        ATNB,   8, 
        PCP0,   8, 
        PCP1,   8, 
        PWMN,   8, 
        LPTY,   8, 
        M92D,   8, 
        WKPM,   8, 
        ALST,   8, 
        AFUC,   8, 
        EXUS,   8, 
        AIRC,   8, 
        WLSH,   8, 
        TSSS,   8, 
        ODZC,   8
    }

    OperationRegion (OGNS, SystemMemory, 0xAFBBAD98, 0x000000ED)
    Field (OGNS, AnyAcc, Lock, Preserve)
    {
        OG00,   8, 
        OG01,   8, 
        OG02,   8, 
        OG03,   8, 
        OG04,   8, 
        OG05,   8, 
        OG06,   8, 
        OG07,   8, 
        OG08,   8, 
        OG09,   8, 
        OG10,   8, 
        CPUD,   8, 
        WINF,   8, 
        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, 
        SSTE,   16, 
        SFUN,   8, 
        TPSV,   8, 
        TAC0,   8, 
        TCRT,   8, 
        TDO1,   8, 
        TDO2,   8, 
        PPSV,   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, 
        PTIM,   8, 
        PTMP,   8, 
        DTSE,   8, 
        DTS1,   8, 
        DTS2,   8, 
        MPEN,   8, 
        QFAN,   8, 
        VBIF,   16, 
        RTCW,   16, 
        CPUN,   8, 
        ALPR,   32, 
        CIST,   8, 
        GNBF,   32, 
        CPUP,   16, 
        SLMT,   16, 
        LDES,   8, 
        HDDF,   8, 
        GCDF,   16, 
        OSVR,   32, 
        SGRQ,   32, 
        SGFN,   8, 
        SGMD,   8, 
        TJMX,   16, 
        LDST,   8, 
        WMIB,   32, 
        WMIS,   8, 
        RDYB,   8, 
        LDOB,   8, 
        FBTE,   8, 
        LDEV,   8, 
        SSTK,   8, 
        MSRN,   32, 
        MSRH,   32, 
        MSRL,   32, 
        OSTB,   16, 
        HCEC,   8, 
        HLKP,   8, 
        ILLD,   8, 
        CTJT,   8, 
        TBLG,   8, 
        TBCT,   8, 
        TBLN,   8, 
        HAPF,   8, 
        BDVS,   32, 
        TPON,   8, 
        PHNV,   16, 
        WLDP,   8, 
        BTDP,   8, 
        WRST,   8, 
        BRST,   8, 
        W3DP,   8, 
        WRPS,   8, 
        BRPS,   8, 
        WUDP,   8, 
        EXPC,   8, 
        UHDB,   8, 
        FRPN,   16, 
        IKFG,   8, 
        SWMF,   16, 
        SWSF,   16, 
        PAR0,   16, 
        DAX0,   16, 
        DAX1,   16, 
        DA00,   8, 
        DA01,   8, 
        DA02,   8, 
        DA03,   8, 
        DA04,   8, 
        DA05,   8, 
        DA06,   8, 
        DA07,   8, 
        DA08,   8, 
        DA09,   8, 
        DA10,   8, 
        DA11,   8, 
        DA12,   8, 
        DA13,   8, 
        DA14,   8, 
        DA15,   8, 
        DA16,   8, 
        DA17,   8, 
        LDRS,   16, 
        WUFC,   8, 
        TPOF,   8, 
        BIMA,   8, 
        BIMI,   8, 
        ECMA,   8, 
        ECMI,   8, 
        BIYR,   16, 
        BIMN,   8, 
        BIDA,   8, 
        USCM,   8, 
        UPST,   16, 
        XMIB,   32, 
        XMIS,   8, 
        BAPI,   32, 
        KBTY,   8, 
        FNKS,   8, 
        HISD,   8, 
        LCDD,   32, 
        FUNK,   8, 
        DA18,   8, 
        DA19,   8, 
        DA20,   8, 
        RSVD,   8
    }

    OperationRegion (NVST, SystemMemory, 0xAFBBCE8E, 0x0000012B)
    Field (NVST, AnyAcc, Lock, Preserve)
    {
        SMIF,   8, 
        PRM0,   8, 
        PRM1,   8, 
        BRTL,   8, 
        TLST,   8, 
        IGDS,   8, 
        LCDA,   16, 
        CSTE,   16, 
        NSTE,   16, 
        CADL,   16, 
        PADL,   16, 
        LIDS,   8, 
        PWRS,   8, 
        BVAL,   32, 
        ADDL,   16, 
        BCMD,   8, 
        SBFN,   8, 
        DID,    32, 
        INFO,   2048, 
        TOML,   8, 
        TOMH,   8, 
        CEBP,   8, 
        C0LS,   8, 
        C1LS,   8, 
        C0HS,   8, 
        C1HS,   8, 
        ROMS,   32, 
        MUXF,   8, 
        PDDN,   8
    }

    Method (SCMP, 2, NotSerialized)
    {
        Name (STG1, Buffer (0x50) {})
        Name (STG2, Buffer (0x50) {})
        Store (Arg0, STG1)
        Store (Arg1, STG2)
        If (LNotEqual (SizeOf (Arg0), SizeOf (Arg1)))
        {
            Return (Zero)
        }

        Store (Zero, Local0)
        While (LLess (Local0, SizeOf (Arg0)))
        {
            If (LNotEqual (DerefOf (Index (STG1, Local0)), DerefOf (Index (
                STG2, Local0))))
            {
                Return (Zero)
            }

            Increment (Local0)
        }

        Return (One)
    }

    Name (WNOS, Zero)
    Name (MYOS, Zero)
    Name (HTTS, Zero)
    Name (TPOS, Zero)
    Name (LINX, Zero)
    Name (OSSP, Zero)
    Method (CKOS, 0, NotSerialized)
    {
        If (LEqual (WNOS, Zero))
        {
            If (SCMP (_OS, "Microsoft Windows"))
            {
                Store (One, WNOS)
            }

            If (SCMP (_OS, "Microsoft Windows NT"))
            {
                Store (0x02, WNOS)
            }

            If (SCMP (_OS, "Microsoft WindowsME: Millennium Edition"))
            {
                Store (0x03, WNOS)
            }

            If (CondRefOf (\_OSI, Local0))
            {
                If (SCMP (_OS, "Windows 2006"))
                {
                    Store (0x05, WNOS)
                }
                Else
                {
                    If (SCMP (_OS, "Windows 2009"))
                    {
                        Store (0x06, WNOS)
                    }
                    Else
                    {
                        Store (0x04, WNOS)
                    }
                }
            }
        }

        Return (WNOS)
    }

    Method (SEQL, 2, Serialized)
    {
        Store (SizeOf (Arg0), Local0)
        Store (SizeOf (Arg1), Local1)
        If (LNotEqual (Local0, Local1))
        {
            Return (Zero)
        }

        Name (BUF0, Buffer (Local0) {})
        Store (Arg0, BUF0)
        Name (BUF1, Buffer (Local0) {})
        Store (Arg1, BUF1)
        Store (Zero, Local2)
        While (LLess (Local2, Local0))
        {
            Store (DerefOf (Index (BUF0, Local2)), Local3)
            Store (DerefOf (Index (BUF1, Local2)), Local4)
            If (LNotEqual (Local3, Local4))
            {
                Return (Zero)
            }

            Increment (Local2)
        }

        Return (One)
    }

    Method (OSTP, 0, NotSerialized)
    {
        If (CondRefOf (\_OSI, Local0))
        {
            Store (Zero, OSTB)
            Store (Zero, TPOS)
            If (_OSI ("Windows 2001"))
            {
                Store (0x08, OSTB)
                Store (0x08, TPOS)
            }

            If (_OSI ("Windows 2001.1"))
            {
                Store (0x20, OSTB)
                Store (0x20, TPOS)
            }

            If (_OSI ("Windows 2001 SP1"))
            {
                Store (0x10, OSTB)
                Store (0x10, TPOS)
            }

            If (_OSI ("Windows 2001 SP2"))
            {
                Store (0x11, OSTB)
                Store (0x11, TPOS)
            }

            If (_OSI ("Windows 2001 SP3"))
            {
                Store (0x12, OSTB)
                Store (0x12, TPOS)
            }

            If (_OSI ("Windows 2006"))
            {
                Store (0x40, OSTB)
                Store (0x40, TPOS)
            }

            If (_OSI ("Windows 2006 SP1"))
            {
                Store (0x41, OSTB)
                Store (0x41, TPOS)
                Store (One, OSSP)
            }

            If (_OSI ("Windows 2009"))
            {
                Store (One, OSSP)
                Store (0x50, OSTB)
                Store (0x50, TPOS)
            }

            If (_OSI ("Windows 2012"))
            {
                Store (One, OSSP)
                Store (0x60, OSTB)
                Store (0x60, TPOS)
            }

            If (_OSI ("Linux"))
            {
                Store (One, LINX)
                Store (0x80, OSTB)
                Store (0x80, TPOS)
            }
        }
        Else
        {
            If (CondRefOf (\_OS, Local0))
            {
                If (SEQL (_OS, "Microsoft Windows"))
                {
                    Store (One, OSTB)
                    Store (One, TPOS)
                }
                Else
                {
                    If (SEQL (_OS, "Microsoft WindowsME: Millennium Edition"))
                    {
                        Store (0x02, OSTB)
                        Store (0x02, TPOS)
                    }
                    Else
                    {
                        If (SEQL (_OS, "Microsoft Windows NT"))
                        {
                            Store (0x04, OSTB)
                            Store (0x04, TPOS)
                        }
                        Else
                        {
                            Store (Zero, OSTB)
                            Store (Zero, TPOS)
                        }
                    }
                }
            }
            Else
            {
                Store (Zero, OSTB)
                Store (Zero, TPOS)
            }
        }

        Return (OSTB)
    }

    Scope (_PR)
    {
        Processor (C000, 0x00, 0x00000410, 0x06) {}
        Processor (C001, 0x01, 0x00000410, 0x06) {}
        Processor (C002, 0x02, 0x00000410, 0x06) {}
        Processor (C003, 0x03, 0x00000410, 0x06) {}
    }

    Name (_S0, Package (0x04)
    {
        Zero, 
        Zero, 
        Zero, 
        Zero
    })
    If (LEqual (DAS1, One))
    {
        Name (_S1, Package (0x04)
        {
            One, 
            One, 
            Zero, 
            Zero
        })
    }

    If (LEqual (DAS3, One))
    {
        Name (_S3, Package (0x04)
        {
            0x03, 
            0x03, 
            Zero, 
            Zero
        })
    }

    Name (_S4, Package (0x04)
    {
        0x04, 
        0x04, 
        Zero, 
        Zero
    })
    Name (_S5, Package (0x04)
    {
        0x05, 
        0x05, 
        Zero, 
        Zero
    })
    Scope (_GPE)
    {
        Method (_L1C, 0, NotSerialized)
        {
            Store (0xFFFF, Local1)
            Store (\_SB.PCI0.SMBS.MIN, Local2)
            ShiftLeft (Local2, 0x08, Local1)
            Store (\_SB.PCI0.SMBS.SEC, Local2)
            Or (Local1, Local2, Local1)
            Store (Local1, P80H)
        }

        Method (_L08, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.PB2, 0x02)
            Notify (\_SB.PCI0.PB3, 0x02)
            Notify (\_SB.PCI0.PB4, 0x02)
            Notify (\_SB.PCI0.PB5, 0x02)
            Notify (\_SB.PCI0.PB6, 0x02)
            Notify (\_SB.PCI0.PB7, 0x02)
            Notify (\_SB.PCI0.SPB0, 0x02)
            Notify (\_SB.PCI0.SPB1, 0x02)
            Notify (\_SB.PCI0.SPB2, 0x02)
            Notify (\_SB.PCI0.SPB3, 0x02)
        }

        Name (CALB, Buffer (0x05) {})
        Name (XX05, Buffer (0x05) {})
        Method (_L05, 0, NotSerialized)
        {
            CreateWordField (CALB, Zero, SZZE)
            CreateField (CALB, 0x10, 0x03, FUCC)
            CreateField (CALB, 0x13, 0x05, DEVV)
            CreateByteField (CALB, 0x03, BUSS)
            CreateByteField (CALB, 0x04, HPST)
            Store (0x05, SZZE)
            Store (Zero, BUSS)
            Store (0x07, DEVV)
            Store (Zero, FUCC)
            If (\_SB.PCI0.SMBS.GE05)
            {
                Store (Zero, \_SB.PCI0.SMBS.G05T)
                Store (0x0F04, P80H)
                Store (Zero, HPST)
                \_SB.ALIB (0x06, CALB)
                Store (0x0F05, P80H)
            }
            Else
            {
                Store (One, \_SB.PCI0.SMBS.G05T)
                Store (0x0204, P80H)
                Store (One, HPST)
                \_SB.ALIB (0x06, CALB)
                Store (0x0205, P80H)
            }

            Notify (\_SB.PCI0.PB7, Zero)
        }

        Method (_L18, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.OHC1, 0x02)
            Notify (\_SB.PCI0.OHC2, 0x02)
            Notify (\_SB.PCI0.OHC3, 0x02)
            Notify (\_SB.PCI0.OHC4, 0x02)
            Notify (\_SB.PCI0.EHC1, 0x02)
            Notify (\_SB.PCI0.EHC2, 0x02)
            Notify (\_SB.PCI0.EHC3, 0x02)
            Notify (\_SB.PCI0.XHC0, 0x02)
            Notify (\_SB.PCI0.XHC1, 0x02)
            Notify (\_SB.PWRB, 0x02)
        }

        Method (_L09, 0, NotSerialized)
        {
            Store (0x4400, P80H)
            Store (\_SB.PCI0.SMBS.I199, Local0)
            Or (Local0, \_SB.PCI0.SMBS.O012, Local0)
            Or (Local0, \_SB.PCI0.SMBS.O013, Local0)
            CreateWordField (XX05, Zero, SZZE)
            CreateField (XX05, 0x10, 0x03, FUCC)
            CreateField (XX05, 0x13, 0x05, DEVV)
            CreateByteField (XX05, 0x03, BUSS)
            CreateByteField (XX05, 0x04, HPST)
            Store (0x05, SZZE)
            Store (Zero, BUSS)
            Store (0x05, DEVV)
            Store (Zero, FUCC)
            If (LEqual (Local0, One))
            {
                If (LEqual (WLSH, Zero))
                {
                    Store (Zero, \_SB.PCI0.SMBS.O199)
                    Store (Zero, \_SB.PCI0.SMBS.O012)
                    Store (Zero, \_SB.PCI0.SMBS.O013)
                    Store (Zero, \_SB.PCI0.SMBS.E199)
                    Store (Zero, \_SB.PCI0.SMBS.E012)
                    Store (Zero, \_SB.PCI0.SMBS.E013)
                }
                Else
                {
                    Store (Zero, HPST)
                    \_SB.ALIB (0x06, XX05)
                    Store (Zero, \_SB.PCI0.SMBS.O199)
                    Store (Zero, \_SB.PCI0.SMBS.E199)
                    Store (Zero, \_SB.PCI0.SMBS.O012)
                    Store (Zero, \_SB.PCI0.SMBS.O013)
                    Store (Zero, \_SB.PCI0.SMBS.E012)
                    Store (Zero, \_SB.PCI0.SMBS.E013)
                }
            }

            If (LEqual (Local0, Zero))
            {
                If (LEqual (WLSH, Zero))
                {
                    Store (One, \_SB.PCI0.SMBS.O199)
                    Store (One, \_SB.PCI0.SMBS.O012)
                    Store (One, \_SB.PCI0.SMBS.O013)
                    Store (Zero, \_SB.PCI0.SMBS.E199)
                    Store (Zero, \_SB.PCI0.SMBS.E012)
                    Store (Zero, \_SB.PCI0.SMBS.E013)
                }
                Else
                {
                    Store (One, \_SB.PCI0.SMBS.O199)
                    Store (Zero, \_SB.PCI0.SMBS.E199)
                    Store (One, HPST)
                    \_SB.ALIB (0x06, XX05)
                    Sleep (0x14)
                    Store (One, \_SB.PCI0.SMBS.O012)
                    Store (One, \_SB.PCI0.SMBS.O013)
                    Store (Zero, \_SB.PCI0.SMBS.E012)
                    Store (Zero, \_SB.PCI0.SMBS.E013)
                }
            }

            Notify (\_SB.PCI0.PB5, Zero)
            Notify (\_SB.PCI0.SPB2, Zero)
        }

        Method (_L06, 0, NotSerialized)
        {
            If (LEqual (ODZC, One))
            {
                If (\_SB.PCI0.SMBS.G06T)
                {
                    Sleep (0x14)
                    If (\_SB.PCI0.SMBS.GE06)
                    {
                        Store (Zero, \_SB.PCI0.SMBS.G06T)
                        If (LOr (LEqual (\_SB.PCI0.SATA.VIDI, 0x78001022), LEqual (\_SB.PCI0.SATA.VIDI, 0x78011022))) {}
                        If (LOr (LEqual (\_SB.PCI0.SATA.VIDI, 0x78041022), LEqual (\_SB.PCI0.SATA.VIDI, 0x78021002)))
                        {
                            Notify (\_SB.PCI0.SATA.ODDZ, 0x80)
                        }

                        If (LEqual (\_SB.PCI0.SATA.VIDI, 0x78031022))
                        {
                            Notify (\_SB.PCI0.SATA.ODDZ, 0x80)
                        }

                        Store (0xDF15, P80H)
                    }
                }
                Else
                {
                    Sleep (0x14)
                    If (LNot (\_SB.PCI0.SMBS.GE06))
                    {
                        Store (One, \_SB.PCI0.SMBS.G06T)
                        If (LOr (LEqual (\_SB.PCI0.SATA.VIDI, 0x78001022), LEqual (\_SB.PCI0.SATA.VIDI, 0x78011022))) {}
                        If (LOr (LEqual (\_SB.PCI0.SATA.VIDI, 0x78041022), LEqual (\_SB.PCI0.SATA.VIDI, 0x78021002)))
                        {
                            Notify (\_SB.PCI0.SATA.ODDZ, 0x80)
                        }

                        If (LEqual (\_SB.PCI0.SATA.VIDI, 0x78031022))
                        {
                            Notify (\_SB.PCI0.SATA.ODDZ, 0x80)
                        }

                        Store (0xDF14, P80H)
                    }
                }
            }
        }
    }

    OperationRegion (TRDP, SystemIO, 0x025C, 0x02)
    Field (TRDP, ByteAcc, NoLock, Preserve)
    {
        AEID,   8, 
        AEIC,   8
    }

    Name (MES4, Zero)
    Scope (_TZ)
    {
        Name (TSP, 0x0A)
        Name (TC1, 0x02)
        Name (TC2, 0x0A)
        Name (ATMP, 0x3C)
        Name (LTMP, 0x3C)
        Name (FANS, Zero)
        Name (CRTF, Zero)
        OperationRegion (STSI, SystemMemory, 0xF80C31E8, 0x08)
        Field (STSI, DWordAcc, NoLock, Preserve)
        {
            TSII,   8, 
                    Offset (0x04), 
            TSID,   8
        }

        IndexField (TSII, TSID, ByteAcc, NoLock, Preserve)
        {
                    Offset (0x01), 
            TS01,   8, 
            TS02,   8, 
            TS03,   8, 
            TS04,   8, 
            TS05,   8, 
            TS06,   8, 
            TS07,   8, 
            TS08,   8, 
            TS09,   8, 
                    Offset (0x10), 
            TS10,   8, 
            TS11,   8, 
            TS12,   8, 
            TS13,   8, 
            TS14,   8, 
                    Offset (0x22), 
            TS22,   8, 
                    Offset (0x32), 
            TS32,   8, 
                    Offset (0xBF), 
            TSBF,   8, 
                    Offset (0xFE), 
            TSFE,   8, 
            TSFF,   8
        }

        Name (ZNST, Zero)
        Name (INST, Zero)
        Name (CURP, Zero)
        Name (MINP, 0x04)
        Name (F0ST, Zero)
        Name (F1ST, Zero)
        Name (F2ST, Zero)
        Name (F3ST, Zero)
        Name (FNBE, Zero)
        Name (FNBF, Zero)
        Name (FNBS, Zero)
        Name (FTC0, 0x50)
        Name (FTC1, 0x32)
        Name (FTNB, 0x5A)
        Name (FSC0, 0x99)
        Name (FSC1, 0x66)
        Name (FSNB, 0xFF)
        Name (FHYS, 0x0C)
        Name (CORF, Zero)
        Name (FUDF, Zero)
        Name (FUDV, Zero)
        Name (Z0TT, 0x69)
        Name (Z0TP, 0x62)
        Name (Z0T1, One)
        Name (Z0T2, 0x02)
        Name (Z0TS, 0x96)
        Name (Z0A0, 0x50)
        Name (Z0A1, 0x32)
        Name (Z0A2, Zero)
        Name (Z0A3, Zero)
        Name (Z0S0, 0x99)
        Name (Z0S1, 0x66)
        Name (Z0S2, Zero)
        Name (Z0S3, Zero)
        Name (Z0TC, Zero)
        Name (Z0TL, Zero)
        Name (Z0TH, 0x0C)
        Name (Z0TI, Zero)
        Name (Z0TO, Zero)
        Name (Z0PR, Zero)
        Name (Z0HP, 0x05)
        Method (RTMP, 0, NotSerialized)
        {
            If (\_SB.PCI0.LPC0.EC.ECAV ())
            {
                Store (\_SB.PCI0.LPC0.EC.TH0L, Local0)
                If (LLess (Local0, 0x80))
                {
                    Store (Local0, LTMP)
                }
            }

            Return (LTMP)
        }

        Method (RFAN, 1, NotSerialized)
        {
            If (Arg0)
            {
                Store (\_SB.PCI0.LPC0.EC.F1TS, Local0)
            }
            Else
            {
                Store (\_SB.PCI0.LPC0.EC.F0TS, Local0)
            }

            If (LEqual (Local0, Zero))
            {
                Return (Zero)
            }

            Multiply (0x8000, 0x3C, Local1)
            Multiply (Local1, 0x5F, Local1)
            Divide (Local1, 0x64, Local3, Local1)
            Not (Local0, Local0)
            And (Local0, 0xFFFF, Local0)
            Multiply (Local0, 0x02, Local0)
            Divide (Local1, Local0, Local3, Local2)
            If (LGreater (Local2, 0x6338))
            {
                Return (0xFF)
            }

            Divide (Local2, 0x64, Local3, Local2)
            Return (Local2)
        }

        Method (RPSV, 0, NotSerialized)
        {
            If (\_SB.PCI0.LPC0.EC.ECAV ())
            {
                Store (\_SB.PCI0.LPC0.EC.EPSV, Local0)
                If (LLess (Local0, 0x80))
                {
                    Store (Local0, TPSV)
                }
            }
        }

        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)
        }

        Method (RLTM, 0, NotSerialized)
        {
            Return (ATMP)
        }

        Method (GZXT, 1, Serialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Or (TS03, 0x40, TS09)
                Store (TS01, Local1)
                Store (TS10, Local2)
                And (TS03, 0xBF, TS09)
                Add (Multiply (0x0100, Local1), Local2, Local3)
                Add (0x0AAC, Divide (Multiply (Local3, 0x0A), 0x0100, Local4, Local5), 
                    Local6)
            }

            Return (Local6)
        }

        Method (UTRP, 0, Serialized)
        {
            Store (TS02, Local0)
            And (Local0, 0x18, Local0)
            If (LNotEqual (Local0, Zero))
            {
                Or (TS03, 0x40, TS09)
                Store (TS01, Z0TC)
                FZTD ()
                Notify (THZ0, 0x81)
                Store (Local0, TS02)
            }

            Return (Local0)
        }

        Method (ITFO, 1, Serialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Store (0x06, \_SB.PCI0.SMBS.F0CT)
                Store (0x04, \_SB.PCI0.SMBS.F0MS)
                Store (0x02, \_SB.PCI0.SMBS.F0FQ)
                Store (0xFF, \_SB.PCI0.SMBS.F0LD)
            }
            Else
            {
                If (LEqual (Arg0, One))
                {
                    Store (0x06, \_SB.PCI0.SMBS.F1CT)
                    Store (0x04, \_SB.PCI0.SMBS.F1MS)
                    Store (0x02, \_SB.PCI0.SMBS.F1FQ)
                    Store (0xFF, \_SB.PCI0.SMBS.F1LD)
                }
                Else
                {
                    If (LEqual (Arg0, 0x02))
                    {
                        Store (0x06, \_SB.PCI0.SMBS.F2CT)
                        Store (0x04, \_SB.PCI0.SMBS.F2MS)
                        Store (0x02, \_SB.PCI0.SMBS.F2FQ)
                        Store (0xFF, \_SB.PCI0.SMBS.F2LD)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (0x06, \_SB.PCI0.SMBS.F3CT)
                            Store (0x04, \_SB.PCI0.SMBS.F3MS)
                            Store (0x02, \_SB.PCI0.SMBS.F3FQ)
                            Store (0xFF, \_SB.PCI0.SMBS.F3LD)
                        }
                    }
                }
            }
        }

        Method (ITIN, 1, Serialized)
        {
        }

        Method (STTD, 3, Serialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Store (0x02, TS32)
                Store (TS02, TS02)
                Store (Arg1, TS07)
                Store (Zero, TS13)
                Store (Arg2, TS08)
                Store (Zero, TS14)
            }
        }

        Method (STFO, 2, Serialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Store (Arg1, \_SB.PCI0.SMBS.F0LD)
            }
            Else
            {
                If (LEqual (Arg0, One))
                {
                    Store (Arg1, \_SB.PCI0.SMBS.F1LD)
                }
                Else
                {
                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, \_SB.PCI0.SMBS.F2LD)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, \_SB.PCI0.SMBS.F3LD)
                        }
                    }
                }
            }
        }

        Method (SFFS, 0, Serialized)
        {
            Store (FSNB, \_SB.PCI0.SMBS.F0LD)
        }

        Method (SFSD, 2, Serialized)
        {
            If (LEqual (Arg1, Zero))
            {
                And (F0ST, Not (Arg0), F0ST)
            }
            Else
            {
                Or (F0ST, Arg0, F0ST)
            }

            If (And (F0ST, One))
            {
                Store (Z0S0, Local0)
            }
            Else
            {
                If (And (F0ST, 0x02))
                {
                    Store (Z0S1, Local0)
                }
                Else
                {
                    If (And (F0ST, 0x04))
                    {
                        Store (Z0S2, Local0)
                    }
                    Else
                    {
                        If (And (F0ST, 0x08))
                        {
                            Store (Z0S3, Local0)
                        }
                        Else
                        {
                            Store (Zero, Local0)
                        }
                    }
                }
            }

            If (LEqual (FNBS, Zero))
            {
                Store (Local0, \_SB.PCI0.SMBS.F0LD)
            }
        }

        Method (F0SU, 1, Serialized)
        {
            Store (Zero, Local0)
            If (And (Arg0, F0ST))
            {
                Store (One, Local0)
            }

            Return (Local0)
        }

        PowerResource (P0L0, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Return (F0SU (One))
            }

            Method (_ON, 0, NotSerialized)
            {
                SFSD (One, One)
            }

            Method (_OFF, 0, NotSerialized)
            {
                SFSD (One, Zero)
            }
        }

        PowerResource (P0L1, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Return (F0SU (0x02))
            }

            Method (_ON, 0, NotSerialized)
            {
                SFSD (0x02, One)
            }

            Method (_OFF, 0, NotSerialized)
            {
                SFSD (0x02, Zero)
            }
        }

        PowerResource (P0L2, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Return (F0SU (0x04))
            }

            Method (_ON, 0, NotSerialized)
            {
                SFSD (0x04, One)
            }

            Method (_OFF, 0, NotSerialized)
            {
                SFSD (0x04, Zero)
            }
        }

        PowerResource (P0L3, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Return (F0SU (0x08))
            }

            Method (_ON, 0, NotSerialized)
            {
                SFSD (0x08, One)
            }

            Method (_OFF, 0, NotSerialized)
            {
                SFSD (0x08, Zero)
            }
        }

        Device (Z0F0)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, Zero)
            Name (_PR0, Package (0x01)
            {
                P0L0
            })
            Method (_INI, 0, NotSerialized)
            {
                Store (TNBH, FHYS)
                Store (TCP1, FTC0)
                Store (TCP0, FTC1)
                Store (Divide (Multiply (PCP1, 0xFF), 0x64, ), FSC0)
                Store (Divide (Multiply (PCP0, 0xFF), 0x64, ), FSC1)
                Store (Zero, Z0TL)
                Store (FHYS, Z0TH)
                Store (Zero, CURP)
                Store (Zero, Z0PR)
                Store (0x05, Z0HP)
                Store (Zero, FNBF)
                ITFO (Zero)
                ITIN (Zero)
                STTD (Zero, Z0A3, Zero)
            }
        }

        Device (Z0F1)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, One)
            Name (_PR0, Package (0x01)
            {
                P0L1
            })
        }

        Device (Z0F2)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x02)
            Name (_PR0, Package (0x01)
            {
                P0L2
            })
        }

        Device (Z0F3)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x03)
            Name (_PR0, Package (0x01)
            {
                P0L3
            })
        }

        Method (FZTD, 0, Serialized)
        {
            Store (0x69, Z0TT)
            Store (0x62, Z0TP)
            Store (FTC0, Z0A0)
            Store (FTC1, Z0A1)
            Store (Zero, Z0A2)
            Store (Zero, Z0A3)
            Store (FSC0, Z0S0)
            Store (FSC1, Z0S1)
            Store (Zero, Z0S2)
            Store (Zero, Z0S3)
            Store (Zero, Z0PR)
            If (LGreaterEqual (Z0TC, Z0TT))
            {
                Store (0x80, Z0TI)
                Store (Z0TT, Z0TO)
                Store (0x02, Local0)
                Store (One, Z0PR)
            }
            Else
            {
                If (LGreaterEqual (Z0TC, Z0TP))
                {
                    Store (Z0TT, Z0TI)
                    Store (Z0TP, Z0TO)
                    Store (0x02, Local0)
                    Store (One, Z0PR)
                }
                Else
                {
                    If (LGreaterEqual (Z0TC, Z0A0))
                    {
                        Store (Z0TP, Z0TI)
                        Store (Z0A0, Z0TO)
                        Store (One, Local0)
                    }
                    Else
                    {
                        If (LGreaterEqual (Z0TC, Z0A1))
                        {
                            Store (Z0A0, Z0TI)
                            Store (Z0A1, Z0TO)
                            Store (One, Local0)
                        }
                        Else
                        {
                            If (LGreaterEqual (Z0TC, Z0A2))
                            {
                                Store (Z0A1, Z0TI)
                                Store (Z0A2, Z0TO)
                                Store (One, Local0)
                            }
                            Else
                            {
                                If (LGreaterEqual (Z0TC, Z0A3))
                                {
                                    Store (Z0A2, Z0TI)
                                    Store (Z0A3, Z0TO)
                                    Store (One, Local0)
                                }
                                Else
                                {
                                    If (LLess (Z0TC, Z0A3))
                                    {
                                        Store (Z0A3, Z0TI)
                                        Store (Zero, Z0TO)
                                        Store (Zero, Local0)
                                    }
                                }
                            }
                        }
                    }
                }
            }

            If (LEqual (Local0, One))
            {
                If (LGreaterEqual (Z0TO, Z0TH))
                {
                    Subtract (Z0TO, Z0TH, Local1)
                    If (LEqual (Z0TO, Z0A0))
                    {
                        Store (Local1, Z0A0)
                    }
                    Else
                    {
                        If (LEqual (Z0TO, Z0A1))
                        {
                            Store (Local1, Z0A1)
                        }
                        Else
                        {
                            If (LEqual (Z0TO, Z0A2))
                            {
                                Store (Local1, Z0A2)
                            }
                            Else
                            {
                                If (LEqual (Z0TO, Z0A3))
                                {
                                    Store (Local1, Z0A3)
                                }
                            }
                        }
                    }

                    Store (Local1, Z0TO)
                }
            }
            Else
            {
                If (LEqual (Local0, 0x02))
                {
                    If (LGreaterEqual (Z0TO, Z0HP))
                    {
                        Subtract (Z0TO, Z0HP, Z0TO)
                    }
                }
            }

            STTD (Zero, Z0TI, Z0TO)
            Store (Z0TC, Z0TL)
        }

        Name (PLCY, Zero)
        ThermalZone (THZ0)
        {
            Method (_CRT, 0, Serialized)
            {
                If (CRTF)
                {
                    RCRT ()
                    Return (KELV (TCRT))
                }
                Else
                {
                    Return (KELV (0x7D))
                }
            }

            Method (RCRT, 0, NotSerialized)
            {
                If (\_SB.PCI0.LPC0.EC.ECAV ())
                {
                    Store (\_SB.PCI0.LPC0.EC.ECRT, Local0)
                    If (LLess (Local0, 0x80))
                    {
                        Store (Local0, TCRT)
                    }
                }
            }

            Method (_SCP, 1, Serialized)
            {
                Store (Arg0, PLCY)
                Notify (THZ0, 0x81)
            }

            Method (_TMP, 0, Serialized)
            {
                Return (GZXT (Zero))
            }

            Method (_AC0, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (Z0A0, 0x0A)))
            }

            Method (_AC1, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (Z0A1, 0x0A)))
            }

            Method (_AC2, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (Z0A2, 0x0A)))
            }

            Method (_AC3, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (Z0A3, 0x0A)))
            }

            Method (_AL0, 0, NotSerialized)
            {
                Return (Package (0x01)
                {
                    Z0F0
                })
            }

            Method (_AL1, 0, NotSerialized)
            {
                Return (Package (0x01)
                {
                    Z0F1
                })
            }

            Method (_AL2, 0, NotSerialized)
            {
                Return (Package (0x01)
                {
                    Z0F2
                })
            }

            Method (_AL3, 0, NotSerialized)
            {
                Return (Package (0x01)
                {
                    Z0F3
                })
            }

            Method (_PSL, 0, Serialized)
            {
                If (LEqual (CPUN, 0x02))
                {
                    Return (Package (0x02)
                    {
                        \_PR.C001, 
                        \_PR.C002
                    })
                }

                Return (Package (0x01)
                {
                    \_PR.C001
                })
            }

            Method (_PSV, 0, Serialized)
            {
                RPSV ()
                If (LEqual (TPSV, Zero))
                {
                    Return (KELV (0x69))
                }
                Else
                {
                    Return (KELV (TPSV))
                }
            }

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

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

            Method (_TSP, 0, Serialized)
            {
                Multiply (TSP, 0x0A, Local0)
                Return (Local0)
            }
        }
    }

    Device (WMI0)
    {
        Name (_HID, "PNP0C14")
        Name (_UID, Zero)
        Name (WAPF, Zero)
        Name (_WDG, Buffer (0x01B8)
        {
            /* 0000 */    0x00, 0x24, 0x14, 0x39, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0008 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0010 */    0x30, 0x30, 0x01, 0x01, 0x00, 0x24, 0x14, 0x49, 
            /* 0018 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0020 */    0x52, 0x83, 0x41, 0x00, 0x30, 0x31, 0x01, 0x01, 
            /* 0028 */    0x00, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0030 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0038 */    0x30, 0x32, 0x01, 0x01, 0x01, 0x24, 0x14, 0x49, 
            /* 0040 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0048 */    0x52, 0x83, 0x41, 0x00, 0x31, 0x31, 0x01, 0x01, 
            /* 0050 */    0x01, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0058 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0060 */    0x31, 0x32, 0x01, 0x01, 0x02, 0x24, 0x14, 0x49, 
            /* 0068 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0070 */    0x52, 0x83, 0x41, 0x00, 0x32, 0x31, 0x01, 0x01, 
            /* 0078 */    0x02, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0080 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0088 */    0x32, 0x32, 0x01, 0x01, 0x03, 0x24, 0x14, 0x49, 
            /* 0090 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0098 */    0x52, 0x83, 0x41, 0x00, 0x33, 0x31, 0x01, 0x01, 
            /* 00A0 */    0x03, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 00A8 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 00B0 */    0x33, 0x32, 0x01, 0x01, 0x04, 0x24, 0x14, 0x49, 
            /* 00B8 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 00C0 */    0x52, 0x83, 0x41, 0x00, 0x34, 0x31, 0x01, 0x01, 
            /* 00C8 */    0x04, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 00D0 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 00D8 */    0x34, 0x32, 0x01, 0x01, 0x05, 0x24, 0x14, 0x49, 
            /* 00E0 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 00E8 */    0x52, 0x83, 0x41, 0x00, 0x35, 0x31, 0x01, 0x01, 
            /* 00F0 */    0x05, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 00F8 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0100 */    0x35, 0x32, 0x01, 0x01, 0x06, 0x24, 0x14, 0x49, 
            /* 0108 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0110 */    0x52, 0x83, 0x41, 0x00, 0x36, 0x31, 0x01, 0x01, 
            /* 0118 */    0x06, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0120 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0128 */    0x36, 0x32, 0x01, 0x01, 0x07, 0x24, 0x14, 0x49, 
            /* 0130 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0138 */    0x52, 0x83, 0x41, 0x00, 0x37, 0x31, 0x01, 0x01, 
            /* 0140 */    0x07, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0148 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0150 */    0x37, 0x32, 0x01, 0x01, 0x00, 0x24, 0x14, 0x59, 
            /* 0158 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0160 */    0x52, 0x83, 0x41, 0x00, 0x80, 0x00, 0x01, 0x08, 
            /* 0168 */    0x00, 0x24, 0x14, 0x69, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0170 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 0178 */    0x30, 0x35, 0x01, 0x02, 0x00, 0x24, 0x14, 0x79, 
            /* 0180 */    0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, 
            /* 0188 */    0x52, 0x83, 0x41, 0x00, 0x30, 0x36, 0x01, 0x02, 
            /* 0190 */    0x00, 0x24, 0x14, 0x89, 0xA3, 0xC6, 0xFA, 0x40, 
            /* 0198 */    0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, 
            /* 01A0 */    0x30, 0x37, 0x01, 0x02, 0x21, 0x12, 0x90, 0x05, 
            /* 01A8 */    0x66, 0xD5, 0xD1, 0x11, 0xB2, 0xF0, 0x00, 0xA0, 
            /* 01B0 */    0xC9, 0x06, 0x29, 0x10, 0x42, 0x41, 0x01, 0x01
        })
        Name (EVCD, Zero)
        Method (WQ00, 1, NotSerialized)
        {
            Return (EVCD)
        }

        OperationRegion (\WMIA, SystemMemory, WMIB, 0x9000)
        Field (WMIA, AnyAcc, NoLock, Preserve)
        {
            WAG1,   2048, 
            WAG2,   2048, 
            WAG3,   2048, 
            WAG4,   2048, 
            WAG5,   2048, 
            WAG6,   2048, 
            WAG7,   2048, 
            WAG8,   2048, 
                    Offset (0x1000), 
            WPD1,   32768, 
            WPD2,   32768, 
            WPD3,   32768, 
            WPD4,   32768, 
            WPD5,   32768, 
            WPD6,   32768, 
            WPD7,   32768, 
            WPD8,   32768
        }

        Method (WQ01, 1, NotSerialized)
        {
            Return (WAG1)
        }

        Method (WS01, 2, NotSerialized)
        {
            Store (Arg1, WAG1)
            Return (Zero)
        }

        Method (WQ02, 1, NotSerialized)
        {
            Return (WPD1)
        }

        Method (WS02, 2, NotSerialized)
        {
            Store (Arg1, WPD1)
            Return (Zero)
        }

        Method (WQ11, 1, NotSerialized)
        {
            Return (WAG2)
        }

        Method (WS11, 2, NotSerialized)
        {
            Store (Arg1, WAG2)
            Return (Zero)
        }

        Method (WQ12, 1, NotSerialized)
        {
            Return (WPD2)
        }

        Method (WS12, 2, NotSerialized)
        {
            Store (Arg1, WPD2)
            Return (Zero)
        }

        Method (WQ21, 1, NotSerialized)
        {
            Return (WAG3)
        }

        Method (WS21, 2, NotSerialized)
        {
            Store (Arg1, WAG3)
            Return (Zero)
        }

        Method (WQ22, 1, NotSerialized)
        {
            Return (WPD3)
        }

        Method (WS22, 2, NotSerialized)
        {
            Store (Arg1, WPD3)
            Return (Zero)
        }

        Method (WQ31, 1, NotSerialized)
        {
            Return (WAG4)
        }

        Method (WS31, 2, NotSerialized)
        {
            Store (Arg1, WAG4)
            Return (Zero)
        }

        Method (WQ32, 1, NotSerialized)
        {
            Return (WPD4)
        }

        Method (WS32, 2, NotSerialized)
        {
            Store (Arg1, WPD4)
            Return (Zero)
        }

        Method (WQ41, 1, NotSerialized)
        {
            Return (WAG5)
        }

        Method (WS41, 2, NotSerialized)
        {
            Store (Arg1, WAG5)
            Return (Zero)
        }

        Method (WQ42, 1, NotSerialized)
        {
            Return (WPD5)
        }

        Method (WS42, 2, NotSerialized)
        {
            Store (Arg1, WPD5)
            Return (Zero)
        }

        Method (WQ51, 1, NotSerialized)
        {
            Return (WAG6)
        }

        Method (WS51, 2, NotSerialized)
        {
            Store (Arg1, WAG6)
            Return (Zero)
        }

        Method (WQ52, 1, NotSerialized)
        {
            Return (WPD6)
        }

        Method (WS52, 2, NotSerialized)
        {
            Store (Arg1, WPD6)
            Return (Zero)
        }

        Method (WQ61, 1, NotSerialized)
        {
            Return (WAG7)
        }

        Method (WS61, 2, NotSerialized)
        {
            Store (Arg1, WAG7)
            Return (Zero)
        }

        Method (WQ62, 1, NotSerialized)
        {
            Return (WPD7)
        }

        Method (WS62, 2, NotSerialized)
        {
            Store (Arg1, WPD7)
            Return (Zero)
        }

        Method (WQ71, 1, NotSerialized)
        {
            Return (WAG8)
        }

        Method (WS71, 2, NotSerialized)
        {
            Store (Arg1, WAG8)
            Return (Zero)
        }

        Method (WQ72, 1, NotSerialized)
        {
            Return (WPD8)
        }

        Method (WS72, 2, NotSerialized)
        {
            Store (Arg1, WPD8)
            Return (Zero)
        }

        Method (WM05, 3, NotSerialized)
        {
            CreateDWordField (Arg2, Zero, WMA5)
            If (LEqual (WMA5, One))
            {
                WMIG (WMIB, Add (WMIB, 0x1000), One)
                Return (Zero)
            }

            If (LEqual (WMA5, 0x02))
            {
                WMIG (Add (WMIB, 0x0100), Add (WMIB, 0x2000), 0x02)
                Return (Zero)
            }

            If (LEqual (WMA5, 0x03))
            {
                WMIG (Add (WMIB, 0x0200), Add (WMIB, 0x3000), 0x03)
                Return (Zero)
            }

            If (LEqual (WMA5, 0x04))
            {
                WMIG (Add (WMIB, 0x0300), Add (WMIB, 0x4000), 0x04)
                Return (Zero)
            }

            If (LEqual (WMA5, 0x05))
            {
                WMIG (Add (WMIB, 0x0400), Add (WMIB, 0x5000), 0x05)
                Return (Zero)
            }

            If (LEqual (WMA5, 0x06))
            {
                WMIG (Add (WMIB, 0x0500), Add (WMIB, 0x6000), 0x06)
                Return (Zero)
            }

            If (LEqual (WMA5, 0x07))
            {
                WMIG (Add (WMIB, 0x0600), Add (WMIB, 0x7000), 0x07)
                Return (Zero)
            }

            If (LEqual (WMA5, 0x08))
            {
                WMIG (Add (WMIB, 0x0700), Add (WMIB, 0x8000), 0x08)
                Return (Zero)
            }

            Return (Zero)
        }

        Method (WM06, 3, Serialized)
        {
            CreateDWordField (Arg2, Zero, WM6A)
            Store (INIT (WM6A), Local0)
            Return (Local0)
        }

        Method (WM07, 3, Serialized)
        {
            CreateDWordField (Arg2, Zero, WM7A)
            Store (WDOG (WM7A), Local0)
            Return (Local0)
        }

        Method (NTFY, 1, Serialized)
        {
            Store (Arg0, EVCD)
            Notify (WMI0, 0x80)
        }

        Method (WSMI, 1, Serialized)
        {
            Store (Arg0, WMIS)
            \_SB.BSMI (0xDF)
        }

        Name (WQBA, Buffer (0x0914)
        {
            /* 0000 */    0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
            /* 0008 */    0x04, 0x09, 0x00, 0x00, 0x50, 0x67, 0x00, 0x00, 
            /* 0010 */    0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
            /* 0018 */    0x28, 0xC7, 0xB2, 0x00, 0x01, 0x06, 0x18, 0x42, 
            /* 0020 */    0x10, 0x2B, 0x10, 0x92, 0x2B, 0x81, 0x42, 0x04, 
            /* 0028 */    0x0A, 0x44, 0x24, 0x81, 0x30, 0x28, 0x0D, 0x20, 
            /* 0030 */    0x92, 0x03, 0x21, 0x17, 0x4C, 0x4C, 0x80, 0x08, 
            /* 0038 */    0x08, 0x79, 0x15, 0x60, 0x53, 0x80, 0x49, 0x10, 
            /* 0040 */    0xF5, 0xEF, 0x0F, 0x51, 0x12, 0x1C, 0x4A, 0x08, 
            /* 0048 */    0x84, 0x24, 0x0A, 0x30, 0x2F, 0x40, 0xB7, 0x00, 
            /* 0050 */    0xC3, 0x02, 0x6C, 0x0B, 0x30, 0x2D, 0xC0, 0x31, 
            /* 0058 */    0x24, 0x95, 0x06, 0x4E, 0x09, 0x2C, 0x05, 0x42, 
            /* 0060 */    0x42, 0x05, 0x28, 0x17, 0xE0, 0x5B, 0x80, 0x76, 
            /* 0068 */    0x44, 0x49, 0x16, 0xB0, 0xA3, 0x30, 0x09, 0x3C, 
            /* 0070 */    0x8A, 0xC8, 0x46, 0xE3, 0xD0, 0xD8, 0x61, 0x58, 
            /* 0078 */    0x26, 0x98, 0x06, 0x71, 0x18, 0x65, 0x23, 0x8B, 
            /* 0080 */    0xC0, 0x13, 0xEA, 0x74, 0x74, 0x05, 0x08, 0x13, 
            /* 0088 */    0x20, 0x1E, 0x55, 0x18, 0xCD, 0x41, 0x91, 0x08, 
            /* 0090 */    0xD0, 0x28, 0x31, 0x63, 0x22, 0xB0, 0x9D, 0x63, 
            /* 0098 */    0x6B, 0x14, 0xA7, 0x51, 0xB8, 0x00, 0xE9, 0x18, 
            /* 00A0 */    0x1A, 0xC1, 0x71, 0x85, 0xF7, 0xC8, 0x8E, 0x90, 
            /* 00A8 */    0x59, 0x1C, 0x8B, 0x20, 0x43, 0x85, 0xEB, 0x10, 
            /* 00B0 */    0x4E, 0x73, 0x32, 0xC8, 0x89, 0x9C, 0x49, 0xEC, 
            /* 00B8 */    0x08, 0x05, 0x09, 0xB0, 0x8E, 0x21, 0xA4, 0x58, 
            /* 00C0 */    0x51, 0x6A, 0xC6, 0xD3, 0x0C, 0x82, 0x34, 0x0A, 
            /* 00C8 */    0xA5, 0xC9, 0x79, 0x00, 0x61, 0xC2, 0xC3, 0x20, 
            /* 00D0 */    0x30, 0xFE, 0x11, 0x61, 0x64, 0x40, 0xC8, 0x33, 
            /* 00D8 */    0xB2, 0x86, 0x6A, 0x02, 0xBB, 0x17, 0xE0, 0x6C, 
            /* 00E0 */    0x6A, 0x32, 0x36, 0x39, 0x29, 0x9B, 0x1D, 0x41, 
            /* 00E8 */    0x68, 0x0B, 0x5E, 0xDA, 0x04, 0x18, 0x04, 0x13, 
            /* 00F0 */    0x4A, 0x24, 0x0F, 0xE5, 0x78, 0xA2, 0x54, 0x88, 
            /* 00F8 */    0xA4, 0xF1, 0xC5, 0x88, 0x52, 0x1C, 0x8A, 0x60, 
            /* 0100 */    0x23, 0xB6, 0x86, 0x21, 0x98, 0x98, 0x21, 0xE3, 
            /* 0108 */    0x07, 0xB7, 0xFD, 0x83, 0x01, 0x53, 0x00, 0xD1, 
            /* 0110 */    0x02, 0x88, 0x22, 0x8D, 0x06, 0x75, 0x18, 0x48, 
            /* 0118 */    0xF0, 0x70, 0xE0, 0x71, 0x9E, 0xD6, 0xF9, 0x1D, 
            /* 0120 */    0xD7, 0x41, 0x04, 0x39, 0xE1, 0xE3, 0xAA, 0xF3, 
            /* 0128 */    0x54, 0x40, 0x46, 0xC6, 0xFE, 0xFF, 0x58, 0x09, 
            /* 0130 */    0x3A, 0x38, 0x26, 0x40, 0x71, 0x0D, 0xA8, 0x69, 
            /* 0138 */    0x3E, 0x1D, 0xB0, 0x81, 0x86, 0xC3, 0x0C, 0xD1, 
            /* 0140 */    0xA3, 0x0D, 0x77, 0x02, 0x87, 0xC8, 0x00, 0x3D, 
            /* 0148 */    0xA2, 0x07, 0x03, 0xEC, 0x10, 0x4F, 0xE6, 0x25, 
            /* 0150 */    0xA0, 0x54, 0x01, 0x66, 0x4F, 0x08, 0x9A, 0x76, 
            /* 0158 */    0x82, 0xE3, 0xF1, 0x71, 0xC0, 0xF3, 0x39, 0xE1, 
            /* 0160 */    0x04, 0x96, 0x3F, 0x08, 0xD4, 0xC8, 0x0C, 0xED, 
            /* 0168 */    0x71, 0x9E, 0xD6, 0x5B, 0x81, 0x8F, 0x00, 0x26, 
            /* 0170 */    0xB0, 0x58, 0x08, 0x6D, 0x52, 0xE3, 0x01, 0x02, 
            /* 0178 */    0x8A, 0x0F, 0x05, 0x42, 0x78, 0x75, 0xF0, 0x7C, 
            /* 0180 */    0x4D, 0x30, 0x32, 0x84, 0x9C, 0x8C, 0x07, 0x35, 
            /* 0188 */    0x0A, 0x83, 0xD6, 0x0A, 0xAE, 0x9B, 0x40, 0x02, 
            /* 0190 */    0x47, 0x84, 0xD0, 0x67, 0xC3, 0xA2, 0x86, 0x4D, 
            /* 0198 */    0x8F, 0x16, 0xFC, 0x54, 0xC1, 0x20, 0xCF, 0xE0, 
            /* 01A0 */    0x11, 0xC0, 0x23, 0x39, 0x21, 0x1F, 0x3E, 0x3C, 
            /* 01A8 */    0x30, 0xF8, 0xB3, 0xF0, 0x91, 0x02, 0x1C, 0x1E, 
            /* 01B0 */    0xC1, 0x84, 0xF3, 0x0A, 0x01, 0x6B, 0xA4, 0xF0, 
            /* 01B8 */    0x6F, 0x11, 0x46, 0xF6, 0xA9, 0xE1, 0xB5, 0x21, 
            /* 01C0 */    0x81, 0x0F, 0x1E, 0x81, 0xB1, 0x43, 0xB5, 0x5F, 
            /* 01C8 */    0x01, 0x08, 0xC1, 0xA3, 0x3D, 0x0A, 0x3C, 0x7B, 
            /* 01D0 */    0x44, 0x78, 0xDC, 0xC0, 0xFC, 0xFF, 0x8F, 0x1B, 
            /* 01D8 */    0xB0, 0x09, 0x8A, 0x1C, 0x20, 0x7A, 0x0C, 0xFC, 
            /* 01E0 */    0x04, 0x71, 0x0A, 0xF1, 0xC3, 0x1F, 0xC3, 0x11, 
            /* 01E8 */    0x45, 0x89, 0x7C, 0x48, 0x3E, 0x9C, 0x18, 0xE1, 
            /* 01F0 */    0x10, 0x9E, 0x49, 0xCE, 0xC0, 0x07, 0x0C, 0x4F, 
            /* 01F8 */    0xEB, 0x14, 0x5E, 0x24, 0x3C, 0x02, 0x4C, 0xA0, 
            /* 0200 */    0x43, 0x0C, 0x8D, 0xB2, 0x7E, 0x45, 0x80, 0x41, 
            /* 0208 */    0x9D, 0x63, 0x00, 0x57, 0x30, 0xCF, 0x31, 0xE0, 
            /* 0210 */    0x3B, 0x3E, 0xF0, 0x6B, 0x00, 0xE6, 0x7C, 0xF2, 
            /* 0218 */    0x14, 0x03, 0x07, 0x97, 0x81, 0xBC, 0x04, 0xC4, 
            /* 0220 */    0x79, 0x77, 0xF1, 0xCD, 0xC4, 0xD7, 0x02, 0xE3, 
            /* 0228 */    0x3E, 0xC4, 0x80, 0x61, 0x60, 0x0F, 0x31, 0xE0, 
            /* 0230 */    0xFC, 0xFF, 0x1F, 0x62, 0xE0, 0x05, 0x3F, 0xC4, 
            /* 0238 */    0x00, 0x34, 0x91, 0x77, 0xBE, 0x90, 0x91, 0x55, 
            /* 0240 */    0xF8, 0x10, 0x83, 0xBA, 0x21, 0x9C, 0xCF, 0x43, 
            /* 0248 */    0xCA, 0xD3, 0x01, 0x93, 0x73, 0xCE, 0xA0, 0x87, 
            /* 0250 */    0x18, 0xE0, 0x01, 0x88, 0xF7, 0x3E, 0x65, 0x32, 
            /* 0258 */    0x82, 0x33, 0x35, 0xA0, 0x51, 0x7D, 0xAE, 0x00, 
            /* 0260 */    0xC7, 0x79, 0x82, 0xFF, 0xFF, 0xCF, 0x13, 0x18, 
            /* 0268 */    0xBC, 0xD7, 0x0A, 0x76, 0x0C, 0x60, 0x67, 0x0A, 
            /* 0270 */    0x38, 0x57, 0x0A, 0x9F, 0x5A, 0x7C, 0x4E, 0xF0, 
            /* 0278 */    0x18, 0xF9, 0x58, 0x0C, 0x1A, 0xF2, 0x41, 0xC0, 
            /* 0280 */    0x0B, 0xB4, 0xAC, 0xB3, 0x0D, 0x68, 0x2E, 0x13, 
            /* 0288 */    0xCF, 0x3D, 0xD8, 0xA3, 0x0D, 0x18, 0x90, 0x2A, 
            /* 0290 */    0xBD, 0x05, 0xE8, 0x02, 0x82, 0x23, 0xF0, 0xC1, 
            /* 0298 */    0x06, 0xF8, 0xC4, 0x3A, 0xD5, 0xD0, 0x30, 0x63, 
            /* 02A0 */    0x54, 0x10, 0x18, 0xD4, 0xC1, 0x06, 0x70, 0x75, 
            /* 02A8 */    0xE8, 0xF0, 0xC1, 0x06, 0x3C, 0xFF, 0xFF, 0x11, 
            /* 02B0 */    0xB2, 0xC1, 0x9C, 0x44, 0x98, 0xA3, 0x08, 0xF6, 
            /* 02B8 */    0x2C, 0xE1, 0x9B, 0x0D, 0x78, 0xB0, 0xB1, 0x27, 
            /* 02C0 */    0x1B, 0xB0, 0x9C, 0x09, 0x9E, 0x6C, 0x80, 0x49, 
            /* 02C8 */    0xF8, 0x93, 0x0D, 0x40, 0x1E, 0xD8, 0x27, 0x81, 
            /* 02D0 */    0x77, 0x80, 0xFF, 0xFF, 0x93, 0x0D, 0x60, 0xF1, 
            /* 02D8 */    0x4A, 0x81, 0x3D, 0xD9, 0x40, 0x5E, 0xBC, 0x4E, 
            /* 02E0 */    0x36, 0xE0, 0x3A, 0x03, 0x82, 0xED, 0x08, 0x02, 
            /* 02E8 */    0xF3, 0x6C, 0x03, 0x9C, 0xCE, 0x80, 0xC0, 0xE1, 
            /* 02F0 */    0xFF, 0x7F, 0x06, 0x04, 0x1C, 0x9E, 0x5B, 0x9E, 
            /* 02F8 */    0x01, 0xC1, 0x75, 0xF2, 0x64, 0x67, 0x40, 0x70, 
            /* 0300 */    0xA1, 0x3C, 0x03, 0x02, 0x66, 0xFF, 0xFF, 0x67, 
            /* 0308 */    0x40, 0xC0, 0xD2, 0xE9, 0x80, 0x9D, 0x01, 0x01, 
            /* 0310 */    0x4E, 0xFD, 0xFF, 0x2F, 0x20, 0xFC, 0x0C, 0x08, 
            /* 0318 */    0x30, 0xEC, 0x66, 0x03, 0x1B, 0x1B, 0x7B, 0xB2, 
            /* 0320 */    0x01, 0xCB, 0x19, 0x10, 0x77, 0xB2, 0x01, 0xEF, 
            /* 0328 */    0xFF, 0xFF, 0x0C, 0x08, 0x30, 0xE9, 0x64, 0x03, 
            /* 0330 */    0x58, 0xFB, 0xFF, 0x9F, 0x01, 0x01, 0x63, 0x67, 
            /* 0338 */    0x1B, 0x60, 0x75, 0x06, 0x04, 0xBC, 0xFF, 0xFF, 
            /* 0340 */    0xCF, 0x80, 0xF8, 0x63, 0xCB, 0x33, 0x20, 0xB8, 
            /* 0348 */    0x70, 0x9F, 0x01, 0xC1, 0x87, 0xF1, 0x0C, 0x08, 
            /* 0350 */    0xF0, 0xEF, 0x74, 0xC0, 0x8E, 0x36, 0xFC, 0xFF, 
            /* 0358 */    0x7F, 0x06, 0x04, 0x18, 0x75, 0x10, 0x60, 0x67, 
            /* 0360 */    0x40, 0xC0, 0xD3, 0xFF, 0xFF, 0x0C, 0x08, 0x58, 
            /* 0368 */    0xBB, 0xD9, 0xC0, 0xC6, 0xC6, 0x9E, 0x6C, 0xC0, 
            /* 0370 */    0x72, 0x06, 0xC4, 0x9D, 0x6C, 0xC0, 0x7F, 0x06, 
            /* 0378 */    0x04, 0x5C, 0xFD, 0xFF, 0xCF, 0x80, 0x80, 0x95, 
            /* 0380 */    0x93, 0x0D, 0xE0, 0xF1, 0x0C, 0x08, 0xF8, 0x39, 
            /* 0388 */    0x0A, 0xFC, 0xFF, 0x9F, 0x01, 0x01, 0x6E, 0xCD, 
            /* 0390 */    0xE1, 0x19, 0x10, 0x5C, 0x33, 0xF3, 0x19, 0x10, 
            /* 0398 */    0x6C, 0xF7, 0x1A, 0x9F, 0x01, 0xC1, 0xFF, 0xFF, 
            /* 03A0 */    0x3F, 0x03, 0x02, 0xEC, 0x39, 0x1D, 0xB0, 0xA3, 
            /* 03A8 */    0x0D, 0xE0, 0xEE, 0xFF, 0x7F, 0x06, 0x04, 0xEC, 
            /* 03B0 */    0x1C, 0x04, 0xD8, 0x19, 0x10, 0xE0, 0xD6, 0xFF, 
            /* 03B8 */    0xFF, 0x66, 0x03, 0x1F, 0x1B, 0x7B, 0xB2, 0x01, 
            /* 03C0 */    0xCB, 0x19, 0x10, 0x77, 0xB2, 0x01, 0xFF, 0x19, 
            /* 03C8 */    0x10, 0x60, 0xD0, 0xC9, 0x06, 0xF6, 0xFF, 0xFF, 
            /* 03D0 */    0x0C, 0x08, 0x30, 0xE9, 0x6C, 0x03, 0xAC, 0xCE, 
            /* 03D8 */    0x80, 0xC0, 0xEF, 0xFF, 0x7F, 0x06, 0x04, 0x3C, 
            /* 03E0 */    0xDD, 0x5B, 0x9E, 0x01, 0xC1, 0x85, 0xFB, 0x0C, 
            /* 03E8 */    0x08, 0x3E, 0x88, 0x67, 0x40, 0xC0, 0xFA, 0xFF, 
            /* 03F0 */    0xFF, 0x0C, 0x08, 0x98, 0x38, 0x1D, 0xB0, 0x33, 
            /* 03F8 */    0x20, 0xC0, 0xAC, 0x83, 0x00, 0x3B, 0xD8, 0xE0, 
            /* 0400 */    0xFF, 0xFF, 0x67, 0x40, 0x80, 0x4D, 0x37, 0x1B, 
            /* 0408 */    0xD8, 0xD8, 0xD8, 0x93, 0x0D, 0x58, 0xCE, 0x80, 
            /* 0410 */    0xB8, 0x93, 0x0D, 0xF8, 0xCF, 0x80, 0x70, 0xFE, 
            /* 0418 */    0xFF, 0x67, 0x40, 0x80, 0x2D, 0x27, 0x1B, 0xC0, 
            /* 0420 */    0xE3, 0x95, 0x02, 0xF3, 0xFF, 0x3F, 0x03, 0x02, 
            /* 0428 */    0x56, 0xCE, 0x36, 0xC0, 0xEA, 0x0C, 0x08, 0xF0, 
            /* 0430 */    0xE0, 0xE0, 0xF2, 0x66, 0x83, 0xF9, 0xFF, 0x9F, 
            /* 0438 */    0x01, 0xC1, 0x80, 0xFB, 0x0C, 0x08, 0xBE, 0xFB, 
            /* 0440 */    0xC1, 0x33, 0x20, 0xC0, 0xBF, 0xD3, 0x01, 0x3B, 
            /* 0448 */    0xDA, 0x80, 0xE3, 0xFF, 0x7F, 0x06, 0x04, 0x58, 
            /* 0450 */    0x73, 0x10, 0x60, 0x67, 0x40, 0xC0, 0xE1, 0xFF, 
            /* 0458 */    0xFF, 0x0C, 0x08, 0x98, 0xB9, 0xD9, 0xC0, 0xC6, 
            /* 0460 */    0xC6, 0x9E, 0x6C, 0xC0, 0x72, 0x06, 0xC4, 0x9D, 
            /* 0468 */    0x6C, 0xC0, 0x7F, 0x06, 0x04, 0x3C, 0xFE, 0xFF, 
            /* 0470 */    0xCF, 0x80, 0xC0, 0xFC, 0x64, 0x03, 0x78, 0x3C, 
            /* 0478 */    0x03, 0x02, 0x7E, 0xCE, 0x36, 0xB0, 0xFF, 0xFF, 
            /* 0480 */    0x67, 0x40, 0x80, 0x3F, 0xDE, 0xCE, 0x80, 0x20, 
            /* 0488 */    0xC3, 0x7D, 0x06, 0x04, 0xDF, 0xFD, 0xE0, 0x19, 
            /* 0490 */    0x10, 0xD8, 0xFD, 0xFF, 0xCF, 0x80, 0x00, 0x43, 
            /* 0498 */    0x4E, 0x07, 0xEC, 0x0C, 0x08, 0x78, 0xFD, 0xFF, 
            /* 04A0 */    0x9F, 0x01, 0x01, 0x03, 0x07, 0x01, 0x76, 0x06, 
            /* 04A8 */    0x04, 0xD8, 0x75, 0xB3, 0x81, 0xF9, 0xFF, 0xBF, 
            /* 04B0 */    0x60, 0xC1, 0x38, 0xD9, 0x80, 0xE5, 0x0C, 0x88, 
            /* 04B8 */    0x3B, 0xD9, 0x80, 0xFF, 0x0C, 0x08, 0x30, 0xE8, 
            /* 04C0 */    0x64, 0x03, 0xE6, 0xFF, 0xFF, 0x19, 0x10, 0x60, 
            /* 04C8 */    0xCB, 0xD9, 0x06, 0x58, 0x9D, 0x01, 0x81, 0xFB, 
            /* 04D0 */    0xFF, 0xFF, 0x0C, 0x08, 0xB8, 0x38, 0x1A, 0x3C, 
            /* 04D8 */    0x03, 0x82, 0xEB, 0x96, 0xE0, 0x33, 0x20, 0xD8, 
            /* 04E0 */    0xEE, 0x07, 0xCF, 0x80, 0x00, 0x23, 0xFE, 0xFF, 
            /* 04E8 */    0x67, 0x40, 0x60, 0x7B, 0x3A, 0x60, 0x67, 0x40, 
            /* 04F0 */    0x80, 0x59, 0x07, 0x01, 0x76, 0xB0, 0x01, 0xD7, 
            /* 04F8 */    0xFF, 0xFF, 0x0C, 0x08, 0x30, 0xE6, 0x66, 0x03, 
            /* 0500 */    0x1B, 0x1B, 0x7B, 0xB2, 0x01, 0xCB, 0x19, 0x10, 
            /* 0508 */    0x77, 0xB2, 0x01, 0xFF, 0x19, 0x10, 0x7C, 0xFF, 
            /* 0510 */    0xFF, 0x33, 0x20, 0xC0, 0x88, 0x93, 0x0D, 0xE0, 
            /* 0518 */    0xF1, 0x0C, 0x08, 0x96, 0xFF, 0xFF, 0x19, 0x10, 
            /* 0520 */    0x98, 0x9F, 0x6D, 0x80, 0x55, 0xB4, 0x83, 0x0D, 
            /* 0528 */    0x2A, 0xCC, 0xD9, 0x06, 0x10, 0x3D, 0xEF, 0x87, 
            /* 0530 */    0x0F, 0x1F, 0x0C, 0x7C, 0x10, 0xC0, 0xDC, 0x6C, 
            /* 0538 */    0xE0, 0xDC, 0x2A, 0x7C, 0x5D, 0xF1, 0x41, 0xC4, 
            /* 0540 */    0x87, 0x07, 0xF6, 0xFF, 0x87, 0x8A, 0x13, 0x9E, 
            /* 0548 */    0x9F, 0x1C, 0x7C, 0xB6, 0x81, 0x7D, 0x9A, 0x79, 
            /* 0550 */    0x08, 0xC4, 0x21, 0x3C, 0xDB, 0x80, 0xFD, 0x4D, 
            /* 0558 */    0xE1, 0x63, 0x81, 0xCF, 0x36, 0x00, 0x3F, 0x44, 
            /* 0560 */    0x1C, 0x30, 0xE4, 0x64, 0x3C, 0xA8, 0x51, 0x58, 
            /* 0568 */    0xE3, 0x25, 0x81, 0x4C, 0xDB, 0x04, 0x43, 0x43, 
            /* 0570 */    0xE8, 0xB4, 0xE4, 0xB3, 0x0D, 0x38, 0xFF, 0xFF, 
            /* 0578 */    0x67, 0x1B, 0x70, 0x9E, 0x4E, 0xF0, 0x67, 0x1B, 
            /* 0580 */    0x30, 0x9D, 0x25, 0x30, 0x04, 0x1E, 0x32, 0xFC, 
            /* 0588 */    0xD3, 0x0C, 0x3F, 0x3E, 0xBC, 0x3F, 0x24, 0xF0, 
            /* 0590 */    0xB9, 0x0F, 0x6C, 0xA7, 0x0E, 0x38, 0x87, 0x19, 
            /* 0598 */    0x60, 0x32, 0x26, 0xDC, 0x91, 0xC2, 0x43, 0xE0, 
            /* 05A0 */    0x03, 0x68, 0x75, 0x7E, 0xE4, 0x58, 0x78, 0x56, 
            /* 05A8 */    0xB8, 0xB3, 0x0C, 0x1F, 0x15, 0xE6, 0x74, 0x83, 
            /* 05B0 */    0x8B, 0xF2, 0x3E, 0x30, 0x81, 0x82, 0xBC, 0x0B, 
            /* 05B8 */    0x24, 0xF2, 0x81, 0x40, 0x61, 0x7C, 0xBA, 0x01, 
            /* 05C0 */    0x8E, 0xFF, 0xFF, 0xD3, 0x0D, 0xF0, 0x98, 0xA4, 
            /* 05C8 */    0x4F, 0x37, 0x60, 0x83, 0x88, 0x18, 0xAC, 0x68, 
            /* 05D0 */    0x30, 0xDD, 0x9A, 0x70, 0xB7, 0x1B, 0x1C, 0x5E, 
            /* 05D8 */    0xB8, 0x18, 0xA7, 0xC3, 0x10, 0xA2, 0x3C, 0xB0, 
            /* 05E0 */    0x18, 0x99, 0x1F, 0x03, 0xC1, 0x70, 0x9B, 0x79, 
            /* 05E8 */    0xB6, 0x01, 0x2E, 0xE1, 0x0E, 0x05, 0xFA, 0x43, 
            /* 05F0 */    0xF9, 0x6C, 0x03, 0xF8, 0xFC, 0xFF, 0x9F, 0x6D, 
            /* 05F8 */    0x80, 0xCF, 0x41, 0x04, 0x77, 0x32, 0x01, 0xC3, 
            /* 0600 */    0x89, 0x01, 0xD6, 0xB1, 0x0D, 0xB8, 0x88, 0x5B, 
            /* 0608 */    0xA9, 0x4E, 0x3B, 0x16, 0x06, 0x22, 0x1B, 0x87, 
            /* 0610 */    0x45, 0x3A, 0x54, 0x0B, 0xA1, 0xD2, 0x90, 0x7C, 
            /* 0618 */    0x04, 0x3A, 0xBB, 0x47, 0x85, 0xE7, 0x04, 0x01, 
            /* 0620 */    0x09, 0xD4, 0x10, 0x0E, 0x0F, 0xA1, 0xE8, 0xA3, 
            /* 0628 */    0xA1, 0xC0, 0x0E, 0x0B, 0x46, 0x41, 0x3C, 0x7A, 
            /* 0630 */    0x07, 0x81, 0xD0, 0xA1, 0x08, 0x7F, 0x62, 0xF0, 
            /* 0638 */    0x7C, 0xDE, 0xF8, 0x4D, 0xF0, 0xB0, 0xF1, 0xB4, 
            /* 0640 */    0x00, 0xEB, 0x62, 0xE0, 0x63, 0x00, 0x3F, 0x13, 
            /* 0648 */    0xE2, 0x0F, 0xFD, 0x26, 0xE0, 0xC7, 0x1E, 0xF0, 
            /* 0650 */    0x09, 0x3C, 0x0D, 0x80, 0x02, 0xC8, 0x93, 0xF7, 
            /* 0658 */    0xB1, 0xE6, 0x01, 0x80, 0xCD, 0xE1, 0xC9, 0xC6, 
            /* 0660 */    0x68, 0xFF, 0xFF, 0x47, 0x1A, 0x9C, 0x8C, 0x95, 
            /* 0668 */    0xEA, 0x4B, 0xE3, 0x33, 0xA3, 0xC7, 0xC5, 0xCF, 
            /* 0670 */    0x03, 0x3E, 0xB8, 0xB0, 0xB3, 0x01, 0xEE, 0x0C, 
            /* 0678 */    0x85, 0x81, 0xF5, 0x48, 0x39, 0xAC, 0xD1, 0xC2, 
            /* 0680 */    0x1E, 0xF0, 0x43, 0x83, 0x2F, 0x1C, 0x9E, 0x99, 
            /* 0688 */    0xCF, 0x28, 0x3E, 0x6A, 0x80, 0xE5, 0x38, 0x05, 
            /* 0690 */    0xFF, 0xB0, 0x82, 0x3B, 0xC9, 0xC0, 0x9D, 0xE6, 
            /* 0698 */    0x23, 0xC1, 0xA3, 0x9E, 0x87, 0x1E, 0xDE, 0x47, 
            /* 06A0 */    0x18, 0xCF, 0x2E, 0x88, 0xAF, 0x9D, 0xFC, 0xF2, 
            /* 06A8 */    0x7D, 0x5A, 0xBE, 0xEF, 0xF8, 0xE8, 0x63, 0xA0, 
            /* 06B0 */    0x27, 0x86, 0xA8, 0xAF, 0x27, 0x9E, 0x00, 0xBF, 
            /* 06B8 */    0x50, 0x38, 0xC6, 0xA9, 0x88, 0x06, 0x5A, 0xA9, 
            /* 06C0 */    0xA4, 0xAE, 0x99, 0xC2, 0xF8, 0x54, 0x04, 0xB8, 
            /* 06C8 */    0x8A, 0x30, 0x78, 0x50, 0xFC, 0xFF, 0x4F, 0x45, 
            /* 06D0 */    0xD8, 0x1B, 0x86, 0x2F, 0x03, 0x3E, 0x14, 0x81, 
            /* 06D8 */    0xE5, 0x40, 0xE2, 0x89, 0xBD, 0x04, 0xF8, 0xDC, 
            /* 06E0 */    0x80, 0xC3, 0x39, 0x03, 0x7E, 0x32, 0x02, 0xC3, 
            /* 06E8 */    0x5D, 0xFB, 0xC9, 0x08, 0xB8, 0x44, 0x3B, 0x19, 
            /* 06F0 */    0x01, 0x34, 0x39, 0xDF, 0xE1, 0xFE, 0xFF, 0x27, 
            /* 06F8 */    0x23, 0x30, 0x9C, 0x1A, 0x60, 0x1C, 0x8C, 0x80, 
            /* 0700 */    0x8B, 0xA4, 0x83, 0x11, 0x95, 0x73, 0x30, 0x82, 
            /* 0708 */    0x72, 0x84, 0xC0, 0x1D, 0x8C, 0xC0, 0x3F, 0xA6, 
            /* 0710 */    0x33, 0x7A, 0x1D, 0x38, 0x75, 0x1F, 0x8C, 0x00, 
            /* 0718 */    0x73, 0xC3, 0xF5, 0xC1, 0x08, 0xF8, 0xFC, 0xFF, 
            /* 0720 */    0x0F, 0x46, 0xC0, 0xE5, 0x70, 0xE1, 0x83, 0x11, 
            /* 0728 */    0xB8, 0x0F, 0x0B, 0xFC, 0x10, 0x83, 0x25, 0x28, 
            /* 0730 */    0xFE, 0x35, 0x64, 0x02, 0x85, 0x5A, 0xA4, 0x24, 
            /* 0738 */    0x2F, 0x97, 0xC2, 0xF8, 0x4C, 0x04, 0xB8, 0x8A, 
            /* 0740 */    0x71, 0x26, 0x02, 0x21, 0xC6, 0xE3, 0xB1, 0x11, 
            /* 0748 */    0xCF, 0x38, 0x6C, 0xB8, 0xE7, 0x8B, 0xA7, 0x22, 
            /* 0750 */    0xB0, 0xCF, 0xE1, 0x0C, 0xFA, 0xBC, 0x6E, 0xE9, 
            /* 0758 */    0x54, 0x84, 0xFF, 0xFF, 0x9F, 0x8A, 0x60, 0x1C, 
            /* 0760 */    0x83, 0x9E, 0x8A, 0x80, 0x4B, 0xBC, 0x53, 0x11, 
            /* 0768 */    0x40, 0x93, 0x13, 0xC4, 0x53, 0x11, 0xB8, 0xCE, 
            /* 0770 */    0x0D, 0x30, 0xCF, 0x45, 0xE0, 0xFB, 0xFF, 0x9F, 
            /* 0778 */    0x8B, 0xE0, 0x3E, 0x08, 0x7C, 0x18, 0x22, 0xE7, 
            /* 0780 */    0x22, 0x74, 0x78, 0x2A, 0x1D, 0x22, 0x70, 0xB1, 
            /* 0788 */    0xCF, 0x45, 0x74, 0xD8, 0x0E, 0x4C, 0xA2, 0x43, 
            /* 0790 */    0xBD, 0xCF, 0x45, 0x3C, 0xE6, 0x91, 0x86, 0x82, 
            /* 0798 */    0x18, 0xD0, 0x19, 0xCE, 0x45, 0x68, 0x15, 0xE7, 
            /* 07A0 */    0x22, 0xE4, 0x20, 0xDF, 0x16, 0xD8, 0xEC, 0x7C, 
            /* 07A8 */    0x0F, 0xE0, 0x37, 0x15, 0x5F, 0x8B, 0x18, 0x6E, 
            /* 07B0 */    0x35, 0xD7, 0x1D, 0x14, 0x98, 0x6F, 0x45, 0x18, 
            /* 07B8 */    0x5D, 0xA7, 0x22, 0x90, 0xE9, 0xBB, 0x14, 0x81, 
            /* 07C0 */    0x1C, 0x9D, 0x9F, 0xA8, 0xC0, 0x87, 0xFF, 0x3C, 
            /* 07C8 */    0xE0, 0x21, 0x3C, 0x51, 0xC1, 0x3D, 0x13, 0xBC, 
            /* 07D0 */    0xF5, 0xF8, 0x44, 0x05, 0xFB, 0x90, 0x4B, 0x4E, 
            /* 07D8 */    0x54, 0x40, 0xE3, 0xFF, 0x7F, 0xA2, 0x02, 0x5F, 
            /* 07E0 */    0xEC, 0x13, 0x15, 0xA0, 0xE7, 0x08, 0x82, 0x3B, 
            /* 07E8 */    0xB9, 0x82, 0xF5, 0x98, 0x81, 0x51, 0x68, 0xD3, 
            /* 07F0 */    0xA7, 0x46, 0xA3, 0x56, 0x0D, 0xCA, 0xD4, 0x28, 
            /* 07F8 */    0xD3, 0xA0, 0x56, 0x9F, 0x4A, 0x8D, 0x19, 0xBB, 
            /* 0800 */    0x0F, 0x58, 0xE2, 0x3B, 0x41, 0xC3, 0x75, 0x40, 
            /* 0808 */    0x10, 0x1A, 0x89, 0x42, 0x20, 0x8E, 0xF2, 0xA7, 
            /* 0810 */    0x10, 0x88, 0x85, 0x78, 0x00, 0x61, 0x42, 0x57, 
            /* 0818 */    0x24, 0x10, 0x8B, 0x5B, 0x9B, 0x40, 0x1C, 0x0D, 
            /* 0820 */    0x84, 0x46, 0x5F, 0x9D, 0x40, 0x1C, 0xD8, 0x07, 
            /* 0828 */    0x08, 0x93, 0xFB, 0x26, 0x10, 0x88, 0xE3, 0x18, 
            /* 0830 */    0x01, 0x61, 0x11, 0x5E, 0x54, 0x3A, 0x06, 0x10, 
            /* 0838 */    0x2B, 0x20, 0x4C, 0xA0, 0x16, 0x10, 0x26, 0xCB, 
            /* 0840 */    0x0C, 0x08, 0x0B, 0x05, 0x42, 0x43, 0x7F, 0x39, 
            /* 0848 */    0x04, 0xE2, 0xA0, 0x76, 0x40, 0x98, 0x4C, 0x3D, 
            /* 0850 */    0x20, 0x2C, 0x86, 0x1F, 0x10, 0x26, 0x5E, 0xD1, 
            /* 0858 */    0x60, 0x28, 0x08, 0x95, 0xF6, 0xE6, 0xD2, 0x61, 
            /* 0860 */    0x82, 0x78, 0x02, 0x61, 0x61, 0x40, 0xE8, 0xFF, 
            /* 0868 */    0x3F, 0xAC, 0x28, 0x10, 0x16, 0xD1, 0xD5, 0x60, 
            /* 0870 */    0xE8, 0xDB, 0x40, 0x20, 0x0E, 0xF0, 0x4C, 0x0A, 
            /* 0878 */    0x42, 0x44, 0x3F, 0x25, 0x04, 0xE2, 0xC8, 0x20, 
            /* 0880 */    0x54, 0xD2, 0x1F, 0x42, 0x43, 0x25, 0x7F, 0xA5, 
            /* 0888 */    0x83, 0x61, 0x20, 0x34, 0xE6, 0x83, 0xE9, 0x50, 
            /* 0890 */    0xD9, 0x5F, 0x4B, 0x20, 0x16, 0xA6, 0x0E, 0x84, 
            /* 0898 */    0x09, 0x77, 0x37, 0x54, 0xFA, 0x19, 0xD1, 0x60, 
            /* 08A0 */    0x08, 0x08, 0x15, 0xF3, 0xA8, 0xD0, 0x50, 0xC9, 
            /* 08A8 */    0x83, 0x22, 0x08, 0x91, 0x0F, 0x42, 0xE3, 0xBD, 
            /* 08B0 */    0x04, 0x34, 0x54, 0xF2, 0x21, 0xD0, 0x60, 0xC8, 
            /* 08B8 */    0x1B, 0x47, 0x20, 0x96, 0xFC, 0x4A, 0xD3, 0x50, 
            /* 08C0 */    0xC9, 0x43, 0x41, 0x20, 0x0E, 0x09, 0x42, 0x45, 
            /* 08C8 */    0xBC, 0x72, 0x82, 0x90, 0xF0, 0xCF, 0x8B, 0x20, 
            /* 08D0 */    0x44, 0xBA, 0xD1, 0x41, 0xD0, 0xE7, 0xC5, 0x83, 
            /* 08D8 */    0x01, 0xB3, 0x0A, 0xC2, 0x04, 0x69, 0x1D, 0x36, 
            /* 08E0 */    0x7D, 0x28, 0x14, 0xF0, 0x15, 0xD0, 0xE1, 0x20, 
            /* 08E8 */    0x88, 0x80, 0x2C, 0xD2, 0xED, 0x80, 0x29, 0x08, 
            /* 08F0 */    0x15, 0x63, 0x17, 0x90, 0x49, 0x03, 0x11, 0x90, 
            /* 08F8 */    0xE3, 0x0A, 0x06, 0x61, 0x62, 0x5F, 0x14, 0x41, 
            /* 0900 */    0x48, 0xAE, 0xE7, 0x51, 0x40, 0x12, 0x12, 0x44, 
            /* 0908 */    0xC7, 0x03, 0xF2, 0x84, 0x13, 0x90, 0xC3, 0x81, 
            /* 0910 */    0x08, 0xC8, 0xFF, 0x7F
        })
        Name (WMIP, Zero)
        Method (INIT, 1, NotSerialized)
        {
            Store (One, WMIP)
            Store (One, \_SB.ATKP)
            WINI (Arg0)
            Return (Zero)
        }

        Name (PCDV, Zero)
        Method (WDOG, 1, NotSerialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Store (PTIM, PCDV)
                Return (0x3C)
            }

            If (LEqual (Arg0, One))
            {
                If (\_SB.LID._LID ())
                {
                    Store (PTIM, PCDV)
                    Return (One)
                }

                If (LLess (\_TZ.RLTM (), PTMP))
                {
                    Store (PTIM, PCDV)
                    Return (One)
                }

                Decrement (PCDV)
                If (LEqual (PCDV, Zero))
                {
                    Store (PTIM, PCDV)
                    NTFY (0x6D)
                }

                Return (One)
            }

            Return (Zero)
        }

        Method (_WED, 1, NotSerialized)
        {
            Return (Arg0)
        }

        Method (WMIG, 3, Serialized)
        {
            AGFN (Arg0)
            Store (CWMI (Arg0), Local0)
            If (LEqual (Local0, Zero))
            {
                Return (Zero)
            }

            Store (And (ShiftRight (Local0, 0x10), 0xFFFF), Local1)
            And (Local0, 0xFFFF, Local0)
            If (CWAC (Arg0))
            {
                Return (Zero)
            }

            If (LAnd (LEqual (Local0, 0x15), LEqual (Local1, 0x05)))
            {
                WSMI (Arg2)
                Return (Zero)
            }

            If (Or (LEqual (Local0, 0x64), LEqual (Local0, 0x67)))
            {
                WSMI (Arg2)
                Return (Zero)
            }

            Store (GLEN (Arg0), Local2)
            WGLN (Arg0, Arg1, Local0, Local1, Arg2)
            OperationRegion (\WMIF, SystemMemory, Arg0, 0x0100)
            Field (WMIF, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                REST,   8
            }

            If (LNotEqual (STAS, One))
            {
                Return (Zero)
            }

            Store (0x82, STAS)
            Store (One, REST)
            Return (Zero)
        }

        Method (CWMI, 1, NotSerialized)
        {
            OperationRegion (\WMID, SystemMemory, Arg0, 0x0100)
            Field (WMID, DWordAcc, NoLock, Preserve)
            {
                FUNC,   32, 
                LEN,    16, 
                STAS,   8, 
                REST,   8
            }

            If (LEqual (And (REST, One), Zero))
            {
                Return (Zero)
            }

            Store (One, STAS)
            Store (Zero, REST)
            Return (FUNC)
        }

        Method (CWAC, 1, NotSerialized)
        {
            OperationRegion (\WMIC, SystemMemory, Arg0, 0x0100)
            Field (WMIC, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x07), 
                REST,   8
            }

            \_SB.BSMI (0xDE)
            Return (REST)
        }

        Method (WINI, 1, NotSerialized)
        {
            WOEM (Arg0)
        }

        Method (WGLN, 5, NotSerialized)
        {
            WFLH (Arg0, Arg1, Arg2, Arg3, Arg4)
            OWST (Arg0, Arg1, Arg2, Arg3, Arg4)
            BBSF (Arg0, Arg1, Arg2, Arg3, Arg4)
            HWID (Arg0, Arg1, Arg2, Arg3, Arg4)
        }

        Method (MF20, 4, NotSerialized)
        {
            If (LEqual (Arg1, 0x20))
            {
                OperationRegion (F020, SystemMemory, Arg0, 0x08)
                Field (F020, DWordAcc, NoLock, Preserve)
                {
                    MFUN,   16, 
                    SFUN,   16, 
                    LEN,    16, 
                    STAS,   8, 
                    EROR,   8
                }

                \_SB.BSMI (Arg0)
                And (STAS, 0xFE, STAS)
            }
        }

        Method (AGFN, 1, Serialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Return (GNBF)
            }

            Store (AGFB (Arg0), Local0)
            Store (And (ShiftRight (Local0, 0x10), 0xFFFF), Local1)
            And (Local0, 0xFFFF, Local0)
            Store (GLEN (Arg0), Local2)
            If (LEqual (Local0, One))
            {
                GVER (Arg0, Local2)
                And (STAS, 0xFE, STAS)
            }

            If (LEqual (Local0, 0x02))
            {
                \_SB.BSMI (Arg0)
                And (STAS, 0xFE, STAS)
            }

            AGLN (Arg0, Local0, Local1, Local2)
            OperationRegion (\PARM, SystemMemory, Arg0, 0x08)
            Field (PARM, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8
            }

            If (LEqual (STAS, One))
            {
                Store (One, EROR)
                Or (STAS, 0x02, STAS)
            }

            And (STAS, 0xFE, STAS)
            Or (STAS, 0x80, STAS)
            Return (Zero)
        }

        Method (AGFB, 1, NotSerialized)
        {
            OperationRegion (\PAR, SystemMemory, Arg0, 0x08)
            Field (PAR, DWordAcc, NoLock, Preserve)
            {
                FUNC,   32, 
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8
            }

            Store (Zero, EROR)
            Store (One, STAS)
            Return (FUNC)
        }

        Method (GLEN, 1, NotSerialized)
        {
            OperationRegion (\PARL, SystemMemory, Arg0, 0x08)
            Field (PARL, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x04), 
                LEN,    16
            }

            Return (LEN)
        }

        Method (GVER, 2, NotSerialized)
        {
            OperationRegion (\FGVR, SystemMemory, Arg0, Arg1)
            Field (FGVR, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                APID,   16, 
                APRV,   32
            }

            If (LLess (Arg1, 0x0E))
            {
                Return (0x02)
            }

            If (And (APID, One))
            {
                \_SB.PCI0.LPC0.EC.PKEN (One)
            }
            Else
            {
                \_SB.PCI0.LPC0.EC.PKEN (Zero)
            }

            Return (Zero)
        }

        Method (GENS, 1, NotSerialized)
        {
        }

        Method (GENW, 1, NotSerialized)
        {
            Store (Zero, RTCW)
        }

        Method (OFBD, 1, NotSerialized)
        {
            Name (FBDT, Package (0x05)
            {
                0xF0, 
                0xF1, 
                0xF2, 
                0xF3, 
                0xF6
            })
            Store (Match (FBDT, MEQ, Arg0, MTR, Zero, Zero), Local0)
            If (LLess (Local0, Ones)) {}
            Increment (Local0)
            Return (Local0)
        }

        Method (GBRV, 0, NotSerialized)
        {
            Name (BBUF, Buffer (0x0E)
            {
                /* 0000 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00
            })
            Store (ToDecimalString (BIMA), Index (BBUF, Zero))
            Store (0x2E, Index (BBUF, One))
            Divide (BIMI, 0x0A, Local0, Local1)
            Store (ToDecimalString (Local1), Index (BBUF, 0x02))
            Store (ToDecimalString (Local0), Index (BBUF, 0x03))
            Return (BBUF)
        }

        Method (GBMN, 0, NotSerialized)
        {
            Store ("PLCSC", Local0)
            Return (Local0)
        }

        Method (GERV, 0, NotSerialized)
        {
            Name (BBUF, Buffer (0x0E)
            {
                /* 0000 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00
            })
            Store (ToDecimalString (ECMA), Index (BBUF, Zero))
            Store (0x2E, Index (BBUF, One))
            Divide (ECMI, 0x0A, Local0, Local1)
            Store (ToDecimalString (Local1), Index (BBUF, 0x02))
            Store (ToDecimalString (Local0), Index (BBUF, 0x03))
            Return (BBUF)
        }

        Method (HWSP, 4, NotSerialized)
        {
            If (LEqual (Arg1, 0x21))
            {
                If (LEqual (Arg2, One))
                {
                    OperationRegion (HW11, SystemMemory, Arg0, Arg3)
                    Field (HW11, AnyAcc, NoLock, Preserve)
                    {
                                Offset (0x06), 
                        HS1S,   8, 
                        HS1E,   8, 
                        HS1F,   8, 
                        HREV,   16, 
                                Offset (0x10), 
                        PO1S,   8, 
                        WO2B,   8, 
                        US3L,   8, 
                        US4S,   8, 
                        WO5N,   8, 
                        BI6N,   8, 
                        WL7W,   8, 
                        IM8D,   8, 
                        KB9L,   8, 
                        KBAT,   8, 
                        KBBZ,   8, 
                        FNCT,   8, 
                        FNDB,   8, 
                        ESET,   8, 
                        SIFS,   8, 
                        FS0B,   8, 
                        US1S,   8, 
                        PO2D,   8, 
                        FNKM,   8, 
                        US43,   8, 
                        CD5P,   8, 
                        RSV0,   88
                    }

                    Name (FUSD, Buffer (0x0B)
                    {
                        /* 0000 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0008 */    0xFF, 0xFF, 0xFF
                    })
                    CopyObject (FUSD, RSV0)
                    If (LEqual (HS1F, Zero))
                    {
                        Store (0x21, SWMF)
                        Store (One, SWSF)
                        Store (HS1F, PAR0)
                        \_SB.BSMI (0xD5)
                        Store (0x02, HREV)
                        Store (DA00, PO1S)
                        Store (DA01, WO2B)
                        Store (DA02, US3L)
                        Store (DA03, US4S)
                        Store (DA04, WO5N)
                        Store (DA05, BI6N)
                        Store (DA06, WL7W)
                        Store (DA07, IM8D)
                        Store (DA08, KB9L)
                        Store (DA09, KBAT)
                        Store (DA10, KBBZ)
                        Store (DA11, FNCT)
                        Store (DA12, FNDB)
                        Store (DA13, ESET)
                        Store (DA14, SIFS)
                        Store (DA15, FS0B)
                        Store (DA16, US1S)
                        Store (DA17, PO2D)
                        If (LEqual (KBTY, Zero))
                        {
                            Store (0xFF, FNKM)
                        }
                        Else
                        {
                            If (LEqual (FUNK, Zero))
                            {
                                Store (One, FNKM)
                            }
                            Else
                            {
                                Store (Zero, FNKM)
                            }
                        }

                        Store (DA19, US43)
                        Store (DA20, CD5P)
                    }

                    If (LEqual (HS1F, One))
                    {
                        Store (0x02, HREV)
                        Store (PO1S, DA00)
                        Store (WO2B, DA01)
                        Store (US3L, DA02)
                        Store (US4S, DA03)
                        Store (WO5N, DA04)
                        Store (BI6N, DA05)
                        Store (WL7W, DA06)
                        Store (IM8D, DA07)
                        Store (KB9L, DA08)
                        Store (KBAT, DA09)
                        Store (KBBZ, DA10)
                        Store (FNCT, DA11)
                        Store (FNDB, DA12)
                        Store (ESET, DA13)
                        Store (SIFS, DA14)
                        Store (FS0B, DA15)
                        Store (US1S, DA16)
                        Store (PO2D, DA17)
                        If (LEqual (FNKM, Zero))
                        {
                            Store (One, FUNK)
                            \_SB.VALZ.FKMC (One)
                        }
                        Else
                        {
                            Store (Zero, FUNK)
                            \_SB.VALZ.FKMC (Zero)
                        }

                        Store (US43, DA19)
                        Store (CD5P, DA20)
                        Store (0x21, SWMF)
                        Store (One, SWSF)
                        Store (HS1F, PAR0)
                        \_SB.BSMI (0xD5)
                    }

                    If (LEqual (HS1F, 0x02))
                    {
                        Store (0x02, HREV)
                        Store (0x21, SWMF)
                        Store (One, SWSF)
                        Store (HS1F, PAR0)
                        \_SB.BSMI (0xD5)
                        Store (DA00, PO1S)
                        Store (DA01, WO2B)
                        Store (DA02, US3L)
                        Store (DA03, US4S)
                        Store (DA04, WO5N)
                        Store (DA05, BI6N)
                        Store (DA06, WL7W)
                        Store (DA07, IM8D)
                        Store (DA08, KB9L)
                        Store (DA09, KBAT)
                        Store (DA10, KBBZ)
                        Store (DA11, FNCT)
                        Store (DA12, FNDB)
                        Store (DA13, ESET)
                        Store (DA14, SIFS)
                        Store (DA15, FS0B)
                        Store (DA16, US1S)
                        Store (DA17, PO2D)
                        If (LEqual (KBTY, Zero))
                        {
                            Store (0xFF, FNKM)
                        }
                        Else
                        {
                            If (LEqual (FUNK, Zero))
                            {
                                Store (One, FNKM)
                            }
                            Else
                            {
                                Store (Zero, FNKM)
                            }
                        }

                        Store (DA19, US43)
                        Store (DA20, CD5P)
                    }

                    Store (0x80, HS1S)
                    Store (Zero, HS1E)
                }
                Else
                {
                    If (LLess (Arg2, 0x03))
                    {
                        Store (0x21, SWMF)
                        Store (0x02, SWSF)
                        Store (Arg0, BAPI)
                        \_SB.BSMI (0xD5)
                    }
                }
            }
        }

        Method (OWST, 5, NotSerialized)
        {
            If (LAnd (LEqual (Arg2, 0x21), LEqual (Arg3, 0x03)))
            {
                Store (0x21, SWMF)
                Store (0x03, SWSF)
                Store (Arg0, BAPI)
                Store (Arg4, XMIS)
                \_SB.BSMI (0xD5)
            }
        }

        Method (BBSF, 5, NotSerialized)
        {
            If (LEqual (Arg2, 0x21))
            {
                If (LEqual (Arg3, 0x04))
                {
                    Store (0x21, SWMF)
                    Store (0x04, SWSF)
                    Store (Arg0, BAPI)
                    \_SB.BSMI (0xD5)
                    Return (Zero)
                }
            }
        }

        Method (HWID, 5, NotSerialized)
        {
            If (LEqual (Arg2, 0x17))
            {
                If (LEqual (Arg3, 0x04))
                {
                    Store (0x17, SWMF)
                    Store (0x04, SWSF)
                    Store (Arg0, BAPI)
                    \_SB.BSMI (0xD5)
                }
            }
        }

        Method (WOEM, 1, NotSerialized)
        {
        }

        Method (FSMI, 1, NotSerialized)
        {
            Store (Arg0, FSFN)
            Or (Arg0, 0xA0, Local0)
            \_SB.BSMI (0xDC)
            Return (FSTA)
        }

        Method (FLSH, 1, NotSerialized)
        {
            Store (Arg0, FSTA)
            FSMI (Zero)
        }

        Method (FINI, 1, NotSerialized)
        {
            Store (Arg0, FADR)
            Return (FSMI (One))
        }

        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 (Zero, 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))
        }

        Method (ECSR, 1, NotSerialized)
        {
            Store (Arg0, FSTA)
            Return (FSMI (0x07))
        }

        Method (FLSC, 1, NotSerialized)
        {
            Store (Arg0, FSTA)
            Return (FSMI (0x08))
        }

        Method (WFLH, 5, Serialized)
        {
            If (LEqual (Arg2, 0x66))
            {
                If (LEqual (Arg3, One))
                {
                    OperationRegion (WFLS, SystemMemory, Arg0, 0x0100)
                    Field (WFLS, DWordAcc, NoLock, Preserve)
                    {
                                Offset (0x06), 
                        STAS,   8, 
                        REST,   8, 
                        FSFN,   8, 
                        FSTA,   16, 
                        FADR,   32, 
                        FSIZ,   16
                    }

                    Store (0x90, TRTY)
                    Store (FSFN, FSFN)
                    Store (FSTA, FSTA)
                    Store (FADR, FADR)
                    Store (FSIZ, FSIZ)
                    If (LEqual (FSFN, One))
                    {
                        Store (Arg1, FADR)
                    }
                    Else
                    {
                        If (LEqual (FSFN, 0x80))
                        {
                            Store (Arg1, FADR)
                            Store (0x012C, Local0)
                            While (LAnd (Local0, TRTY))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }
                        }
                    }

                    \_SB.BSMI (0xDC)
                    Store (FSFN, FSFN)
                    Store (FSTA, FSTA)
                    Store (FADR, FADR)
                    Store (FSIZ, FSIZ)
                    And (STAS, 0xFE, STAS)
                    Or (STAS, 0x80, STAS)
                    Return (Zero)
                }
                Else
                {
                    WSMI (Arg4)
                    Return (Zero)
                }

                Return (Zero)
            }

            Return (Zero)
        }

        Method (FIN2, 1, NotSerialized)
        {
            Store (Zero, FSTA)
            Return (FSMI (0x80))
        }

        Method (AGLN, 4, NotSerialized)
        {
            CPUX (Arg0, Arg1, Arg2, Arg3)
            MF1X (Arg0, Arg1, Arg2, Arg3)
            MF63 (Arg0, Arg1, Arg2, Arg3)
            MF30 (Arg0, Arg1, Arg2, Arg3)
            HWSP (Arg0, Arg1, Arg2, Arg3)
            XPAP (Arg0, Arg1, Arg2, Arg3)
            MF1F (Arg0, Arg1, Arg2, Arg3)
        }

        Method (MF63, 4, NotSerialized)
        {
            If (LNotEqual (Arg1, 0x63))
            {
                Return (Zero)
            }

            If (LEqual (Arg2, One))
            {
                M631 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x02))
            {
                M632 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x03))
            {
                M633 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x04))
            {
                M634 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x05))
            {
                M635 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x06))
            {
                M636 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x07))
            {
                M637 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x08))
            {
                M638 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x09))
            {
                M639 (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x0A))
            {
                M63A (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x0B))
            {
                M63B (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x0C))
            {
                M63C (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x0D))
            {
                M63D (Arg0, Arg1)
            }

            If (LEqual (Arg2, 0x0E))
            {
                M63E (Arg0, Arg1)
            }

            Return (Zero)
        }

        Method (M631, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x10)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                TSXR,   8, 
                TSXL,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x03E2), TSXR)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x03E3), TSXL)
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x03E0), TSXR)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x03E1), TSXL)
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M632, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x10)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                DEVS,   8, 
                DEVT,   16
            }

            Store (0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (DEVS, Zero))
            {
                Store (TJMX, DEVT)
            }
            Else
            {
                If (LEqual (DEVS, One))
                {
                    Store (\_SB.PCI0.LPC0.EC.PCPT, DEVT)
                }
                Else
                {
                    If (LEqual (DEVS, 0x02))
                    {
                        Store (Zero, DEVT)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }

            Return (Zero)
        }

        Method (M633, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x10)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FANX,   8, 
                FANS,   8, 
                FANT,   16, 
                TRGG,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FANX, Zero))
            {
                Store (\_SB.PCI0.LPC0.EC.F0CS, FANS)
                Store (\_SB.PCI0.LPC0.EC.F0TS, FANT)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0576), TRGG)
            }
            Else
            {
                If (LEqual (FANX, One))
                {
                    Store (\_SB.PCI0.LPC0.EC.F1CS, FANS)
                    Store (\_SB.PCI0.LPC0.EC.F1TS, FANT)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0577), TRGG)
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M634, 2, Serialized)
        {
            Name (_T_1, Zero)
            Name (_T_0, Zero)
            OperationRegion (FM63, SystemMemory, Arg0, 0x10)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                PARA,   8, 
                DATA,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                While (One)
                {
                    Store (ToInteger (PARA), _T_0)
                    If (LEqual (_T_0, Zero))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x0521), DATA)
                    }
                    Else
                    {
                        If (LEqual (_T_0, One))
                        {
                            Store (\_SB.PCI0.LPC0.EC.RRAM (0x0522), DATA)
                        }
                        Else
                        {
                            If (LEqual (_T_0, 0x02))
                            {
                                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0523), DATA)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x03))
                                {
                                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0524), DATA)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x04))
                                    {
                                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x0509), DATA)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x05))
                                        {
                                            Store (\_SB.PCI0.LPC0.EC.RRAM (0x050A), DATA)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x06))
                                            {
                                                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0568), DATA)
                                            }
                                            Else
                                            {
                                                Store (0x80, SM63)
                                                Store (One, EM63)
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Break
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    While (One)
                    {
                        Store (ToInteger (PARA), _T_1)
                        If (LEqual (_T_1, Zero))
                        {
                            \_SB.PCI0.LPC0.EC.WRAM (0x0521, DATA)
                        }
                        Else
                        {
                            If (LEqual (_T_1, One))
                            {
                                \_SB.PCI0.LPC0.EC.WRAM (0x0522, DATA)
                            }
                            Else
                            {
                                If (LEqual (_T_1, 0x02))
                                {
                                    \_SB.PCI0.LPC0.EC.WRAM (0x0523, DATA)
                                }
                                Else
                                {
                                    If (LEqual (_T_1, 0x03))
                                    {
                                        \_SB.PCI0.LPC0.EC.WRAM (0x0524, DATA)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_1, 0x04))
                                        {
                                            \_SB.PCI0.LPC0.EC.WRAM (0x0509, DATA)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_1, 0x05))
                                            {
                                                \_SB.PCI0.LPC0.EC.WRAM (0x050A, DATA)
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_1, 0x06))
                                                {
                                                    \_SB.PCI0.LPC0.EC.WRAM (0x0568, DATA)
                                                }
                                                Else
                                                {
                                                    Store (0x80, SM63)
                                                    Store (One, EM63)
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Break
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M635, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x10)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                ECSD,   8, 
                OSSD,   8, 
                OSPV,   8, 
                THON,   8, 
                THOF,   8, 
                FNER,   8, 
                VGSD,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0530), ECSD)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0531), OSSD)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0532), OSPV)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0533), THON)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0534), THOF)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0535), FNER)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0536), VGSD)
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    \_SB.PCI0.LPC0.EC.WRAM (0x0530, ECSD)
                    \_SB.PCI0.LPC0.EC.WRAM (0x0531, OSSD)
                    \_SB.PCI0.LPC0.EC.WRAM (0x0532, OSPV)
                    \_SB.PCI0.LPC0.EC.WRAM (0x0533, THON)
                    \_SB.PCI0.LPC0.EC.WRAM (0x0534, THOF)
                    \_SB.PCI0.LPC0.EC.WRAM (0x0535, FNER)
                    \_SB.PCI0.LPC0.EC.WRAM (0x0536, VGSD)
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M636, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x20)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                ALGM,   8, 
                TTS1,   8, 
                TTS2,   8, 
                TTS3,   8, 
                TTS4,   8, 
                TTS5,   8, 
                TTS6,   8, 
                TTS7,   8, 
                TTS8,   8, 
                TFFP,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                If (LEqual (ALGM, Zero))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0537), TTS1)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0538), TTS2)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0539), TTS3)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x053A), TTS4)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x053B), TTS5)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x053C), TTS6)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x053D), TTS7)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x053E), TTS8)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x053F), TFFP)
                }
                Else
                {
                    If (LEqual (ALGM, One))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x0597), TTS1)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x0598), TTS2)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x0599), TTS3)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x059A), TTS4)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x059B), TTS5)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x059C), TTS6)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x059D), TTS7)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x059E), TTS8)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x059F), TFFP)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    If (LEqual (ALGM, Zero))
                    {
                        \_SB.PCI0.LPC0.EC.WRAM (0x0537, TTS1)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0538, TTS2)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0539, TTS3)
                        \_SB.PCI0.LPC0.EC.WRAM (0x053A, TTS4)
                        \_SB.PCI0.LPC0.EC.WRAM (0x053B, TTS5)
                        \_SB.PCI0.LPC0.EC.WRAM (0x053C, TTS6)
                        \_SB.PCI0.LPC0.EC.WRAM (0x053D, TTS7)
                        \_SB.PCI0.LPC0.EC.WRAM (0x053E, TTS8)
                        \_SB.PCI0.LPC0.EC.WRAM (0x053F, TFFP)
                    }
                    Else
                    {
                        If (LEqual (ALGM, One))
                        {
                            \_SB.PCI0.LPC0.EC.WRAM (0x0597, TTS1)
                            \_SB.PCI0.LPC0.EC.WRAM (0x0598, TTS2)
                            \_SB.PCI0.LPC0.EC.WRAM (0x0599, TTS3)
                            \_SB.PCI0.LPC0.EC.WRAM (0x059A, TTS4)
                            \_SB.PCI0.LPC0.EC.WRAM (0x059B, TTS5)
                            \_SB.PCI0.LPC0.EC.WRAM (0x059C, TTS6)
                            \_SB.PCI0.LPC0.EC.WRAM (0x059D, TTS7)
                            \_SB.PCI0.LPC0.EC.WRAM (0x059E, TTS8)
                            \_SB.PCI0.LPC0.EC.WRAM (0x059F, TFFP)
                        }
                        Else
                        {
                            Store (0x80, SM63)
                            Store (One, EM63)
                        }
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }
        }

        Method (M637, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x20)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                ALGM,   8, 
                TDA1,   8, 
                TDA2,   8, 
                TDA3,   8, 
                TDA4,   8, 
                TDA5,   8, 
                TDA6,   8, 
                TDA7,   8, 
                TDA8,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                If (LEqual (ALGM, Zero))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0548), TDA1)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0549), TDA2)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x054A), TDA3)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x054B), TDA4)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x054C), TDA5)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x054D), TDA6)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x054E), TDA7)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x054F), TDA8)
                }
                Else
                {
                    If (LEqual (ALGM, One))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A8), TDA1)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A9), TDA2)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05AA), TDA3)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05AB), TDA4)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05AC), TDA5)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05AD), TDA6)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05AE), TDA7)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05AF), TDA8)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    If (LEqual (ALGM, Zero))
                    {
                        \_SB.PCI0.LPC0.EC.WRAM (0x0548, TDA1)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0549, TDA2)
                        \_SB.PCI0.LPC0.EC.WRAM (0x054A, TDA3)
                        \_SB.PCI0.LPC0.EC.WRAM (0x054B, TDA4)
                        \_SB.PCI0.LPC0.EC.WRAM (0x054C, TDA5)
                        \_SB.PCI0.LPC0.EC.WRAM (0x054D, TDA6)
                        \_SB.PCI0.LPC0.EC.WRAM (0x054E, TDA7)
                        \_SB.PCI0.LPC0.EC.WRAM (0x054F, TDA8)
                    }
                    Else
                    {
                        If (LEqual (ALGM, One))
                        {
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A8, TDA1)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A9, TDA2)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05AA, TDA3)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05AB, TDA4)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05AC, TDA5)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05AD, TDA6)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05AE, TDA7)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05AF, TDA8)
                        }
                        Else
                        {
                            Store (0x80, SM63)
                            Store (One, EM63)
                        }
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }
        }

        Method (M638, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x20)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                ALGM,   8, 
                ASC1,   8, 
                ASC2,   8, 
                ASC3,   8, 
                ASC4,   8, 
                ADA1,   8, 
                ADA2,   8, 
                ADA3,   8, 
                ADA4,   8, 
                DSC1,   8, 
                DSC2,   8, 
                DSC3,   8, 
                DSC4,   8, 
                DDA1,   8, 
                DDA2,   8, 
                DDA3,   8, 
                DDA4,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                If (LEqual (ALGM, Zero))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0550), ASC1)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0551), ASC2)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0552), ASC3)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0553), ASC4)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0554), ADA1)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0555), ADA2)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0556), ADA3)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0557), ADA4)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0558), DSC1)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0559), DSC2)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x055A), DSC3)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x055B), DSC4)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x055C), DDA1)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x055D), DDA2)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x055E), DDA3)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x055F), DDA4)
                }
                Else
                {
                    If (LEqual (ALGM, One))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B0), ASC1)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B1), ASC2)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B2), ASC3)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B3), ASC4)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B4), ADA1)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B5), ADA2)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B6), ADA3)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B7), ADA4)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B8), DSC1)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05B9), DSC2)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05BA), DSC3)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05BB), DSC4)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05BC), DDA1)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05BD), DDA2)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05BE), DDA3)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05BF), DDA4)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    If (LEqual (ALGM, Zero))
                    {
                        \_SB.PCI0.LPC0.EC.WRAM (0x0550, ASC1)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0551, ASC2)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0552, ASC3)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0553, ASC4)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0554, ADA1)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0555, ADA2)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0556, ADA3)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0557, ADA4)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0558, DSC1)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0559, DSC2)
                        \_SB.PCI0.LPC0.EC.WRAM (0x055A, DSC3)
                        \_SB.PCI0.LPC0.EC.WRAM (0x055B, DSC4)
                        \_SB.PCI0.LPC0.EC.WRAM (0x055C, DDA1)
                        \_SB.PCI0.LPC0.EC.WRAM (0x055D, DDA2)
                        \_SB.PCI0.LPC0.EC.WRAM (0x055E, DDA3)
                        \_SB.PCI0.LPC0.EC.WRAM (0x055F, DDA4)
                    }
                    Else
                    {
                        If (LEqual (ALGM, One))
                        {
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B0, ASC1)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B1, ASC2)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B2, ASC3)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B3, ASC4)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B4, ADA1)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B5, ADA2)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B6, ADA3)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B7, ADA4)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B8, DSC1)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05B9, DSC2)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05BA, DSC3)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05BB, DSC4)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05BC, DDA1)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05BD, DDA2)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05BE, DDA3)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05BF, DDA4)
                        }
                        Else
                        {
                            Store (0x80, SM63)
                            Store (One, EM63)
                        }
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }
        }

        Method (M639, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x20)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                ALGM,   8, 
                HYS1,   8, 
                HYS2,   8, 
                HYS3,   8, 
                HYS4,   8, 
                HYS5,   8, 
                HYS6,   8, 
                HYS7,   8, 
                HYS8,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                If (LEqual (ALGM, Zero))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0540), HYS1)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0541), HYS2)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0542), HYS3)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0543), HYS4)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0544), HYS5)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0545), HYS6)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0546), HYS7)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0547), HYS8)
                }
                Else
                {
                    If (LEqual (ALGM, One))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A0), HYS1)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A1), HYS2)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A2), HYS3)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A3), HYS4)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A4), HYS5)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A5), HYS6)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A6), HYS7)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05A7), HYS8)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    If (LEqual (ALGM, Zero))
                    {
                        \_SB.PCI0.LPC0.EC.WRAM (0x0540, HYS1)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0541, HYS2)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0542, HYS3)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0543, HYS4)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0544, HYS5)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0545, HYS6)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0546, HYS7)
                        \_SB.PCI0.LPC0.EC.WRAM (0x0547, HYS8)
                    }
                    Else
                    {
                        If (LEqual (ALGM, One))
                        {
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A0, HYS1)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A1, HYS2)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A2, HYS3)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A3, HYS4)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A4, HYS5)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A5, HYS6)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A6, HYS7)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05A7, HYS8)
                        }
                        Else
                        {
                            Store (0x80, SM63)
                            Store (One, EM63)
                        }
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M63A, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x20)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                FANX,   8, 
                TA1L,   8, 
                TA1H,   8, 
                TA2L,   8, 
                TA2H,   8, 
                TA3L,   8, 
                TA3H,   8, 
                TA4L,   8, 
                TA4H,   8, 
                TA5L,   8, 
                TA5H,   8, 
                TA6L,   8, 
                TA6H,   8, 
                TA7L,   8, 
                TA7H,   8, 
                TA8L,   8, 
                TA8H,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                If (LEqual (FANX, Zero))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C0), TA1L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C1), TA1H)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C2), TA2L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C3), TA2H)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C4), TA3L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C5), TA3H)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C6), TA4L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C7), TA4H)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C8), TA5L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05C9), TA5H)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05CA), TA6L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05CB), TA6H)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05CC), TA7L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05CD), TA7H)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05CE), TA8L)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x05CF), TA8H)
                }
                Else
                {
                    If (LEqual (FANX, One))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D0), TA1L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D1), TA1H)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D2), TA2L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D3), TA2H)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D4), TA3L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D5), TA3H)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D6), TA4L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D7), TA4H)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D8), TA5L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05D9), TA5H)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05DA), TA6L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05DB), TA6H)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05DC), TA7L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05DD), TA7H)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05DE), TA8L)
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x05DF), TA8H)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    If (LEqual (FANX, Zero))
                    {
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C0, TA1L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C1, TA1H)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C2, TA2L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C3, TA2H)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C4, TA3L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C5, TA3H)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C6, TA4L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C7, TA4H)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C8, TA5L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05C9, TA5H)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05CA, TA6L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05CB, TA6H)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05CC, TA7L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05CD, TA7H)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05CE, TA8L)
                        \_SB.PCI0.LPC0.EC.WRAM (0x05CF, TA8H)
                    }
                    Else
                    {
                        If (LEqual (FANX, One))
                        {
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D0, TA1L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D1, TA1H)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D2, TA2L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D3, TA2H)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D4, TA3L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D5, TA3H)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D6, TA4L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D7, TA4H)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D8, TA5L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05D9, TA5H)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05DA, TA6L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05DB, TA6H)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05DC, TA7L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05DD, TA7H)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05DE, TA8L)
                            \_SB.PCI0.LPC0.EC.WRAM (0x05DF, TA8H)
                        }
                        Else
                        {
                            Store (0x80, SM63)
                            Store (One, EM63)
                        }
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M63B, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x20)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                PARA,   8, 
                DATA,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                If (LEqual (PARA, Zero))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0569), DATA)
                }
                Else
                {
                    If (LEqual (PARA, One))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x056A), DATA)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    If (LEqual (PARA, Zero))
                    {
                        \_SB.PCI0.LPC0.EC.WRAM (0x0569, DATA)
                    }
                    Else
                    {
                        If (LEqual (PARA, One))
                        {
                            \_SB.PCI0.LPC0.EC.WRAM (0x056A, DATA)
                        }
                        Else
                        {
                            Store (0x80, SM63)
                            Store (One, EM63)
                        }
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M63C, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x20)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                DATA,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0511), DATA)
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x0512), DATA)
                }
                Else
                {
                    If (LEqual (FUNC, 0x02))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RRAM (0x0513), DATA)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }

            Return (Zero)
        }

        Method (M63D, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x10)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                FREQ,   16
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                Store (0x017D7840, Local0)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0xF4A0), Local1)
                Add (Local1, One, Local1)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0xF4A2), Local2)
                Add (Local2, One, Local2)
                Multiply (Local2, Local1, Local2)
                Divide (Local0, Local2, Local3, Local1)
                Store (Local1, FREQ)
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    Store (Zero, FREQ)
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (M63E, 2, NotSerialized)
        {
            OperationRegion (FM63, SystemMemory, Arg0, 0x10)
            Field (FM63, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM63,   8, 
                EM63,   8, 
                FUNC,   8, 
                FANX,   8, 
                FAND,   8
            }

            Or (SM63, 0x80, SM63)
            Store (Zero, EM63)
            If (LEqual (FUNC, Zero))
            {
                If (LEqual (FANX, Zero))
                {
                    Store (\_SB.PCI0.LPC0.EC.RFOV (Zero), FAND)
                }
                Else
                {
                    If (LEqual (FANX, One))
                    {
                        Store (\_SB.PCI0.LPC0.EC.RFOV (One), FAND)
                    }
                    Else
                    {
                        Store (0x80, SM63)
                        Store (One, EM63)
                    }
                }
            }
            Else
            {
                If (LEqual (FUNC, One))
                {
                    If (LEqual (FANX, Zero))
                    {
                        \_SB.PCI0.LPC0.EC.WFOV (Zero, FAND)
                    }
                    Else
                    {
                        If (LEqual (FANX, One))
                        {
                            \_SB.PCI0.LPC0.EC.WFOV (One, FAND)
                        }
                        Else
                        {
                            Store (0x80, SM63)
                            Store (One, EM63)
                        }
                    }
                }
                Else
                {
                    Store (0x80, SM63)
                    Store (One, EM63)
                }
            }

            Return (Zero)
        }

        Method (MF30, 4, NotSerialized)
        {
            OperationRegion (FM30, SystemMemory, Arg0, 0x08)
            Field (FM30, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM30,   8, 
                EM30,   8
            }

            If (LNotEqual (Arg1, 0x30))
            {
                Return (Zero)
            }

            Store (0xFF, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G30V (Arg0, Arg3), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (EC01 (Arg0, Arg3), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (EC02 (Arg0, Arg3), Local0)
            }

            If (LEqual (Arg2, 0x03))
            {
                Store (EC03 (Arg0, Arg3), Local0)
            }

            If (LEqual (Arg2, 0x84))
            {
                Store (EC84 (Arg0, Arg3), Local0)
            }

            And (Arg2, 0xFC, Local2)
            If (LEqual (Local2, 0x80))
            {
                Store (Arg0, BAPI)
                ISMI (0xD8)
                Return (Zero)
            }

            If (LEqual (Local0, 0xFF))
            {
                Return (Zero)
            }

            If (Local0)
            {
                Store (Local0, EM30)
                Or (SM30, 0x02, SM30)
            }

            And (SM30, 0xFE, SM30)
            Or (SM30, 0x80, SM30)
            Return (Zero)
        }

        Method (G30V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F300, SystemMemory, Arg0, Arg1)
            Field (F300, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (EC01, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x10))
            {
                Return (0x02)
            }

            OperationRegion (FEC1, SystemMemory, Arg0, Arg1)
            Field (FEC1, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                ECMD,   8, 
                EDA1,   8, 
                EDA2,   8, 
                EDA3,   8, 
                EDA4,   8, 
                EDA5,   8
            }

            Store (\_SB.PCI0.LPC0.EC.ECXT (ECMD, EDA1, EDA2, EDA3, EDA4, EDA5), Local0)
            Store (DerefOf (Index (Local0, One)), EDA1)
            Store (DerefOf (Index (Local0, One)), EDA2)
            Store (DerefOf (Index (Local0, One)), EDA3)
            Store (DerefOf (Index (Local0, One)), EDA4)
            Store (DerefOf (Index (Local0, One)), EDA5)
            Return (DerefOf (Index (Local0, Zero)))
        }

        Method (EC02, 2, NotSerialized)
        {
            Return (Zero)
        }

        Method (EC03, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x09))
            {
                Return (0x02)
            }

            Store (Zero, Local0)
            OperationRegion (FEC3, SystemMemory, Arg0, Arg1)
            Field (FEC3, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                FNEN,   8
            }

            If (FNEN)
            {
                \_SB.PCI0.LPC0.EC.FNLK (One)
            }
            Else
            {
                \_SB.PCI0.LPC0.EC.FNLK (Zero)
            }

            Return (Zero)
        }

        Method (EC84, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (ECEG, SystemMemory, Arg0, Arg1)
            Field (ECEG, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                EVTP,   8, 
                EVID,   8
            }

            \_SB.PCI0.LPC0.EC.ECXT (0xAE, EVTP, EVID, Zero, Zero, Zero)
            Return (Zero)
        }

        Method (CPUX, 4, NotSerialized)
        {
            If (LEqual (Arg1, 0x31))
            {
                If (LEqual (Arg2, 0x02))
                {
                    GCPU (Arg0, Arg1, Arg2, Arg3)
                    Return (Zero)
                }

                If (LEqual (Arg2, 0x03))
                {
                    SCPU (Arg0, Arg1, Arg2, Arg3)
                    Return (Zero)
                }
            }

            Return (Zero)
        }

        Method (GCPU, 4, NotSerialized)
        {
            OperationRegion (\F31A, SystemMemory, Arg0, 0x10)
            Field (F31A, DWordAcc, NoLock, Preserve)
            {
                MFUN,   16, 
                SFUN,   16, 
                LEN,    16, 
                STAS,   8, 
                EROR,   8, 
                PSIN,   16
            }

            Store (PSTC (Zero), PSIN)
            Store (0x80, STAS)
        }

        Method (SCPU, 4, NotSerialized)
        {
            OperationRegion (\F31B, SystemMemory, Arg0, 0x10)
            Field (F31B, DWordAcc, NoLock, Preserve)
            {
                MFUN,   16, 
                SFUN,   16, 
                LEN,    16, 
                STAS,   8, 
                EROR,   8, 
                PSTL,   8
            }

            If (PSTC (PSTL))
            {
                Store (0x82, STAS)
                Store (One, EROR)
            }
            Else
            {
                Store (0x80, STAS)
            }
        }

        Method (PSTC, 1, Serialized)
        {
            Return (Zero)
        }

        Method (GBTL, 0, Serialized)
        {
            Return (Zero)
        }

        Method (SBTL, 1, Serialized)
        {
        }

        Method (WLED, 1, NotSerialized)
        {
        }

        Method (GPLV, 0, NotSerialized)
        {
            Return (BRTL)
        }

        Method (SPLV, 1, NotSerialized)
        {
        }

        Method (SDSP, 1, NotSerialized)
        {
            SWHG (Arg0)
        }

        Method (MF1X, 4, NotSerialized)
        {
            If (LNotEqual (And (Arg1, 0xF0), 0x10))
            {
                Return (Zero)
            }

            OperationRegion (FM1X, SystemMemory, Arg0, 0x08)
            Field (FM1X, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                SM1X,   8, 
                EM1X,   8
            }

            Store (One, Local0)
            If (LEqual (Arg1, 0x10))
            {
                Store (MF10 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x11))
            {
                Store (MF11 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x12))
            {
                Store (MF12 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x13))
            {
                Store (MF13 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x14))
            {
                Store (MF14 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x15))
            {
                Store (MF15 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x16))
            {
                Store (MF16 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x17))
            {
                Store (MF17 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x18))
            {
                Store (MF18 (Arg0, Arg3, Arg2), Local0)
            }

            If (LEqual (Arg1, 0x19))
            {
                Store (MF19 (Arg0, Arg3, Arg2), Local0)
            }

            And (SM1X, 0xFE, SM1X)
            If (Local0)
            {
                Store (Local0, EM1X)
                Or (SM1X, 0x02, SM1X)
            }

            Or (SM1X, 0x80, SM1X)
            Return (Zero)
        }

        Method (MF10, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G10V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (SRTC (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G10V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F100, SystemMemory, Arg0, Arg1)
            Field (F100, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (SRTC, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F101, SystemMemory, Arg0, Arg1)
            Field (F101, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                DLTM,   16
            }

            Store (DLTM, RTCW)
            Return (Zero)
        }

        Method (MF11, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G11V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (GBAT (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (ASBR (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x03))
            {
                Store (ASBE (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x04))
            {
                Store (BTCR (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x80))
            {
                Store (GTSB (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x81))
            {
                Store (GPST (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G11V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F110, SystemMemory, Arg0, Arg1)
            Field (F100, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (GBAT, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F111, SystemMemory, Arg0, Arg1)
            Field (F111, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                BTNM,   8, 
                BTTP,   8
            }

            Store (One, BTNM)
            Store (Zero, BTTP)
            Return (Zero)
        }

        Method (ASBR, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x30))
            {
                Return (0x02)
            }

            OperationRegion (\F112, SystemMemory, Arg0, Arg1)
            Field (F112, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                BATN,   8, 
                BATA,   8, 
                REGS,   8, 
                BDAT,   16, 
                BLEN,   8, 
                BREV,   16, 
                BLK1,   32, 
                BLK2,   32, 
                BLK3,   32, 
                BLK4,   32, 
                BLK5,   32, 
                BLK6,   32, 
                BLK7,   32, 
                BLK8,   32
            }

            If (LGreaterEqual (BATN, One))
            {
                Return (0x11)
            }

            If (LEqual (BATA, Zero))
            {
                Store (\_SB.PCI0.LPC0.EC.SMBR (\_SB.PCI0.LPC0.EC.RDWD, \_SB.PCI0.LPC0.EC.BADR, REGS), Local0)
                Store (DerefOf (Index (Local0, 0x02)), BDAT)
                Store (DerefOf (Index (Local0, Zero)), Local2)
                And (Local2, 0x1F, Local2)
                If (Local2)
                {
                    Add (Local2, 0x10, Local2)
                }

                Return (Local2)
            }

            If (LEqual (BATA, One))
            {
                Store (\_SB.PCI0.LPC0.EC.SMBW (\_SB.PCI0.LPC0.EC.WRWD, \_SB.PCI0.LPC0.EC.BADR, REGS, 0x02, BDAT), Local0)
                Store (DerefOf (Index (Local0, Zero)), Local2)
                And (Local2, 0x1F, Local2)
                If (Local2)
                {
                    Add (Local2, 0x10, Local2)
                }

                Return (Local2)
            }

            If (LEqual (BATA, 0x02))
            {
                Store (\_SB.PCI0.LPC0.EC.SMBR (\_SB.PCI0.LPC0.EC.RDBL, \_SB.PCI0.LPC0.EC.BADR, REGS), Local0)
                Name (BKUF, Buffer (0x20) {})
                CreateDWordField (BKUF, Zero, DAT1)
                CreateDWordField (BKUF, 0x04, DAT2)
                CreateDWordField (BKUF, 0x08, DAT3)
                CreateDWordField (BKUF, 0x0C, DAT4)
                CreateDWordField (BKUF, 0x10, DAT5)
                CreateDWordField (BKUF, 0x14, DAT6)
                CreateDWordField (BKUF, 0x18, DAT7)
                CreateDWordField (BKUF, 0x1C, DAT8)
                Store (DerefOf (Index (Local0, 0x02)), BKUF)
                Store (DAT1, BLK1)
                Store (DAT2, BLK2)
                Store (DAT3, BLK3)
                Store (DAT4, BLK4)
                Store (DAT5, BLK5)
                Store (DAT6, BLK6)
                Store (DAT7, BLK7)
                Store (DAT8, BLK8)
                Store (DerefOf (Index (Local0, One)), BLEN)
                Store (DerefOf (Index (Local0, Zero)), Local2)
                And (Local2, 0x1F, Local2)
                If (Local2)
                {
                    Add (Local2, 0x10, Local2)
                }

                Return (Local2)
            }

            Return (0x10)
        }

        Method (ASBE, 2, Serialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F113, SystemMemory, Arg0, Arg1)
            Field (F113, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                BATN,   8, 
                BATA,   8, 
                REGS,   8, 
                BDAT,   8
            }

            If (LGreater (BATN, One))
            {
                Return (0x11)
            }

            If (LEqual (BATA, Zero))
            {
                Store (\_SB.PCI0.LPC0.EC.RBEP (REGS), Local2)
                And (Local2, 0xFF, Local3)
                Store (Local3, BDAT)
                ShiftRight (Local2, 0x08, Local2)
                And (Local2, 0x1F, Local2)
                If (Local2)
                {
                    Add (Local2, 0x10, Local2)
                }

                Return (Local2)
            }

            If (LEqual (BATA, One))
            {
                Store (\_SB.PCI0.LPC0.EC.WBEP (REGS, BDAT), Local2)
                And (Local2, 0x1F, Local2)
                If (Local2)
                {
                    Add (Local2, 0x10, Local2)
                }

                Return (Local2)
            }

            Return (0x10)
        }

        Method (BTCR, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x09))
            {
                Return (0x02)
            }

            OperationRegion (\F114, SystemMemory, Arg0, Arg1)
            Field (F114, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                BCDC,   8
            }

            SBTL (BCDC)
            Return (Zero)
        }

        Method (GTSB, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0F))
            {
                Return (0x02)
            }

            OperationRegion (\F118, SystemMemory, Arg0, Arg1)
            Field (F118, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                BAST,   16
            }

            Store (\_SB.PCI0.LPC0.EC.SMBR (\_SB.PCI0.LPC0.EC.RDWD, \_SB.PCI0.LPC0.EC.BADR, 0x16), Local0)
            Store (DerefOf (Index (Local0, 0x02)), BAST)
            Store (DerefOf (Index (Local0, Zero)), Local1)
            And (Local1, 0x1F, Local1)
            If (Local1)
            {
                Add (Local1, 0x10, Local1)
            }

            Return (Local1)
        }

        Method (GPST, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0F))
            {
                Return (0x02)
            }

            OperationRegion (\F119, SystemMemory, Arg0, Arg1)
            Field (F119, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SORC,   8, 
                GPCT,   8
            }

            If (Or (LEqual (SORC, Zero), LGreater (SORC, 0x03)))
            {
                Return (One)
            }

            If (LEqual (SORC, One)) {}
            Else
            {
                If (LEqual (SORC, 0x02))
                {
                    Store (DCPF, Local0)
                    If (Local0)
                    {
                        Store (Zero, GPCT)
                    }
                    Else
                    {
                        Store (One, GPCT)
                    }
                }
                Else
                {
                    If (LEqual (SORC, 0x03))
                    {
                        Store (Zero, Local0)
                        If (Local0)
                        {
                            Store (Zero, GPCT)
                        }
                        Else
                        {
                            Store (One, GPCT)
                        }
                    }
                }
            }

            Return (Zero)
        }

        Method (MF12, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G12V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (GLDI (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (LDCR (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G12V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F120, SystemMemory, Arg0, Arg1)
            Field (F120, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (GLDI, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x10))
            {
                Return (0x02)
            }

            OperationRegion (\F121, SystemMemory, Arg0, Arg1)
            Field (F121, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                LDI0,   32, 
                LDI1,   32
            }

            Store (Zero, Local0)
            Or (Local0, 0x10, Local0)
            Or (Local0, 0x20, Local0)
            Store (Local0, LDI0)
            Return (Zero)
        }

        Method (LDCR, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0B))
            {
                Return (0x02)
            }

            OperationRegion (\F122, SystemMemory, Arg0, Arg1)
            Field (F122, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                LDNM,   8, 
                LCRT,   8
            }

            If (LEqual (LDNM, 0x04))
            {
                WLED (LCRT)
                Return (Zero)
            }

            Return (0x10)
        }

        Method (MF13, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G13V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (GTSI (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (GTSV (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x03))
            {
                Store (GVSN (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x04))
            {
                Store (GVSV (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x05))
            {
                Store (GFNN (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x06))
            {
                Store (GFNS (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x07))
            {
                Store (SFNS (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G13V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F130, SystemMemory, Arg0, Arg1)
            Field (F130, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (GTSI, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F131, SystemMemory, Arg0, Arg1)
            Field (F131, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                THRI,   32
            }

            Store (Zero, Local0)
            Or (Local0, One, Local0)
            If (LGreaterEqual (CPUN, One))
            {
                Or (Local0, 0x0100, Local0)
            }

            If (LGreaterEqual (CPUN, 0x02))
            {
                Or (Local0, 0x0200, Local0)
            }

            If (LGreaterEqual (CPUN, 0x03))
            {
                Or (Local0, 0x0400, Local0)
            }

            If (LGreaterEqual (CPUN, 0x04))
            {
                Or (Local0, 0x0800, Local0)
            }

            Store (Local0, THRI)
            Return (Zero)
        }

        Method (GTSV, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F132, SystemMemory, Arg0, Arg1)
            Field (F132, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                TSNM,   8, 
                TSVL,   8, 
                TSST,   8
            }

            Store (Zero, TSST)
            If (LEqual (TSNM, Zero))
            {
                Store (\_TZ.RTMP (), TSVL)
                Return (Zero)
            }

            If (LEqual (TSNM, 0x08))
            {
                Store (Arg0, BAPI)
                ISMI (0xD8)
                Return (Zero)
            }

            If (LEqual (TSNM, 0x09))
            {
                Store (Arg0, BAPI)
                ISMI (0xD8)
                Return (Zero)
            }

            If (LEqual (TSNM, 0x0A))
            {
                Store (Arg0, BAPI)
                ISMI (0xD8)
                Return (Zero)
            }

            If (LEqual (TSNM, 0x0B))
            {
                Store (Arg0, BAPI)
                ISMI (0xD8)
                Return (Zero)
            }

            Return (0x10)
        }

        Method (GVSN, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x09))
            {
                Return (0x02)
            }

            OperationRegion (\F133, SystemMemory, Arg0, Arg1)
            Field (F133, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                NMVS,   8
            }

            Store (Zero, NMVS)
            Return (Zero)
        }

        Method (GVSV, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0B))
            {
                Return (0x02)
            }

            OperationRegion (\F134, SystemMemory, Arg0, Arg1)
            Field (F134, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                VSNM,   8, 
                VSVL,   16
            }

            If (LGreater (VSNM, Zero))
            {
                Return (0x10)
            }

            Return (Zero)
        }

        Method (GFNN, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x09))
            {
                Return (0x02)
            }

            OperationRegion (\F135, SystemMemory, Arg0, Arg1)
            Field (F135, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                NMFN,   32
            }

            Store (One, NMFN)
            Return (Zero)
        }

        Method (GFNS, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0D))
            {
                Return (0x02)
            }

            OperationRegion (\F136, SystemMemory, Arg0, Arg1)
            Field (F136, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                FNNM,   8, 
                GFNS,   32
            }

            If (Or (LEqual (FNNM, Zero), LGreater (FNNM, One)))
            {
                Return (0x10)
            }

            Store (FNNM, Local0)
            Store (\_TZ.RFAN (Decrement (Local0)), GFNS)
            Return (Zero)
        }

        Method (SFNS, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F137, SystemMemory, Arg0, Arg1)
            Field (F137, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                FNNB,   8, 
                FNSP,   8
            }

            If (LGreater (FNNB, One))
            {
                Return (0x10)
            }

            \_SB.PCI0.LPC0.EC.SFNV (FNNB, FNSP)
            Return (Zero)
        }

        Method (MF14, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G14V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (GNBT (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (GBTS (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G14V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F140, SystemMemory, Arg0, Arg1)
            Field (F140, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (GNBT, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x09))
            {
                Return (0x02)
            }

            OperationRegion (\F141, SystemMemory, Arg0, Arg1)
            Field (F141, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                NBBT,   8
            }

            Store (0x05, NBBT)
            Return (Zero)
        }

        Method (GBTS, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F142, SystemMemory, Arg0, Arg1)
            Field (F142, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                BTNM,   8, 
                BTST,   8
            }

            Name (BTTB, Package (0x05)
            {
                Package (0x04)
                {
                    Zero, 
                    0x0C, 
                    Zero, 
                    Zero
                }, 

                Package (0x04)
                {
                    Zero, 
                    0x0D, 
                    Zero, 
                    Zero
                }, 

                Package (0x04)
                {
                    Zero, 
                    0x0E, 
                    Zero, 
                    Zero
                }, 

                Package (0x04)
                {
                    Zero, 
                    0x0F, 
                    Zero, 
                    Zero
                }, 

                Package (0x04)
                {
                    Zero, 
                    0x15, 
                    Zero, 
                    Zero
                }
            })
            If (LGreater (BTNM, 0x05))
            {
                Return (0x10)
            }

            Store (BTNM, Local0)
            Decrement (Local0)
            Store (DerefOf (Index (BTTB, Local0)), Local1)
            If (LEqual (DerefOf (Index (Local1, 0x02)), Zero)) {}
            If (LEqual (DerefOf (Index (Local1, One)), One))
            {
                Store (RGPL (DerefOf (Index (Local1, Zero)), One), Local2)
            }

            If (LEqual (DerefOf (Index (Local1, One)), 0x03)) {}
            If (LEqual (DerefOf (Index (Local1, 0x02)), Local2))
            {
                Store (Zero, BTST)
            }
            Else
            {
                Store (One, BTST)
            }

            Return (Zero)
        }

        Method (MF15, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G15V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (GLDB (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (SLDB (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x03))
            {
                Store (GDPI (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x04))
            {
                Store (SODP (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G15V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F150, SystemMemory, Arg0, Arg1)
            Field (F150, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (GLDB, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F151, SystemMemory, Arg0, Arg1)
            Field (F151, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                LCDB,   8, 
                MLDB,   8
            }

            Store (GPLV (), LCDB)
            Store (0x0F, MLDB)
            Return (Zero)
        }

        Method (SLDB, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F152, SystemMemory, Arg0, Arg1)
            Field (F152, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                LCDL,   8, 
                LTPE,   8
            }

            If (LEqual (LTPE, Zero))
            {
                If (LGreaterEqual (LCDL, 0x10))
                {
                    Return (0x10)
                }

                SPLV (LCDL)
                Return (Zero)
            }

            If (LEqual (LTPE, One))
            {
                \_SB.PCI0.LPC0.EC.SBRV (LCDL)
                Return (Zero)
            }

            Return (0x11)
        }

        Method (GDPI, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x10))
            {
                Return (0x02)
            }

            OperationRegion (\F153, SystemMemory, Arg0, Arg1)
            Field (F153, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                ODPI,   32, 
                ODPC,   32, 
                ODAV,   32
            }

            Store (Zero, Local0)
            Or (Local0, One, Local0)
            Or (Local0, 0x02, Local0)
            Or (Local0, 0x08, Local0)
            Or (Local0, 0x10, Local0)
            Store (Local0, ODPI)
            Store (ACTD, ODAV)
            Store (AVLD, ODPC)
            Return (Zero)
        }

        Method (SODP, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F154, SystemMemory, Arg0, Arg1)
            Field (F154, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                ODPM,   32
            }

            Store (Zero, Local0)
            Or (Local0, One, Local0)
            Or (Local0, 0x02, Local0)
            Or (Local0, 0x08, Local0)
            Or (Local0, 0x10, Local0)
            And (ODPM, Local0, Local0)
            If (LEqual (Local0, ODPM))
            {
                SDSP (ODPM)
                Return (Zero)
            }

            Return (0x10)
        }

        Method (MF16, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G16V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (SFBD (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (LCMD (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x03))
            {
                Store (BSFN (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x04))
            {
                Store (PSSF (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G16V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F160, SystemMemory, Arg0, Arg1)
            Field (F160, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (SFBD, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F161, SystemMemory, Arg0, Arg1)
            Field (F161, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                NXBD,   8
            }

            If (OFBD (NXBD))
            {
                Store (NXBD, UHDB)
                Store (Arg0, BAPI)
                ISMI (0xD8)
                Return (Zero)
            }
            Else
            {
                Return (0x10)
            }
        }

        Method (LCMD, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            Store (Arg0, BAPI)
            ISMI (0xD8)
            Store (0xAA55, FRPN)
            Return (Zero)
        }

        Method (BSFN, 2, NotSerialized)
        {
            Store (Arg0, BAPI)
            ISMI (0xD8)
            Return (Zero)
        }

        Method (PSSF, 2, NotSerialized)
        {
            Store (0x16, SWMF)
            Store (0x1604, SWSF)
            \_SB.BSMI (0xD5)
            Return (Zero)
        }

        Method (MF17, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G17V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (GMDL (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (GBSI (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x03))
            {
                Store (GECI (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G17V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F170, SystemMemory, Arg0, Arg1)
            Field (F170, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (GMDL, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x19))
            {
                Return (0x02)
            }

            OperationRegion (\F171, SystemMemory, Arg0, Arg1)
            Field (F171, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                MLEN,   8, 
                MDL1,   32, 
                MDL2,   32, 
                MDL3,   32, 
                MDL4,   32
            }

            Store (Zero, MDL1)
            Store (Zero, MDL2)
            Store (Zero, MDL3)
            Store (Zero, MDL4)
            Name (BBUF, Buffer (0x10) {})
            CreateDWordField (BBUF, Zero, DAT1)
            CreateDWordField (BBUF, 0x04, DAT2)
            CreateDWordField (BBUF, 0x08, DAT3)
            CreateDWordField (BBUF, 0x0C, DAT4)
            Store (GBMN (), Local0)
            Store (SizeOf (Local0), MLEN)
            Store (GBMN (), BBUF)
            Store (DAT1, MDL1)
            Store (DAT2, MDL2)
            Store (DAT3, MDL3)
            Store (DAT4, MDL4)
            Return (Zero)
        }

        Method (GBSI, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x19))
            {
                Return (0x02)
            }

            OperationRegion (\F172, SystemMemory, Arg0, Arg1)
            Field (F172, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                BLEN,   8, 
                BDL1,   32, 
                BDL2,   32, 
                BDL3,   32, 
                BDL4,   24, 
                YEAR,   32, 
                MON,    16, 
                DAY,    16
            }

            Store (Zero, BDL1)
            Store (Zero, BDL2)
            Store (Zero, BDL3)
            Store (Zero, BDL4)
            Name (BBUF, Buffer (0x10) {})
            CreateDWordField (BBUF, Zero, DAT1)
            CreateDWordField (BBUF, 0x04, DAT2)
            CreateDWordField (BBUF, 0x08, DAT3)
            CreateDWordField (BBUF, 0x0C, DAT4)
            Store (GBRV (), Local0)
            Store (SizeOf (Local0), BLEN)
            Store (GBRV (), BBUF)
            Store (DAT1, BDL1)
            Store (DAT2, BDL2)
            Store (DAT3, BDL3)
            Store (DAT4, BDL4)
            CreateWordField (BBUF, Zero, WRD0)
            ToDecimalString (BIYR, BBUF)
            Store (DAT1, YEAR)
            ToDecimalString (BIMN, BBUF)
            Store (WRD0, MON)
            ToDecimalString (BIDA, BBUF)
            Store (WRD0, DAY)
            Return (Zero)
        }

        Method (GECI, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x19))
            {
                Return (0x02)
            }

            OperationRegion (\F173, SystemMemory, Arg0, Arg1)
            Field (F173, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                ELEN,   8, 
                EDL1,   32, 
                EDL2,   32, 
                EDL3,   32, 
                EDL4,   32
            }

            Store (Zero, EDL1)
            Store (Zero, EDL2)
            Store (Zero, EDL3)
            Store (Zero, EDL4)
            Name (BBUF, Buffer (0x10) {})
            CreateDWordField (BBUF, Zero, DAT1)
            CreateDWordField (BBUF, 0x04, DAT2)
            CreateDWordField (BBUF, 0x08, DAT3)
            CreateDWordField (BBUF, 0x0C, DAT4)
            Store (GERV (), Local0)
            Store (SizeOf (Local0), ELEN)
            Store (GERV (), BBUF)
            Store (DAT1, EDL1)
            Store (DAT2, EDL2)
            Store (DAT3, EDL3)
            Store (DAT4, EDL4)
            Return (Zero)
        }

        Method (MF18, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G18V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (GDVI (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (GDVS (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x03))
            {
                Store (SDPW (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G18V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F180, SystemMemory, Arg0, Arg1)
            Field (F180, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (GDVI, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x18))
            {
                Return (0x02)
            }

            OperationRegion (\F181, SystemMemory, Arg0, Arg1)
            Field (F181, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                LDI0,   32, 
                LDI1,   32
            }

            Store (Zero, LDI0)
            Return (Zero)
        }

        Method (GDVS, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F182, SystemMemory, Arg0, Arg1)
            Field (F182, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                DNUM,   8, 
                DSTS,   8
            }

            ShiftLeft (One, DNUM, Local0)
            If (LEqual (And (Local0, Zero), Zero))
            {
                Return (0x10)
            }

            Return (Zero)
        }

        Method (SDPW, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F183, SystemMemory, Arg0, Arg1)
            Field (F183, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                DNUM,   8, 
                DCTR,   8
            }

            ShiftLeft (One, DNUM, Local0)
            If (LEqual (And (Local0, Zero), Zero))
            {
                Return (0x10)
            }

            If (LGreater (DCTR, One))
            {
                Return (0x11)
            }

            Return (Zero)
        }

        Method (MF19, 3, NotSerialized)
        {
            Store (One, Local0)
            If (LEqual (Arg2, Zero))
            {
                Store (G19V (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, One))
            {
                Store (ACMS (Arg0, Arg1), Local0)
            }

            If (LEqual (Arg2, 0x02))
            {
                Store (CSIN (Arg0, Arg1), Local0)
            }

            Return (Local0)
        }

        Method (G19V, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0C))
            {
                Return (0x02)
            }

            OperationRegion (\F190, SystemMemory, Arg0, Arg1)
            Field (F190, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                SVER,   16, 
                MVER,   16
            }

            Store (Zero, MVER)
            Store (Zero, SVER)
            Return (Zero)
        }

        Method (ACMS, 2, NotSerialized)
        {
            Store (Arg0, BAPI)
            ISMI (0xD8)
            Return (Zero)
        }

        Method (CSIN, 2, NotSerialized)
        {
            If (LLess (Arg1, 0x0A))
            {
                Return (0x02)
            }

            OperationRegion (\F192, SystemMemory, Arg0, Arg1)
            Field (F192, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x08), 
                CMAX,   16
            }

            Store (0xFF, CMAX)
            Return (Zero)
        }

        Method (XPAP, 4, NotSerialized)
        {
            If (LEqual (Arg1, 0x21))
            {
                If (LGreater (Arg2, 0x05))
                {
                    If (LEqual (Arg2, 0x06))
                    {
                        GCTP (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x07))
                    {
                        GCOM (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x08))
                    {
                        CPTP (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x09))
                    {
                        CPSP (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x0C))
                    {
                        GEHT (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x0D))
                    {
                        \_SB.BSMI (Arg0)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x10))
                    {
                        FBTN (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x11))
                    {
                        BTNF (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x12))
                    {
                        GBTN (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x14))
                    {
                        CPUL (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x15))
                    {
                        GMPL (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x16))
                    {
                        RMTC (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x20))
                    {
                        GWLS (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x21))
                    {
                        SWLS (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x22))
                    {
                        TPST (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x23))
                    {
                        FNST (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x24))
                    {
                        ODJE (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x25))
                    {
                        ODJF (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x26))
                    {
                        ODJN (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }

                    If (LEqual (Arg2, 0x27))
                    {
                        ILED (Arg0, Arg1, Arg2, Arg3)
                        Return (Zero)
                    }
                }
            }
        }

        Name (BUTN, 0xFF)
        Method (GCTP, 4, NotSerialized)
        {
            OperationRegion (\F21P, SystemMemory, Arg0, 0x20)
            Field (F21P, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                TYPE,   8
            }

            Store (0x02, TYPE)
            Store (0x80, STAS)
        }

        Method (GCOM, 4, NotSerialized)
        {
            OperationRegion (\F21Q, SystemMemory, Arg0, 0x20)
            Field (F21Q, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                FUNC,   8, 
                MODE,   8
            }

            If (LEqual (FUNC, Zero))
            {
                If (\_TZ.PLCY)
                {
                    Store (One, MODE)
                }
                Else
                {
                    Store (Zero, MODE)
                }
            }

            If (LEqual (FUNC, One))
            {
                If (MODE)
                {
                    \_TZ.THZ0._SCP (One)
                }
                Else
                {
                    \_TZ.THZ0._SCP (Zero)
                }
            }

            Store (0x80, STAS)
        }

        Method (CPTP, 4, NotSerialized)
        {
            OperationRegion (\F21C, SystemMemory, Arg0, 0x20)
            Field (F21C, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                TYPE,   8
            }

            Store (0x02, TYPE)
            Store (0x80, STAS)
        }

        Method (CPSP, 4, NotSerialized)
        {
            OperationRegion (\F21D, SystemMemory, Arg0, 0x20)
            Field (F21D, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                MODE,   8
            }

            \_SB.BSMI (Arg0)
            Store (0x80, STAS)
        }

        Method (GEHT, 4, NotSerialized)
        {
            OperationRegion (\F21E, SystemMemory, Arg0, 0x20)
            Field (F21E, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                TYPE,   8, 
                CURR,   16
            }

            If (LEqual (TYPE, 0x03))
            {
                Store (0x1E, CURR)
            }

            If (LEqual (TYPE, 0x04))
            {
                Store (0x0A, CURR)
            }

            Store (0x80, STAS)
        }

        Method (FBTN, 4, NotSerialized)
        {
            OperationRegion (\F21F, SystemMemory, Arg0, 0x20)
            Field (F21F, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                FUNC,   8, 
                BUTT,   8
            }

            If (LEqual (FUNC, Zero))
            {
                And (IKFG, 0xDF, IKFG)
            }

            If (LEqual (FUNC, One))
            {
                Store (IKFG, Local0)
                If (And (Local0, 0x20))
                {
                    Store (0x02, BUTT)
                }
                Else
                {
                    Store (Zero, BUTT)
                }
            }

            If (LEqual (FUNC, 0x02))
            {
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x04FB), Local0)
                If (And (BUTT, 0x02))
                {
                    \_SB.PCI0.LPC0.EC.WRAM (0x0494, Or (Local0, 0x08))
                }
                Else
                {
                    \_SB.PCI0.LPC0.EC.WRAM (0x0494, And (Local0, 0xF7))
                }
            }

            Store (0x80, STAS)
        }

        Method (BTNF, 4, NotSerialized)
        {
            OperationRegion (\F21I, SystemMemory, Arg0, 0x20)
            Field (F21I, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                BUTT,   8
            }

            Store (BUTT, BUTN)
            Store (0x80, STAS)
        }

        Method (GBTN, 4, NotSerialized)
        {
            OperationRegion (\F21B, SystemMemory, Arg0, 0x20)
            Field (F21B, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                BUTN,   8
            }

            Store (Zero, BUTN)
            Store (0x80, STAS)
        }

        Method (CPUL, 4, NotSerialized)
        {
            OperationRegion (\F21A, SystemMemory, Arg0, 0x20)
            Field (F21A, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                FUNC,   8, 
                LVEL,   8
            }

            If (LEqual (FUNC, Zero))
            {
                Store (PSTC (Zero), Local0)
                And (Local0, 0xFF, Local0)
                If (LEqual (Local0, Zero))
                {
                    \_SB.BSMI (Arg0)
                }
                Else
                {
                    Store (Add (Local0, 0x02), LVEL)
                }
            }

            If (LEqual (FUNC, One))
            {
                \_SB.BSMI (Arg0)
            }

            If (LEqual (FUNC, 0x02))
            {
                \_SB.BSMI (Arg0)
                If (LGreater (LVEL, 0x02))
                {
                    PSTC (Subtract (LVEL, 0x02))
                }
                Else
                {
                    PSTC (One)
                }
            }

            Store (0x80, STAS)
        }

        Method (GMPL, 4, NotSerialized)
        {
            OperationRegion (\F21G, SystemMemory, Arg0, 0x20)
            Field (F21G, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                MODE,   8
            }

            Store (Zero, MODE)
            Store (0x80, STAS)
        }

        Method (RMTC, 4, NotSerialized)
        {
        }

        Method (GWLS, 4, NotSerialized)
        {
            OperationRegion (\F21Y, SystemMemory, Arg0, 0x20)
            Field (F21Y, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                BTXT,   1, 
                BTON,   1, 
                WLXT,   1, 
                WLON,   1, 
                SWON,   1
            }

            Store (WLDP, WLXT)
            Store (BTDP, BTXT)
            Store (WRST, WLON)
            Store (BRST, BTON)
            Store (And (OHWR (), One), SWON)
            Store (0x80, STAS)
        }

        Method (SWLS, 4, NotSerialized)
        {
            OperationRegion (\F21Z, SystemMemory, Arg0, 0x20)
            Field (F21Z, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                BTON,   1, 
                WLON,   1
            }

            OBTD (BTON)
            OWLD (WLON)
            Store (0x80, STAS)
        }

        Method (FNST, 4, NotSerialized)
        {
            OperationRegion (\F21W, SystemMemory, Arg0, 0x20)
            Field (F21W, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                FUNC,   8, 
                DAT0,   8
            }

            If (LEqual (FUNC, One))
            {
                If (LEqual (DAT0, Zero))
                {
                    \_SB.PCI0.LPC0.EC.ECXT (0xAF, Zero, Zero, Zero, Zero, Zero)
                    Store (Zero, \_SB.VALZ.STMD)
                    Store (Zero, SSTK)
                    Sleep (0x01F4)
                }
                Else
                {
                    \_SB.PCI0.LPC0.EC.ECXT (0xAF, 0x02, Zero, Zero, Zero, Zero)
                    Store (One, SSTK)
                    Sleep (0x01F4)
                }

                If (LEqual (DAT0, One))
                {
                    Store (One, \_SB.VALZ.STMD)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x07B0), Local0)
                    \_SB.PCI0.LPC0.EC.WRAM (0x07B0, And (Local0, 0xEF))
                }

                If (LEqual (DAT0, 0x02))
                {
                    Store (0x02, \_SB.VALZ.STMD)
                    Store (\_SB.PCI0.LPC0.EC.RRAM (0x07B0), Local0)
                    \_SB.PCI0.LPC0.EC.WRAM (0x07B0, Or (Local0, 0x10))
                }
            }
            Else
            {
                Store (\_SB.VALZ.STMD, DAT0)
            }

            Store (0x80, STAS)
        }

        Method (TPST, 4, NotSerialized)
        {
            OperationRegion (\F21X, SystemMemory, Arg0, 0x20)
            Field (F21X, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x06), 
                STAS,   8, 
                EROR,   8, 
                FUNC,   8, 
                DAT0,   8
            }

            If (LEqual (FUNC, Zero))
            {
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x07C7), Local0)
                If (Local0)
                {
                    Store (Zero, DAT0)
                }
                Else
                {
                    Store (One, DAT0)
                }

                Store (0x80, STAS)
            }

            If (LEqual (FUNC, One))
            {
                If (LNotEqual (DAT0, Zero))
                {
                    \_SB.PCI0.LPC0.EC.ECXT (0xB5, Zero, Zero, Zero, Zero, Zero)
                    Store (One, TPON)
                }
                Else
                {
                    \_SB.PCI0.LPC0.EC.ECXT (0xB5, One, Zero, Zero, Zero, Zero)
                    Store (Zero, TPON)
                }

                Store (0x80, STAS)
            }
        }

        Method (ODJE, 4, NotSerialized)
        {
        }

        Method (ODJF, 4, NotSerialized)
        {
        }

        Method (ODJN, 4, NotSerialized)
        {
        }

        Name (ILUD, 0xFF)
        Method (ILED, 4, NotSerialized)
        {
        }

        Method (MF1F, 4, NotSerialized)
        {
            If (LEqual (Arg1, 0x1F))
            {
                OperationRegion (F01F, SystemMemory, Arg0, 0x08)
                Field (F01F, DWordAcc, NoLock, Preserve)
                {
                    MFUN,   16, 
                    SFUN,   16, 
                    LEN,    16, 
                    STAS,   8, 
                    EROR,   8
                }

                \_SB.BSMI (Arg0)
                And (STAS, 0xFE, STAS)
            }
        }
    }

    Scope (_SB)
    {
        Device (BT)
        {
            Name (_HID, "TOS6205")
            Name (BTAF, Zero)
            Method (_STA, 0, NotSerialized)
            {
                If (BTDP)
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (BWAK, 1, Serialized)
            {
                If (BTDP)
                {
                    Notify (BT, 0x80)
                }
            }

            Method (BTST, 0, NotSerialized)
            {
                Store (Zero, Local0)
                If (LAnd (BTDP, BRST))
                {
                    Store (One, Local1)
                }
                Else
                {
                    Store (Zero, Local1)
                }

                Store (One, Local2)
                If (Local1)
                {
                    Or (Local0, 0x80, Local0)
                }

                If (BTAF)
                {
                    Or (Local0, 0x40, Local0)
                }

                If (Local2)
                {
                    Or (Local0, One, Local0)
                }

                Return (Local0)
            }

            Method (AUSB, 0, NotSerialized)
            {
                Store (One, BTAF)
            }

            Method (DUSB, 0, NotSerialized)
            {
                Store (Zero, BTAF)
            }

            Method (BTPO, 0, NotSerialized)
            {
                Store (One, BRST)
                If (LAnd (BTDP, BRST))
                {
                    SGPL (0xD2, One, One)
                }
                Else
                {
                    SGPL (0xD2, One, Zero)
                }

                ^^VALZ.MLED ()
            }

            Method (BTPF, 0, NotSerialized)
            {
                Store (Zero, BRST)
                If (LAnd (BTDP, BRST))
                {
                    SGPL (0xD2, One, One)
                }
                Else
                {
                    SGPL (0xD2, One, Zero)
                }

                ^^VALZ.MLED ()
            }

            Method (NTFY, 0, NotSerialized)
            {
                Notify (BT, 0x90)
            }

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

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

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

    Method (ASMI, 1, Serialized)
    {
        Store (Arg0, ALPR)
        Store (0xD6, SMCM)
        Return (ALPR)
    }

    Method (DBGR, 4, NotSerialized)
    {
        Store (Arg0, DBR1)
        Store (Arg1, DBR2)
        Store (Arg2, DBR3)
        Store (Arg3, DBR4)
        ASMI (0x80)
    }

    Name (PICM, Zero)
    Name (GPIC, Zero)
    Method (_PIC, 1, NotSerialized)
    {
        Store (Arg0, PICM)
        Store (Arg0, GPIC)
        If (PICM)
        {
            \_SB.DSPI ()
        }
    }

    Method (_PTS, 1, NotSerialized)
    {
        SPTS (Arg0)
        If (LEqual (Arg0, One))
        {
            Store (0x51, IO80)
            \_SB.S80H (0x51)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (0x53, IO80)
            \_SB.S80H (0x53)
            Store (One, \_SB.PCI0.SMBS.SLPS)
            \WMI0.GENS (Arg0)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0x54, IO80)
            \_SB.S80H (0x54)
            Store (One, \_SB.PCI0.SMBS.SLPS)
            Store (One, RSTU)
            \WMI0.GENS (Arg0)
        }

        If (LEqual (Arg0, 0x05))
        {
            Store (0x55, IO80)
            \_SB.S80H (0x55)
            \_SB.GSMI (0x03)
            \WMI0.GENS (Arg0)
        }

        \_SB.APTS (Arg0)
    }

    Method (LIDW, 0, NotSerialized)
    {
        Store (Zero, LDEV)
    }

    Method (_WAK, 1, NotSerialized)
    {
        SWAK (Arg0)
        \_SB.AWAK (Arg0)
        If (LEqual (Arg0, One))
        {
            Store (0xE1, IO80)
            \_SB.S80H (0xE1)
            Store (0xF1, \_SB.PCI0.P2P.PR4B)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (0xE3, IO80)
            \_SB.S80H (0xE3)
            CHKH ()
            Notify (\_SB.PWRB, 0x02)
            If (\_SB.PCI0.SATA.IPM1)
            {
                Store (Zero, \_SB.PCI0.SATA.DIS1)
                Store (One, \_SB.PCI0.SATA.WTEN)
                Store (One, \_SB.PCI0.SATA.PTI1)
                Store (Zero, \_SB.PCI0.SATA.WTEN)
                Sleep (0x28)
                Store (Zero, \_SB.PCI0.SMBS.O170)
                Store (Zero, \_SB.PCI0.SMBS.E170)
                Store (One, \_SB.PCI0.SMBS.O053)
                Store (Zero, \_SB.PCI0.SMBS.E053)
                Sleep (0x28)
            }

            \WMI0.GENW (Arg0)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0xFF, \_SB.PCI0.LPC0.EC.TTAC)
            \_SB.PCI0.LPC0.EC.TTPH ()
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0xE4, IO80)
            \_SB.S80H (0xE4)
            \_SB.PCI0._INI ()
            If (LOr (LEqual (TPOS, 0x40), LEqual (TPOS, 0x41)))
            {
                \_SB.PCI0.EHC1.STOS ()
                \_SB.PCI0.EHC2.STOS ()
                \_SB.PCI0.EHC3.STOS ()
            }

            Notify (\_SB.PWRB, 0x02)
            Notify (\_SB.PCI0.PB7, Zero)
            \WMI0.GENW (Arg0)
        }

        If (LLess (OSTB, 0x40))
        {
            Acquire (\_SB.PCI0.LPC0.PSMX, 0xFFFF)
            Store (One, SBFN)
            Store (0x8A, BCMD)
            \_SB.BSMI (Zero)
            Release (\_SB.PCI0.LPC0.PSMX)
        }

        If (LEqual (Arg0, 0x05))
        {
            Store (0xE5, IO80)
            \WMI0.GENW (Arg0)
        }

        LIDW ()
        Return (Zero)
    }

    Scope (_SB)
    {
        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Method (_STA, 0, NotSerialized)
            {
                Return (0x0B)
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, EisaId ("PNP0A03"))
            Name (_ADR, Zero)
            OperationRegion (SCTH, PCI_Config, 0x7A, One)
            Field (SCTH, ByteAcc, NoLock, Preserve)
            {
                RSMF,   1
            }

            Method (_INI, 0, NotSerialized)
            {
                If (LEqual (GPIC, Zero)) {}
                Else
                {
                    DSPI ()
                }

                OSTP ()
                CHKH ()
                If (CondRefOf (_OSI, Local0))
                {
                    Store (Zero, MYOS)
                }
                Else
                {
                    If (LEqual (SizeOf (_OS), 0x14))
                    {
                        Store (One, MYOS)
                    }
                    Else
                    {
                        If (LEqual (SizeOf (_OS), 0x27))
                        {
                            Store (0x02, MYOS)
                        }
                        Else
                        {
                            Store (0x03, MYOS)
                        }
                    }
                }
            }

            OperationRegion (NBMS, PCI_Config, 0x60, 0x08)
            Field (NBMS, DWordAcc, NoLock, Preserve)
            {
                MIDX,   32, 
                MIDR,   32
            }

            Mutex (NBMM, 0x00)
            Method (NBMR, 1, NotSerialized)
            {
                Acquire (NBMM, 0xFFFF)
                And (Arg0, 0x7F, Local0)
                Store (Local0, MIDX)
                Store (MIDR, Local0)
                Store (0x7F, MIDX)
                Release (NBMM)
                Return (Local0)
            }

            Method (NBMW, 2, NotSerialized)
            {
                Acquire (NBMM, 0xFFFF)
                And (Arg0, 0x7F, Local0)
                Or (Local0, 0x80, Local0)
                Store (Local0, MIDX)
                Store (Arg1, MIDR)
                Store (And (Local0, 0x7F, Local0), MIDX)
                Release (NBMM)
            }

            OperationRegion (NBXP, PCI_Config, 0xE0, 0x08)
            Field (NBXP, DWordAcc, NoLock, Preserve)
            {
                NBXI,   32, 
                NBXD,   32
            }

            Mutex (NBXM, 0x00)
            Method (NBXR, 1, NotSerialized)
            {
                Acquire (NBXM, 0xFFFF)
                Store (Arg0, NBXI)
                Store (NBXD, Local0)
                Store (Zero, NBXI)
                Release (NBXM)
                Return (Local0)
            }

            Method (NBXW, 2, NotSerialized)
            {
                Acquire (NBXM, 0xFFFF)
                Store (Arg0, NBXI)
                Store (Arg1, NBXD)
                Store (Zero, NBXI)
                Release (NBXM)
            }

            Method (XPTR, 2, NotSerialized)
            {
                If (LAnd (LLess (Arg0, 0x02), LGreater (Arg0, 0x07)))
                {
                    Return (Zero)
                }
                Else
                {
                    If (LLess (Arg0, 0x04))
                    {
                        Subtract (Arg0, 0x02, Local1)
                        Store (0x01310800, Local0)
                    }
                    Else
                    {
                        Subtract (Arg0, 0x04, Local1)
                        Store (0x01300900, Local0)
                    }

                    Add (Local0, ShiftLeft (Local1, 0x08), Local0)
                    ShiftLeft (Local0, Local1, Local0)
                    NBXW (Local0, Arg1)
                    Return (Ones)
                }
            }

            Method (XPLP, 2, NotSerialized)
            {
            }

            Method (XPLL, 2, NotSerialized)
            {
            }

            Name (_UID, One)
            Name (_BBN, Zero)
            Name (SUPP, Zero)
            Name (CTRL, Zero)
            Name (AMHP, Zero)
            Method (XOSC, 4, NotSerialized)
            {
                CreateDWordField (Arg3, Zero, CDW1)
                CreateDWordField (Arg3, 0x04, CDW2)
                CreateDWordField (Arg3, 0x08, CDW3)
                If (LEqual (Arg0, Buffer (0x10)
                        {
                            /* 0000 */    0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 
                            /* 0008 */    0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66
                        }))
                {
                    Store (CDW2, SUPP)
                    Store (CDW3, CTRL)
                    If (LNotEqual (And (SUPP, 0x16), 0x16))
                    {
                        And (CTRL, 0x1E, CTRL)
                    }

                    And (CTRL, 0x1D, CTRL)
                    If (Not (And (CDW1, One)))
                    {
                        If (And (CTRL, One)) {}
                        If (And (CTRL, 0x10)) {}
                    }

                    If (LNotEqual (Arg1, One))
                    {
                        Or (CDW1, 0x08, CDW1)
                    }

                    If (LNotEqual (CDW3, CTRL))
                    {
                        Or (CDW1, 0x10, CDW1)
                    }

                    Store (CTRL, CDW3)
                    Return (Arg3)
                }
                Else
                {
                    Or (CDW1, 0x04, CDW1)
                    Return (Arg3)
                }
            }

            Method (TOM, 0, NotSerialized)
            {
                Multiply (TOML, 0x00010000, Local0)
                Multiply (TOMH, 0x01000000, Local1)
                Add (Local0, Local1, Local0)
                Return (Local0)
            }

            Name (CRES, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, SubDecode,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x00FF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0100,             // Length
                    0x00,, )
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x0CF7,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0CF8,             // Length
                    0x00,, , TypeStatic)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Granularity
                    0x0D00,             // Range Minimum
                    0xFFFF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0xF300,             // Length
                    ,, , TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000A0000,         // Range Minimum
                    0x000BFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00020000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadOnly,
                    0x00000000,         // Granularity
                    0x000C0000,         // Range Minimum
                    0x000C3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadOnly,
                    0x00000000,         // Granularity
                    0x000C4000,         // Range Minimum
                    0x000C7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadOnly,
                    0x00000000,         // Granularity
                    0x000C8000,         // Range Minimum
                    0x000CBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadOnly,
                    0x00000000,         // Granularity
                    0x000CC000,         // Range Minimum
                    0x000CFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D0000,         // Range Minimum
                    0x000D3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D4000,         // Range Minimum
                    0x000D7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D8000,         // Range Minimum
                    0x000DBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000DC000,         // Range Minimum
                    0x000DFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E0000,         // Range Minimum
                    0x000E3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E4000,         // Range Minimum
                    0x000E7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E8000,         // Range Minimum
                    0x000EBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000EC000,         // Range Minimum
                    0x000EFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x80000000,         // Range Minimum
                    0xF7FFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x78000000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xFC000000,         // Range Minimum
                    0xFED3FFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x02D40000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xFED45000,         // Range Minimum
                    0xFFFFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x012BB000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                IO (Decode16,
                    0x0CF8,             // Range Minimum
                    0x0CF8,             // Range Maximum
                    0x01,               // Alignment
                    0x08,               // Length
                    )
            })
            Method (_CRS, 0, NotSerialized)
            {
                CreateDWordField (CRES, 0x019B, BTMN)
                CreateDWordField (CRES, 0x019F, BTMX)
                CreateDWordField (CRES, 0x01A7, BTLN)
                CreateDWordField (CRES, 0x01B6, BTN1)
                CreateDWordField (CRES, 0x01BA, BTX1)
                CreateDWordField (CRES, 0x01C2, BTL1)
                Store (TOM (), BTMN)
                Subtract (0xF8000000, BTMN, BTLN)
                Return (CRES)
            }

            Device (MEMR)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (MEM1, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00000000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00000000,         // Address Length
                        )
                })
                Method (_CRS, 0, NotSerialized)
                {
                    CreateDWordField (MEM1, 0x04, MB01)
                    CreateDWordField (MEM1, 0x08, ML01)
                    CreateDWordField (MEM1, 0x10, MB02)
                    CreateDWordField (MEM1, 0x14, ML02)
                    If (GPIC)
                    {
                        Store (0xFEC00000, MB01)
                        Store (0xFEE00000, MB02)
                        Store (0x1000, ML01)
                        Store (0x1000, ML02)
                    }

                    Return (MEM1)
                }
            }

            Method (XCMP, 2, NotSerialized)
            {
                If (LNotEqual (0x10, SizeOf (Arg0)))
                {
                    Return (Zero)
                }

                If (LNotEqual (0x10, SizeOf (Arg1)))
                {
                    Return (Zero)
                }

                Store (Zero, Local0)
                While (LLess (Local0, 0x10))
                {
                    If (LNotEqual (DerefOf (Index (Arg0, Local0)), DerefOf (Index (
                        Arg1, Local0))))
                    {
                        Return (Zero)
                    }

                    Increment (Local0)
                }

                Return (One)
            }

            Method (AFN0, 0, Serialized)
            {
                If (LEqual (PDDN, One))
                {
                    ^VGA.AFN0 ()
                }

                If (LEqual (PDDN, 0x02))
                {
                    ^PB2.VGA.AFN0 ()
                }

                If (LEqual (PDDN, 0x03))
                {
                    ^PB3.VGA.AFN0 ()
                }
            }

            Method (AFN1, 1, Serialized)
            {
            }

            Method (AFN2, 2, Serialized)
            {
            }

            Method (AFN3, 2, Serialized)
            {
                If (LEqual (PDDN, One))
                {
                    ^VGA.AFN3 (Arg0, Arg1)
                }

                If (LEqual (PDDN, 0x02))
                {
                    ^PB2.VGA.AFN3 (Arg0, Arg1)
                }

                If (LEqual (PDDN, 0x03))
                {
                    ^PB3.VGA.AFN3 (Arg0, Arg1)
                }
            }

            Method (AFN4, 1, Serialized)
            {
                If (LEqual (PDDN, One))
                {
                    ^VGA.AFN4 (Arg0)
                }

                If (LEqual (PDDN, 0x02))
                {
                    ^PB2.VGA.AFN4 (Arg0)
                }

                If (LEqual (PDDN, 0x03))
                {
                    ^PB3.VGA.AFN4 (Arg0)
                }
            }

            Method (AFN5, 0, Serialized)
            {
                If (LEqual (PDDN, One))
                {
                    ^VGA.AFN5 ()
                }

                If (LEqual (PDDN, 0x02))
                {
                    ^PB2.VGA.AFN5 ()
                }

                If (LEqual (PDDN, 0x03))
                {
                    ^PB3.VGA.AFN5 ()
                }
            }

            Method (AFN6, 0, Serialized)
            {
                If (LEqual (PDDN, One))
                {
                    ^VGA.AFN6 ()
                }

                If (LEqual (PDDN, 0x02))
                {
                    ^PB2.VGA.AFN6 ()
                }

                If (LEqual (PDDN, 0x03))
                {
                    ^PB3.VGA.AFN6 ()
                }
            }

            Name (PR00, Package (0x1B)
            {
                Package (0x04)
                {
                    0x0011FFFF, 
                    Zero, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    Zero, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    Zero, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    Zero, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    Zero, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    One, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    Zero, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    One, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x02, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x03, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    Zero, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    Zero, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    Zero, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0010FFFF, 
                    Zero, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0010FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }
            })
            Name (AR00, Package (0x1B)
            {
                Package (0x04)
                {
                    0x0011FFFF, 
                    Zero, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    Zero, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    Zero, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0015FFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    Zero, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    Zero, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    One, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    Zero, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    One, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x02, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x03, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    Zero, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    Zero, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    Zero, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x0010FFFF, 
                    Zero, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0010FFFF, 
                    One, 
                    Zero, 
                    0x11
                }
            })
            Method (_PRT, 0, NotSerialized)
            {
                If (PICM)
                {
                    Return (AR00)
                }

                Return (PR00)
            }

            Device (VGA)
            {
                Name (_ADR, 0x00010000)
                OperationRegion (AGPD, PCI_Config, 0x2E, One)
                Field (AGPD, ByteAcc, NoLock, Preserve)
                {
                    SDID,   8
                }

                Name (PXEN, 0x80000001)
                Name (PXID, 0x00020000)
                Name (PXMX, 0x80000001)
                Name (PXFX, 0x80000001)
                Name (PXDY, 0x80000001)
                Name (AF7E, 0x80000000)
                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Name (DOSA, Zero)
                Method (_DOS, 1, NotSerialized)
                {
                    Store (Arg0, DOSA)
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Name (DODL, Package (0x05)
                    {
                        0x00010100, 
                        0x00010110, 
                        0x0200, 
                        0x00010210, 
                        0x00010220
                    })
                    Return (DODL)
                }

                Method (SWHD, 1, Serialized)
                {
                    Store (One, UPDN)
                    Store (Arg0, NXTD)
                    Notify (VGA, 0x80)
                }

                Name (UPDN, One)
                Name (NXTD, One)
                Device (LCD)
                {
                    Name (_ADR, 0x0110)
                    Name (BRLV, Package (0x11)
                    {
                        0x52, 
                        0x22, 
                        0x02, 
                        0x08, 
                        0x0E, 
                        0x16, 
                        0x1C, 
                        0x22, 
                        0x2A, 
                        0x30, 
                        0x36, 
                        0x3E, 
                        0x44, 
                        0x4B, 
                        0x52, 
                        0x58, 
                        0x64
                    })
                    Name (CUBL, 0x64)
                    Name (BLB0, Package (0x0A)
                    {
                        0x64, 
                        0x19, 
                        0x08, 
                        0x0D, 
                        0x11, 
                        0x19, 
                        0x28, 
                        0x37, 
                        0x49, 
                        0x64
                    })
                    Name (BLB1, Package (0x0A)
                    {
                        0x64, 
                        0x19, 
                        0x09, 
                        0x0D, 
                        0x11, 
                        0x19, 
                        0x28, 
                        0x37, 
                        0x48, 
                        0x64
                    })
                    Name (MCBL, Package (0x0A)
                    {
                        0x64, 
                        0x28, 
                        0x0A, 
                        0x14, 
                        0x1E, 
                        0x28, 
                        0x37, 
                        0x46, 
                        0x55, 
                        0x64
                    })
                    Name (BL01, Package (0x0A)
                    {
                        0x64, 
                        0x16, 
                        0x07, 
                        0x0A, 
                        0x0E, 
                        0x16, 
                        0x21, 
                        0x2F, 
                        0x3F, 
                        0x64
                    })
                    Name (BL02, Package (0x0A)
                    {
                        0x64, 
                        0x14, 
                        0x07, 
                        0x0A, 
                        0x0D, 
                        0x14, 
                        0x21, 
                        0x2E, 
                        0x3E, 
                        0x64
                    })
                    Name (BL03, Package (0x0A)
                    {
                        0x64, 
                        0x14, 
                        0x07, 
                        0x0A, 
                        0x0E, 
                        0x14, 
                        0x21, 
                        0x2F, 
                        0x3F, 
                        0x64
                    })
                    Name (BL04, Package (0x0A)
                    {
                        0x64, 
                        0x16, 
                        0x08, 
                        0x0B, 
                        0x0F, 
                        0x16, 
                        0x24, 
                        0x33, 
                        0x45, 
                        0x64
                    })
                    Name (BL05, Package (0x0A)
                    {
                        0x64, 
                        0x1A, 
                        0x09, 
                        0x0D, 
                        0x12, 
                        0x1A, 
                        0x2A, 
                        0x39, 
                        0x4B, 
                        0x64
                    })
                    Name (BL06, Package (0x0A)
                    {
                        0x64, 
                        0x1C, 
                        0x0A, 
                        0x0E, 
                        0x13, 
                        0x1C, 
                        0x2C, 
                        0x3D, 
                        0x50, 
                        0x64
                    })
                    Name (BL07, Package (0x0A)
                    {
                        0x64, 
                        0x18, 
                        0x08, 
                        0x0C, 
                        0x10, 
                        0x18, 
                        0x27, 
                        0x35, 
                        0x45, 
                        0x64
                    })
                    Name (BL08, Package (0x0A)
                    {
                        0x64, 
                        0x19, 
                        0x08, 
                        0x0C, 
                        0x10, 
                        0x19, 
                        0x27, 
                        0x35, 
                        0x46, 
                        0x64
                    })
                    Name (BL09, Package (0x0A)
                    {
                        0x64, 
                        0x17, 
                        0x08, 
                        0x0C, 
                        0x0F, 
                        0x17, 
                        0x24, 
                        0x31, 
                        0x40, 
                        0x64
                    })
                    Name (BL10, Package (0x0A)
                    {
                        0x64, 
                        0x1C, 
                        0x0A, 
                        0x0E, 
                        0x13, 
                        0x1C, 
                        0x2D, 
                        0x3E, 
                        0x53, 
                        0x64
                    })
                    Name (BL11, Package (0x0A)
                    {
                        0x64, 
                        0x18, 
                        0x08, 
                        0x0C, 
                        0x10, 
                        0x18, 
                        0x26, 
                        0x34, 
                        0x44, 
                        0x64
                    })
                    Name (BL12, Package (0x0A)
                    {
                        0x64, 
                        0x18, 
                        0x08, 
                        0x0C, 
                        0x10, 
                        0x18, 
                        0x26, 
                        0x34, 
                        0x45, 
                        0x64
                    })
                    Name (BL13, Package (0x0A)
                    {
                        0x64, 
                        0x19, 
                        0x09, 
                        0x0D, 
                        0x11, 
                        0x19, 
                        0x28, 
                        0x37, 
                        0x48, 
                        0x64
                    })
                    Name (BL14, Package (0x0A)
                    {
                        0x64, 
                        0x15, 
                        0x07, 
                        0x0B, 
                        0x0E, 
                        0x15, 
                        0x22, 
                        0x2E, 
                        0x3D, 
                        0x64
                    })
                    Name (BL15, Package (0x0A)
                    {
                        0x64, 
                        0x14, 
                        0x07, 
                        0x0A, 
                        0x0E, 
                        0x14, 
                        0x21, 
                        0x2D, 
                        0x3B, 
                        0x64
                    })
                    Name (BL16, Package (0x0A)
                    {
                        0x64, 
                        0x14, 
                        0x07, 
                        0x0A, 
                        0x0D, 
                        0x14, 
                        0x20, 
                        0x2C, 
                        0x3A, 
                        0x64
                    })
                    Name (BL17, Package (0x0A)
                    {
                        0x64, 
                        0x1A, 
                        0x09, 
                        0x0D, 
                        0x11, 
                        0x1A, 
                        0x29, 
                        0x38, 
                        0x4A, 
                        0x64
                    })
                    Name (BL18, Package (0x0A)
                    {
                        0x64, 
                        0x18, 
                        0x08, 
                        0x0C, 
                        0x10, 
                        0x18, 
                        0x25, 
                        0x33, 
                        0x43, 
                        0x64
                    })
                    Name (BL19, Package (0x0A)
                    {
                        0x64, 
                        0x1A, 
                        0x09, 
                        0x0D, 
                        0x11, 
                        0x1A, 
                        0x28, 
                        0x39, 
                        0x49, 
                        0x64
                    })
                    Name (BL20, Package (0x0A)
                    {
                        0x64, 
                        0x1A, 
                        0x09, 
                        0x0D, 
                        0x11, 
                        0x1A, 
                        0x2A, 
                        0x39, 
                        0x4B, 
                        0x64
                    })
                    Name (MCB8, Package (0x67)
                    {
                        0x64, 
                        0x28, 
                        Zero, 
                        One, 
                        0x02, 
                        0x03, 
                        0x04, 
                        0x05, 
                        0x06, 
                        0x07, 
                        0x08, 
                        0x09, 
                        0x0A, 
                        0x0B, 
                        0x0C, 
                        0x0D, 
                        0x0E, 
                        0x0F, 
                        0x10, 
                        0x11, 
                        0x12, 
                        0x13, 
                        0x14, 
                        0x15, 
                        0x16, 
                        0x17, 
                        0x18, 
                        0x19, 
                        0x1A, 
                        0x1B, 
                        0x1C, 
                        0x1D, 
                        0x1E, 
                        0x1F, 
                        0x20, 
                        0x21, 
                        0x22, 
                        0x23, 
                        0x24, 
                        0x25, 
                        0x26, 
                        0x27, 
                        0x28, 
                        0x29, 
                        0x2A, 
                        0x2B, 
                        0x2C, 
                        0x2D, 
                        0x2E, 
                        0x2F, 
                        0x30, 
                        0x31, 
                        0x32, 
                        0x33, 
                        0x34, 
                        0x35, 
                        0x36, 
                        0x37, 
                        0x38, 
                        0x39, 
                        0x3A, 
                        0x3B, 
                        0x3C, 
                        0x3D, 
                        0x3E, 
                        0x3F, 
                        0x40, 
                        0x41, 
                        0x42, 
                        0x43, 
                        0x44, 
                        0x45, 
                        0x46, 
                        0x47, 
                        0x48, 
                        0x49, 
                        0x4A, 
                        0x4B, 
                        0x4C, 
                        0x4D, 
                        0x4E, 
                        0x4F, 
                        0x50, 
                        0x51, 
                        0x52, 
                        0x53, 
                        0x54, 
                        0x55, 
                        0x56, 
                        0x57, 
                        0x58, 
                        0x59, 
                        0x5A, 
                        0x5B, 
                        0x5C, 
                        0x5D, 
                        0x5E, 
                        0x5F, 
                        0x60, 
                        0x61, 
                        0x62, 
                        0x63, 
                        0x64
                    })
                    Name (SPDF, Package (0x0A)
                    {
                        0x64, 
                        0x19, 
                        Zero, 
                        0x0D, 
                        0x1B, 
                        0x28, 
                        0x37, 
                        0x46, 
                        0x55, 
                        0x64
                    })
                    Method (GIBL, 1, Serialized)
                    {
                        If (LEqual (OSTB, 0x60))
                        {
                            Store (Match (MCB8, MEQ, Arg0, MTR, Zero, 0x02), Local1)
                        }
                        Else
                        {
                            Store (Match (MCBL, MEQ, Arg0, MTR, Zero, 0x02), Local1)
                        }

                        Subtract (Local1, 0x02, Local1)
                        Return (Local1)
                    }

                    Method (BLMP, 1, Serialized)
                    {
                        If (LEqual (LCDD, 0x149EAF06))
                        {
                            Store (BL01, Local0)
                        }
                        Else
                        {
                            If (LEqual (LCDD, 0x159EAF06))
                            {
                                Store (BL02, Local0)
                            }
                            Else
                            {
                                If (LEqual (LCDD, 0x20ECAF06))
                                {
                                    Store (BL03, Local0)
                                }
                                Else
                                {
                                    If (LEqual (LCDD, 0x21ECAF06))
                                    {
                                        Store (BL04, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (LCDD, 0x22ECAF06))
                                        {
                                            Store (BL05, Local0)
                                        }
                                        Else
                                        {
                                            If (LEqual (LCDD, 0x23ECAF06))
                                            {
                                                Store (BL06, Local0)
                                            }
                                            Else
                                            {
                                                If (LEqual (LCDD, 0x1728AF0D))
                                                {
                                                    Store (BL07, Local0)
                                                }
                                                Else
                                                {
                                                    If (LEqual (LCDD, 0x1729AF0D))
                                                    {
                                                        Store (BL08, Local0)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (LCDD, 0x1592AF0D))
                                                        {
                                                            Store (BL09, Local0)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (LCDD, 0x02F6E430))
                                                            {
                                                                Store (BL10, Local0)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (LCDD, 0x02F7E430))
                                                                {
                                                                    Store (BL11, Local0)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (LCDD, 0x02DCE430))
                                                                    {
                                                                        Store (BL12, Local0)
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (LCDD, 0x02E3E430))
                                                                        {
                                                                            Store (BL13, Local0)
                                                                        }
                                                                        Else
                                                                        {
                                                                            If (LEqual (LCDD, 0x033AE430))
                                                                            {
                                                                                Store (BL14, Local0)
                                                                            }
                                                                            Else
                                                                            {
                                                                                If (LEqual (LCDD, 0x3150A34C))
                                                                                {
                                                                                    Store (BL15, Local0)
                                                                                }
                                                                                Else
                                                                                {
                                                                                    If (LEqual (LCDD, 0x3250A34C))
                                                                                    {
                                                                                        Store (BL16, Local0)
                                                                                    }
                                                                                    Else
                                                                                    {
                                                                                        If (LEqual (LCDD, 0x504BA34C))
                                                                                        {
                                                                                            Store (BL17, Local0)
                                                                                        }
                                                                                        Else
                                                                                        {
                                                                                            If (LEqual (LCDD, 0x033BE430))
                                                                                            {
                                                                                                Store (BL18, Local0)
                                                                                            }
                                                                                            Else
                                                                                            {
                                                                                                If (LEqual (LCDD, 0x0396E430))
                                                                                                {
                                                                                                    Store (BL19, Local0)
                                                                                                }
                                                                                                Else
                                                                                                {
                                                                                                    If (LEqual (LCDD, 0x0397E430))
                                                                                                    {
                                                                                                        Store (BL20, Local0)
                                                                                                    }
                                                                                                    Else
                                                                                                    {
                                                                                                        If (LEqual (LDSZ, One))
                                                                                                        {
                                                                                                            Store (BLB0, Local0)
                                                                                                        }
                                                                                                        Else
                                                                                                        {
                                                                                                            Store (BLB1, Local0)
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Add (Arg0, 0x02, Local1)
                        Return (DerefOf (Index (Local0, Local1)))
                    }

                    Method (_BCL, 0, NotSerialized)
                    {
                        If (LEqual (OSTB, 0x60))
                        {
                            Return (MCB8)
                        }
                        Else
                        {
                            Return (MCBL)
                        }
                    }

                    Method (_BCM, 1, NotSerialized)
                    {
                        Store (Arg0, CUBL)
                        Store (GIBL (Arg0), ^^^^VALZ.BRTL)
                        Store (BLMP (^^^^VALZ.BRTL), BRTL)
                        Acquire (^^^LPC0.PSMX, 0xFFFF)
                        Store (0x72, BCMD)
                        KSMI (Zero)
                        Release (^^^LPC0.PSMX)
                    }

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

                OperationRegion (PCIG, PCI_Config, Zero, 0x50)
                Field (PCIG, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x18), 
                    GBA2,   32
                }

                OperationRegion (GFMM, SystemMemory, GBA2, 0x6000)
                Field (GFMM, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x5F68), 
                    AZPS,   32
                }

                Name (ATIB, Buffer (0x0100) {})
                Method (ATIF, 2, Serialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Return (AF00 ())
                    }

                    If (LEqual (Arg0, One))
                    {
                        Return (AF01 ())
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Return (AF02 ())
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (AF03 (DerefOf (Index (Arg1, 0x02)), DerefOf (Index (Arg1, 
                            0x04))))
                    }

                    If (LEqual (Arg0, 0x0F))
                    {
                        Return (AF15 ())
                    }
                    Else
                    {
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateWordField (ATIB, 0x02, VERN)
                        CreateDWordField (ATIB, 0x04, NMSK)
                        CreateDWordField (ATIB, 0x08, SFUN)
                        Store (Zero, SSZE)
                        Store (Zero, VERN)
                        Store (Zero, NMSK)
                        Store (Zero, SFUN)
                        Return (ATIB)
                    }
                }

                Method (AF00, 0, NotSerialized)
                {
                    And (AZPS, 0xC0000001, AZPS)
                    CreateWordField (ATIB, Zero, SSZE)
                    CreateWordField (ATIB, 0x02, VERN)
                    CreateDWordField (ATIB, 0x04, NMSK)
                    CreateDWordField (ATIB, 0x08, SFUN)
                    Store (0x0C, SSZE)
                    Store (One, VERN)
                    If (LEqual (PXEN, 0x80000000))
                    {
                        Store (0x11, NMSK)
                    }
                    Else
                    {
                        Store (0x51, NMSK)
                    }

                    Store (NMSK, MSKN)
                    Store (0x4007, SFUN)
                    Return (ATIB)
                }

                Method (AF01, 0, NotSerialized)
                {
                    CreateWordField (ATIB, Zero, SSZE)
                    CreateDWordField (ATIB, 0x02, VMSK)
                    CreateDWordField (ATIB, 0x06, FLGS)
                    Store (0x0A, SSZE)
                    Store (0x03, VMSK)
                    Store (One, FLGS)
                    Return (ATIB)
                }

                Name (PSBR, Buffer (0x04)
                {
                    0x00, 0x00, 0x00, 0x00
                })
                Name (MSKN, Zero)
                Name (SEXM, Zero)
                Name (STHG, Zero)
                Name (STHI, Zero)
                Name (SFPG, Zero)
                Name (SFPI, Zero)
                Name (SSPS, Zero)
                Name (SSDM, 0x0A)
                Name (SCDY, Zero)
                Name (SACT, Buffer (0x07)
                {
                    0x01, 0x02, 0x08, 0x80, 0x03, 0x09, 0x81
                })
                Method (AF02, 0, NotSerialized)
                {
                    CreateBitField (PSBR, Zero, PDSW)
                    CreateBitField (PSBR, One, PEXM)
                    CreateBitField (PSBR, 0x02, PTHR)
                    CreateBitField (PSBR, 0x03, PFPS)
                    CreateBitField (PSBR, 0x04, PSPS)
                    CreateBitField (PSBR, 0x05, PDCC)
                    CreateBitField (PSBR, 0x06, PXPS)
                    CreateWordField (ATIB, Zero, SSZE)
                    CreateDWordField (ATIB, 0x02, PSBI)
                    CreateByteField (ATIB, 0x06, EXPM)
                    CreateByteField (ATIB, 0x07, THRM)
                    CreateByteField (ATIB, 0x08, THID)
                    CreateByteField (ATIB, 0x09, FPWR)
                    CreateByteField (ATIB, 0x0A, FPID)
                    CreateByteField (ATIB, 0x0B, SPWR)
                    Store (0x0C, SSZE)
                    Store (PSBR, PSBI)
                    If (PDSW)
                    {
                        Store (Zero, PDSW)
                    }

                    If (PEXM)
                    {
                        Store (SEXM, EXPM)
                        Store (Zero, SEXM)
                        Store (Zero, PEXM)
                    }

                    If (PTHR)
                    {
                        Store (STHG, THRM)
                        Store (STHI, THID)
                        Store (Zero, STHG)
                        Store (Zero, STHI)
                        Store (Zero, PTHR)
                    }

                    If (PFPS)
                    {
                        Store (SFPG, FPWR)
                        Store (SFPI, FPWR)
                        Store (Zero, SFPG)
                        Store (Zero, SFPI)
                        Store (Zero, PFPS)
                    }

                    If (PSPS)
                    {
                        Store (SSPS, SPWR)
                        Store (Zero, PSPS)
                    }

                    If (PXPS)
                    {
                        Store (Zero, PXPS)
                    }

                    Return (ATIB)
                }

                Method (AF03, 2, NotSerialized)
                {
                    CreateWordField (ATIB, Zero, SSZE)
                    CreateWordField (ATIB, 0x02, SSDP)
                    CreateWordField (ATIB, 0x04, SCDP)
                    Store (Arg0, SSDP)
                    Store (Arg1, SCDP)
                    Name (NXTD, 0x06)
                    Name (CIDX, 0x06)
                    Store (SSDP, Local1)
                    And (Local1, 0x8B, Local1)
                    Store (SCDP, Local2)
                    Store (Local2, P80H)
                    Store (Zero, Local0)
                    While (LLess (Local0, SizeOf (SACT)))
                    {
                        Store (DerefOf (Index (SACT, Local0)), Local3)
                        If (LEqual (Local3, Local1))
                        {
                            Store (Local0, CIDX)
                            Store (SizeOf (SACT), Local0)
                        }
                        Else
                        {
                            Increment (Local0)
                        }
                    }

                    Store (CIDX, Local0)
                    While (LLess (Local0, SizeOf (SACT)))
                    {
                        Increment (Local0)
                        If (LEqual (Local0, SizeOf (SACT)))
                        {
                            Store (Zero, Local0)
                        }

                        Store (DerefOf (Index (SACT, Local0)), Local3)
                        If (LEqual (And (Local3, Local2), Local3))
                        {
                            Store (Local0, NXTD)
                            Store (SizeOf (SACT), Local0)
                        }
                    }

                    If (LEqual (NXTD, SizeOf (SACT)))
                    {
                        Store (Zero, SSDP)
                    }
                    Else
                    {
                        Store (NXTD, Local0)
                        Store (DerefOf (Index (SACT, Local0)), Local3)
                        And (SSDP, 0xFFFFFFF4, SSDP)
                        Or (SSDP, Local3, SSDP)
                    }

                    Store (0x04, SSZE)
                    Store (SSDP, P80H)
                    Return (ATIB)
                }

                Method (AFN0, 0, Serialized)
                {
                    If (And (MSKN, One))
                    {
                        CreateBitField (PSBR, Zero, PDSW)
                        Store (One, PDSW)
                        Notify (VGA, 0x81)
                    }
                }

                Method (AFN3, 2, Serialized)
                {
                    If (And (MSKN, 0x08))
                    {
                        Store (Arg0, Local0)
                        Store (Local0, SFPI)
                        Store (Arg1, Local0)
                        Store (And (Local0, 0x03, Local0), SFPG)
                        CreateBitField (PSBR, 0x03, PFPS)
                        Store (One, PFPS)
                        Notify (VGA, 0x81)
                    }
                }

                Method (AFN4, 1, Serialized)
                {
                    If (And (MSKN, 0x10))
                    {
                        Store (Arg0, Local0)
                        Store (SSPS, Local1)
                        Store (Local0, SSPS)
                        If (LEqual (Local0, Local1)) {}
                        Else
                        {
                            CreateBitField (PSBR, 0x04, PSPS)
                            Store (One, PSPS)
                            Notify (VGA, 0x81)
                        }
                    }
                }

                Method (AFN5, 0, Serialized)
                {
                    If (And (MSKN, 0x20))
                    {
                        CreateBitField (PSBR, 0x05, PDCC)
                        Store (One, PDCC)
                        Notify (VGA, 0x81)
                    }
                }

                Method (AFN6, 0, Serialized)
                {
                    If (And (MSKN, 0x40))
                    {
                        CreateBitField (PSBR, 0x06, PXPS)
                        Store (One, PXPS)
                        Notify (VGA, 0x81)
                    }
                }

                Method (AF15, 0, NotSerialized)
                {
                    Store (0xFF, P80H)
                    CreateWordField (ATIB, Zero, DNUM)
                    CreateWordField (ATIB, 0x02, DSZE)
                    CreateDWordField (ATIB, 0x04, FLAG)
                    CreateWordField (ATIB, 0x08, BUSN)
                    CreateWordField (ATIB, 0x0A, DEVN)
                    Store (0x08, DSZE)
                    Store (One, DNUM)
                    Store (0x04, FLAG)
                    Store (Zero, BUSN)
                    Store (One, DEVN)
                    Return (ATIB)
                }

                Scope (\_SB.PCI0.VGA)
                {
                    OperationRegion (REVD, SystemMemory, 0xAFB56018, 0x0000FA04)
                    Field (REVD, AnyAcc, NoLock, Preserve)
                    {
                        SROM,   32, 
                        VROM,   512000
                    }

                    Name (TVGA, Buffer (0xFA00)
                    {
                        0x00
                    })
                    Method (ATRM, 2, Serialized)
                    {
                        Add (Arg0, Arg1, Local0)
                        If (LLessEqual (Local0, SROM))
                        {
                            Multiply (Arg1, 0x08, Local1)
                            Multiply (Arg0, 0x08, Local2)
                            Store (VROM, TVGA)
                            CreateField (TVGA, Local2, Local1, TEMP)
                            Name (RETB, Buffer (Arg1) {})
                            Store (TEMP, RETB)
                            Return (RETB)
                        }
                        Else
                        {
                            If (LLess (Arg0, SROM))
                            {
                                Subtract (SROM, Arg0, Local3)
                                Multiply (Local3, 0x08, Local1)
                                Multiply (Arg0, 0x08, Local2)
                                Store (VROM, TVGA)
                                CreateField (TVGA, Local2, Local1, TEM)
                                Name (RETC, Buffer (Local3) {})
                                Store (TEM, RETC)
                                Return (RETC)
                            }
                            Else
                            {
                                Name (RETD, Buffer (One) {})
                                Return (RETD)
                            }
                        }
                    }
                }

                Scope (\_SB.PCI0.VGA)
                {
                    Name (ATPB, Buffer (0x0100) {})
                    Name (DSID, Ones)
                    Name (HSID, Ones)
                    Name (CNT0, Buffer (0x05)
                    {
                        0x05, 0x00, 0x00, 0x10, 0x01
                    })
                    Name (CNT1, Buffer (0x05)
                    {
                        0x05, 0x01, 0x00, 0x00, 0x01
                    })
                    Name (CNT2, Buffer (0x05)
                    {
                        0x07, 0x03, 0x00, 0x10, 0x02
                    })
                    Name (CNT3, Buffer (0x05)
                    {
                        0x07, 0x07, 0x00, 0x20, 0x02
                    })
                    Name (CNT4, Buffer (0x05)
                    {
                        0x00, 0x09, 0x00, 0x30, 0x02
                    })
                    Name (CNT5, Buffer (0x05)
                    {
                        0x01, 0x00, 0x01, 0x10, 0x01
                    })
                    Name (CNT6, Buffer (0x05)
                    {
                        0x01, 0x01, 0x01, 0x00, 0x01
                    })
                    Name (CNT7, Buffer (0x05)
                    {
                        0x03, 0x03, 0x01, 0x10, 0x02
                    })
                    Name (CNT8, Buffer (0x05)
                    {
                        0x03, 0x07, 0x01, 0x20, 0x02
                    })
                    Name (CNT9, Buffer (0x05)
                    {
                        0x00, 0x09, 0x01, 0x30, 0x02
                    })
                    Method (ATPX, 2, Serialized)
                    {
                        If (LEqual (Arg0, Zero))
                        {
                            Return (PX00 ())
                        }

                        If (LEqual (Arg0, One))
                        {
                            Return (PX01 ())
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            PX02 (DerefOf (Index (Arg1, 0x02)))
                            Return (ATPB)
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            PX03 (DerefOf (Index (Arg1, 0x02)))
                            Return (ATPB)
                        }

                        If (LEqual (Arg0, 0x04))
                        {
                            PX04 (DerefOf (Index (Arg1, 0x02)))
                            Return (ATPB)
                        }

                        If (LEqual (Arg0, 0x08))
                        {
                            Return (PX08 ())
                        }

                        If (LEqual (Arg0, 0x09))
                        {
                            Return (PX09 ())
                        }

                        CreateWordField (ATPB, Zero, SSZE)
                        CreateWordField (ATPB, 0x02, VERN)
                        CreateDWordField (ATPB, 0x04, SFUN)
                        Store (Zero, SSZE)
                        Store (Zero, VERN)
                        Store (Zero, SFUN)
                        Return (ATPB)
                    }

                    Method (PX00, 0, NotSerialized)
                    {
                        Store (0xE0, P80H)
                        CreateWordField (ATPB, Zero, SSZE)
                        CreateWordField (ATPB, 0x02, VERN)
                        CreateDWordField (ATPB, 0x04, SFUN)
                        Store (0x08, SSZE)
                        Store (One, VERN)
                        If (LEqual (PXEN, 0x80000000))
                        {
                            Store (Zero, SFUN)
                            Return (ATPB)
                        }

                        If (LEqual (PXMX, 0x80000000))
                        {
                            Store (0x018F, SFUN)
                        }
                        Else
                        {
                            Store (0x03, SFUN)
                        }

                        If (LEqual (PXID, ^^PB2._ADR))
                        {
                            Store (^^PB2.VGA.SVID, Local0)
                            Store (^^PB2.HDAU.SVID, Local1)
                        }
                        Else
                        {
                            Store (^^PB3.VGA.SVID, Local0)
                            Store (^^PB3.HDAU.SVID, Local1)
                        }

                        If (LNotEqual (Local0, Ones))
                        {
                            Store (Local0, DSID)
                        }

                        If (LNotEqual (Local1, Ones))
                        {
                            Store (Local1, HSID)
                        }

                        Return (ATPB)
                    }

                    Method (PX01, 0, NotSerialized)
                    {
                        Store (0xE1, P80H)
                        CreateWordField (ATPB, Zero, SSZE)
                        CreateDWordField (ATPB, 0x02, VMSK)
                        CreateDWordField (ATPB, 0x06, FLGS)
                        Store (0x0A, SSZE)
                        Store (0x07FF, VMSK)
                        If (LEqual (PXMX, 0x80000000))
                        {
                            Store (0x4B, FLGS)
                        }
                        Else
                        {
                            Store (Zero, FLGS)
                            If (LEqual (PXDY, 0x80000001))
                            {
                                Or (FLGS, 0x0680, FLGS)
                                Or (VMSK, 0x0680, VMSK)
                            }

                            If (LEqual (PXDY, 0x80000002))
                            {
                                Or (FLGS, 0x0280, FLGS)
                            }
                        }

                        Return (ATPB)
                    }

                    Method (PX02, 1, NotSerialized)
                    {
                        CreateWordField (ATPB, Zero, SSZE)
                        CreateByteField (ATPB, 0x02, PWST)
                        Store (0x03, SSZE)
                        Store (Buffer (0x05) {}, Local7)
                        CreateWordField (Local7, Zero, SZZE)
                        CreateField (Local7, 0x10, 0x03, FUCC)
                        CreateField (Local7, 0x13, 0x05, DEVV)
                        CreateByteField (Local7, 0x03, BUSS)
                        CreateByteField (Local7, 0x04, HPST)
                        Store (0x05, SZZE)
                        Store (Zero, BUSS)
                        Store (Zero, FUCC)
                        Store (Buffer (0x04) {}, Local6)
                        CreateByteField (Local6, 0x02, HPOX)
                        And (Arg0, One, PWST)
                        Name (HPOK, Zero)
                        If (PWST)
                        {
                            Store (0x11E2, P80H)
                            If (LEqual (PXID, ^^PB2._ADR))
                            {
                                Store (Zero, ^^PB2.PDC8)
                                Store (Zero, ^^PB2.PDS8)
                                Store (Zero, ^^PB2.HPC8)
                            }
                            Else
                            {
                                Store (Zero, ^^PB3.PDC8)
                                Store (Zero, ^^PB3.PDS8)
                                Store (Zero, ^^PB3.HPC8)
                            }

                            Store (Zero, ^^SMBS.O000)
                            Store (Zero, ^^SMBS.E000)
                            Store (Zero, ^^SMBS.O035)
                            Store (Zero, ^^SMBS.E035)
                            Sleep (0x0A)
                            Store (One, ^^SMBS.O035)
                            Store (Zero, ^^SMBS.E035)
                            Sleep (0x0A)
                            Sleep (0x0A)
                            Store (One, ^^SMBS.MX28)
                            While (LEqual (^^SMBS.I028, Zero)) {}
                            Sleep (0x64)
                            Store (One, ^^SMBS.O000)
                            Store (Zero, ^^SMBS.E000)
                            Store (0x12E2, P80H)
                            Store (Zero, HPOK)
                            Sleep (0x64)
                            Sleep (0x64)
                            If (LEqual (PXID, ^^PB2._ADR))
                            {
                                Store (0x02, DEVV)
                            }
                            Else
                            {
                                Store (0x03, DEVV)
                            }

                            Store (One, HPST)
                            Store (ALIB (0x06, Local7), Local6)
                            Sleep (0x14)
                            Store (Zero, Local2)
                            While (LLess (Local2, 0x0F))
                            {
                                If (LEqual (PXID, ^^PB2._ADR))
                                {
                                    Store (One, ^^PB2.PDC2)
                                }
                                Else
                                {
                                    Store (One, ^^PB3.PDC2)
                                }

                                Store (One, Local4)
                                Store (0xC8, Local5)
                                While (LAnd (Local4, Local5))
                                {
                                    If (LEqual (PXID, ^^PB2._ADR))
                                    {
                                        Store (^^PB2.XPRD (0xA5), Local0)
                                    }
                                    Else
                                    {
                                        Store (^^PB3.XPRD (0xA5), Local0)
                                    }

                                    And (Local0, 0x7F, Local0)
                                    If (LAnd (LGreaterEqual (Local0, 0x10), LNotEqual (Local0, 0x7F)))
                                    {
                                        Store (Zero, Local4)
                                    }
                                    Else
                                    {
                                        Sleep (0x05)
                                        Decrement (Local5)
                                    }
                                }

                                If (LNot (Local4))
                                {
                                    If (LEqual (PXID, ^^PB2._ADR))
                                    {
                                        Store (^^PB2.XPDL (), Local5)
                                    }
                                    Else
                                    {
                                        Store (^^PB3.XPDL (), Local5)
                                    }

                                    If (Local5)
                                    {
                                        If (LEqual (PXID, ^^PB2._ADR))
                                        {
                                            ^^PB2.XPRT ()
                                        }
                                        Else
                                        {
                                            ^^PB3.XPRT ()
                                        }

                                        Sleep (0x05)
                                        Increment (Local2)
                                    }
                                    Else
                                    {
                                        Store (Zero, Local0)
                                        If (LEqual (PXID, ^^PB2._ADR))
                                        {
                                            If (LEqual (^^PB2.XPR2 (), Ones))
                                            {
                                                Store (One, Local0)
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (^^PB3.XPR2 (), Ones))
                                            {
                                                Store (One, Local0)
                                            }
                                        }

                                        If (Local0)
                                        {
                                            Store (One, HPOK)
                                            Store (0x10, Local2)
                                        }
                                        Else
                                        {
                                            Store (Zero, HPOK)
                                            Store (0x10, Local2)
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (0x10, Local2)
                                }
                            }

                            If (LNot (HPOK))
                            {
                                Store (0x13E2, P80H)
                                If (LEqual (PXID, ^^PB2._ADR))
                                {
                                    Store (^^PB2.VGA.DVID, Local1)
                                }
                                Else
                                {
                                    Store (^^PB3.VGA.DVID, Local1)
                                }

                                Sleep (0x0A)
                                Store (One, Local4)
                                Store (0x05, Local5)
                                While (LAnd (Local4, Local5))
                                {
                                    If (LEqual (PXID, ^^PB2._ADR))
                                    {
                                        Store (^^PB2.XPRD (0xA5), Local0)
                                    }
                                    Else
                                    {
                                        Store (^^PB3.XPRD (0xA5), Local0)
                                    }

                                    And (Local0, 0x7F, Local0)
                                    If (LLessEqual (Local0, 0x04))
                                    {
                                        Store (Zero, Local4)
                                    }
                                    Else
                                    {
                                        If (LEqual (PXID, ^^PB2._ADR))
                                        {
                                            Store (^^PB2.VGA.DVID, Local1)
                                        }
                                        Else
                                        {
                                            Store (^^PB3.VGA.DVID, Local1)
                                        }

                                        Sleep (0x05)
                                        Decrement (Local5)
                                    }
                                }

                                If (LEqual (PXID, ^^PB2._ADR))
                                {
                                    Store (0x02, DEVV)
                                }
                                Else
                                {
                                    Store (0x03, DEVV)
                                }

                                Store (Zero, HPST)
                                ALIB (0x06, Local7)
                            }

                            Store (0x14E2, P80H)
                        }
                        Else
                        {
                            Store (0x02E2, P80H)
                            If (LEqual (PXID, ^^PB2._ADR))
                            {
                                Store (0x10, MUXF)
                            }
                            Else
                            {
                                Store (0x18, MUXF)
                            }

                            Store (Zero, ^^SMBS.O000)
                            Store (Zero, ^^SMBS.E000)
                            Sleep (0x0A)
                            Store (Zero, ^^SMBS.O035)
                            Store (Zero, ^^SMBS.E035)
                            Store (0x03E2, P80H)
                            If (LEqual (PXID, ^^PB2._ADR))
                            {
                                Store (One, ^^PB2.PDC2)
                                Store (^^PB2.VGA.DVID, Local1)
                            }
                            Else
                            {
                                Store (One, ^^PB3.PDC2)
                                Store (^^PB3.VGA.DVID, Local1)
                            }

                            Sleep (0x0A)
                            Store (One, Local4)
                            Store (0x05, Local5)
                            While (LAnd (Local4, Local5))
                            {
                                If (LEqual (PXID, ^^PB2._ADR))
                                {
                                    Store (^^PB2.XPRD (0xA5), Local0)
                                }
                                Else
                                {
                                    Store (^^PB3.XPRD (0xA5), Local0)
                                }

                                And (Local0, 0x7F, Local0)
                                If (LLessEqual (Local0, 0x04))
                                {
                                    Store (Zero, Local4)
                                }
                                Else
                                {
                                    If (LEqual (PXID, ^^PB2._ADR))
                                    {
                                        Store (^^PB2.VGA.DVID, Local1)
                                    }
                                    Else
                                    {
                                        Store (^^PB3.VGA.DVID, Local1)
                                    }

                                    Sleep (0x05)
                                    Decrement (Local5)
                                }
                            }

                            If (LEqual (PXID, ^^PB2._ADR))
                            {
                                Store (0x02, DEVV)
                            }
                            Else
                            {
                                Store (0x03, DEVV)
                            }

                            Store (Zero, HPST)
                            ALIB (0x06, Local7)
                            Store (0x02, HPOK)
                            Store (0x04E2, P80H)
                        }

                        If (HPOK)
                        {
                            If (LAnd (LEqual (HPOK, One), LNotEqual (DSID, Ones)))
                            {
                                Store (DSID, Local1)
                                If (LEqual (PXID, ^^PB2._ADR))
                                {
                                    Store (Local1, ^^PB2.VGA.SMID)
                                }
                                Else
                                {
                                    Store (Local1, ^^PB3.VGA.SMID)
                                }

                                Sleep (0x0A)
                                Store (HSID, Local1)
                                If (LNotEqual (Local1, Ones))
                                {
                                    If (LEqual (PXID, ^^PB2._ADR))
                                    {
                                        Store (Local1, ^^PB2.HDAU.SMID)
                                    }
                                    Else
                                    {
                                        Store (Local1, ^^PB3.HDAU.SMID)
                                    }
                                }

                                Sleep (0x0A)
                            }

                            If (LEqual (PXID, ^^PB2._ADR)) {}
                            Else
                            {
                            }
                        }
                    }

                    Method (PX03, 1, NotSerialized)
                    {
                        CreateWordField (ATPB, Zero, SSZE)
                        CreateWordField (ATPB, 0x02, DPSW)
                        Store (0x04, SSZE)
                        And (Arg0, One, DPSW)
                    }

                    Method (PX04, 1, NotSerialized)
                    {
                        Store (0xE4, P80H)
                        CreateWordField (ATPB, Zero, SSZE)
                        CreateWordField (ATPB, 0x02, ICSW)
                        Store (0x04, SSZE)
                        And (Arg0, One, ICSW)
                    }

                    Method (PX08, 0, NotSerialized)
                    {
                        Store (0xE8, P80H)
                        CreateWordField (ATPB, Zero, CNUM)
                        CreateWordField (ATPB, 0x02, CSSZ)
                        Store (0x0A, CNUM)
                        Store (0x05, CSSZ)
                        CreateField (ATPB, 0x20, 0x28, CTI0)
                        Store (CNT0, CTI0)
                        CreateField (ATPB, 0x48, 0x28, CTI1)
                        Store (CNT1, CTI1)
                        CreateField (ATPB, 0x70, 0x28, CTI2)
                        CreateByteField (CNT2, Zero, FLG2)
                        If (LEqual (LPTY, One))
                        {
                            If (LEqual (M92D, One))
                            {
                                Store (Zero, FLG2)
                            }

                            If (LEqual (M92D, 0x02))
                            {
                                Store (0x07, FLG2)
                            }
                        }

                        Store (CNT2, CTI2)
                        CreateField (ATPB, 0x98, 0x28, CTI3)
                        CreateByteField (CNT3, Zero, FLG3)
                        If (LEqual (LPTY, Zero))
                        {
                            Store (0x07, FLG3)
                        }

                        If (LEqual (LPTY, One))
                        {
                            Store (Zero, FLG3)
                        }

                        If (LEqual (LPTY, 0x02))
                        {
                            Store (Zero, FLG3)
                        }

                        If (LEqual (M92D, 0x02))
                        {
                            Store (0x07, FLG3)
                        }

                        Store (CNT3, CTI3)
                        CreateField (ATPB, 0xC0, 0x28, CTI4)
                        Store (CNT4, CTI4)
                        CreateField (ATPB, 0xE8, 0x28, CTI5)
                        Store (CNT5, CTI5)
                        CreateField (ATPB, 0x0110, 0x28, CTI6)
                        Store (CNT6, CTI6)
                        CreateField (ATPB, 0x0138, 0x28, CTI7)
                        CreateByteField (CNT7, Zero, FLG7)
                        If (LEqual (LPTY, One))
                        {
                            If (LEqual (M92D, One))
                            {
                                Store (Zero, FLG7)
                            }

                            If (LEqual (M92D, 0x02))
                            {
                                Store (Zero, FLG7)
                            }
                        }

                        Store (CNT7, CTI7)
                        CreateField (ATPB, 0x0160, 0x28, CTI8)
                        CreateByteField (CNT8, Zero, FLG8)
                        If (LEqual (LPTY, Zero))
                        {
                            Store (0x07, FLG8)
                        }

                        If (LEqual (LPTY, One))
                        {
                            Store (Zero, FLG8)
                        }

                        If (LEqual (LPTY, 0x02))
                        {
                            Store (Zero, FLG8)
                        }

                        If (LEqual (M92D, 0x02))
                        {
                            Store (0x07, FLG8)
                        }

                        Store (CNT8, CTI8)
                        CreateField (ATPB, 0x0188, 0x28, CTI9)
                        CreateByteField (CNT9, Zero, FLG9)
                        If (LEqual (M92D, 0x02))
                        {
                            Store (0x07, FLG9)
                        }

                        Store (CNT9, CTI9)
                        Return (ATPB)
                    }

                    Method (PX09, 0, NotSerialized)
                    {
                        Store (0xE9, P80H)
                        CreateWordField (ATPB, Zero, CNUM)
                        CreateWordField (ATPB, 0x02, CSSZ)
                        Store (Zero, CNUM)
                        Store (Zero, CSSZ)
                        CreateByteField (ATPB, 0x04, ATI0)
                        CreateByteField (ATPB, 0x05, HPD0)
                        CreateByteField (ATPB, 0x06, DDC0)
                        Store (Zero, ATI0)
                        Store (Zero, HPD0)
                        Store (Zero, DDC0)
                        CreateByteField (ATPB, 0x07, ATI1)
                        CreateByteField (ATPB, 0x08, HPD1)
                        CreateByteField (ATPB, 0x09, DDC1)
                        Store (Zero, ATI1)
                        Store (Zero, HPD1)
                        Store (Zero, DDC1)
                        Return (ATPB)
                    }
                }

                Name (AT00, Buffer (0xFF) {})
                Name (AT01, Buffer (0x03) {})
                Method (ATCS, 2, Serialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        ATC0 ()
                    }

                    If (LEqual (Arg0, One))
                    {
                        ATC1 ()
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        ATC2 (Arg1)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        ATC3 ()
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        ATC4 (Arg1)
                    }

                    Return (AT00)
                }

                Method (ATC0, 0, NotSerialized)
                {
                    CreateWordField (AT00, Zero, SZZE)
                    CreateWordField (AT00, 0x02, INTF)
                    CreateDWordField (AT00, 0x04, SUPP)
                    Store (0x08, SZZE)
                    Store (One, INTF)
                    Store (0x0F, SUPP)
                }

                Method (ATC1, 0, Serialized)
                {
                    CreateWordField (AT00, Zero, SZZE)
                    CreateDWordField (AT00, 0x02, VFMK)
                    CreateDWordField (AT00, 0x06, FLAG)
                    CreateField (AT00, 0x30, One, DOCK)
                    Store (0x0A, SZZE)
                    Store (One, VFMK)
                    Store (Zero, FLAG)
                    Store (One, DOCK)
                }

                Method (ATC2, 1, Serialized)
                {
                    CreateField (Arg0, 0x10, 0x03, FUCC)
                    CreateField (Arg0, 0x13, 0x06, DEVV)
                    CreateByteField (Arg0, 0x03, BUSS)
                    CreateDWordField (Arg0, 0x04, VFMK)
                    CreateDWordField (Arg0, 0x06, FLAG)
                    CreateField (Arg0, 0x30, One, ADVC)
                    CreateField (Arg0, 0x31, One, WFCM)
                    CreateByteField (Arg0, 0x08, RQST)
                    CreateByteField (Arg0, 0x09, PFRQ)
                    CreateWordField (AT00, Zero, SZZE)
                    CreateByteField (AT00, 0x02, RETV)
                    Store (0x03, SZZE)
                    Store (One, RETV)
                    Store (ALIB (0x02, Arg0), AT00)
                }

                Method (ATC3, 0, Serialized)
                {
                    CreateWordField (AT00, Zero, SZZE)
                    CreateByteField (AT00, 0x02, RETV)
                    CreateWordField (AT01, Zero, SZZB)
                    CreateByteField (AT01, 0x02, PSPP)
                    Store (0x03, SZZE)
                    Store (One, RETV)
                    Store (0x03, SZZB)
                    Store (One, PSPP)
                    Store (ALIB (0x03, AT01), AT00)
                }

                Method (ATC4, 1, Serialized)
                {
                    CreateField (Arg0, 0x10, 0x03, FUCC)
                    CreateField (Arg0, 0x13, 0x06, DEVV)
                    CreateByteField (Arg0, 0x03, BUSS)
                    CreateByteField (Arg0, 0x04, NULN)
                    CreateWordField (AT00, Zero, SZZE)
                    CreateByteField (AT00, 0x02, NULM)
                    Store (0x03, SZZE)
                    Store (One, NULM)
                    Store (ALIB (0x04, Arg0), AT00)
                }
            }

            Device (PB2)
            {
                Name (_ADR, 0x00020000)
                Name (PR02, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKB, 
                        Zero
                    }
                })
                Name (AR02, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x12
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x13
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x11
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR02)
                    }

                    Return (PR02)
                }

                OperationRegion (XPEX, SystemMemory, 0xF8010100, 0x0100)
                Field (XPEX, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x28), 
                    VC0S,   32
                }

                OperationRegion (XPCB, PCI_Config, 0x58, 0x24)
                Field (XPCB, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    LKCN,   16, 
                    LKST,   16, 
                            Offset (0x18), 
                        ,   3, 
                    PDC8,   1, 
                        ,   2, 
                    PDS8,   1, 
                            Offset (0x19), 
                    HPC8,   1, 
                            Offset (0x1A), 
                        ,   3, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x1B), 
                    HPCS,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PMES,   1
                }

                OperationRegion (XPRI, PCI_Config, 0xE0, 0x08)
                Field (XPRI, ByteAcc, NoLock, Preserve)
                {
                    XPIR,   32, 
                    XPID,   32
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Method (XPDL, 0, NotSerialized)
                {
                    If (And (VC0S, 0x00020000))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Mutex (XPPM, 0x00)
                Method (XPRD, 1, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (XPID, Local0)
                    Store (Zero, XPIR)
                    Release (XPPM)
                    Return (Local0)
                }

                Method (XPWR, 2, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (Arg1, XPID)
                    Store (Zero, XPIR)
                    Release (XPPM)
                }

                Method (XPRT, 0, NotSerialized)
                {
                    Store (XPRD (0xA2), Local0)
                    And (Local0, 0xFFFFFFF8, Local0)
                    ShiftRight (Local0, 0x04, Local1)
                    And (Local1, 0x07, Local1)
                    Or (Local0, Local1, Local0)
                    Or (Local0, 0x0100, Local0)
                    XPWR (0xA2, Local0)
                }

                Method (XPR2, 0, NotSerialized)
                {
                    Store (LKCN, Local0)
                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LKCN)
                    Store (0x64, Local1)
                    Store (One, Local2)
                    While (LAnd (Local1, Local2))
                    {
                        Sleep (One)
                        Store (LKST, Local3)
                        If (And (Local3, 0x0800))
                        {
                            Decrement (Local1)
                        }
                        Else
                        {
                            Store (Zero, Local2)
                        }
                    }

                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    If (LNot (Local2))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local1)
                    Store (And (Local0, 0x0F), Local2)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                Method (XPPR, 1, NotSerialized)
                {
                    Name (HPOK, Zero)
                    Store (Zero, HPOK)
                    Store (ShiftLeft (XPPB (), 0x03), Local0)
                    If (Arg0)
                    {
                        XPLL (Local0, One)
                        XPLP (Local0, One)
                        Sleep (0xC8)
                        XPTR (Local0, One)
                        Store (0x0F, Local5)
                        While (LAnd (LNot (HPOK), LGreater (Local5, Zero)))
                        {
                            Store (One, PDC2)
                            Store (0x28, Local1)
                            While (LAnd (LNot (HPOK), LGreater (Local1, Zero)))
                            {
                                Store (XPRD (0xA5), Local2)
                                If (LEqual (And (Local2, 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LGreaterEqual (And (Local2, 0xFF), 0x04))
                                {
                                    Store (One, HPOK)
                                }

                                Decrement (Local1)
                            }

                            If (HPOK)
                            {
                                Store (And (XPRD (0xA5), 0xFF), Local2)
                                Store (And (ShiftRight (XPRD (0xA2), 0x04), 0x07), Local3)
                                If (LAnd (LEqual (Local2, 0x06), LAnd (LGreater (Local3, One), LLess (
                                    Local3, 0x05))))
                                {
                                    Store (Zero, HPOK)
                                }
                            }

                            If (HPOK)
                            {
                                Store (0x07D0, Local1)
                                Store (Zero, HPOK)
                                While (LAnd (LNot (HPOK), Local1))
                                {
                                    Store (And (XPRD (0xA5), 0xFF), Local2)
                                    If (LEqual (Local2, 0x07))
                                    {
                                        Store (One, Local1)
                                        Store (XPDL (), Local4)
                                        If (Local4)
                                        {
                                            XPRT ()
                                            Decrement (Local5)
                                        }
                                    }

                                    If (LEqual (Local2, 0x10))
                                    {
                                        Store (One, HPOK)
                                    }

                                    Sleep (One)
                                    Decrement (Local1)
                                }
                            }
                        }
                    }

                    If (HPOK)
                    {
                        XPTR (Local0, Zero)
                        XPLP (Local0, Zero)
                        XPLL (Local0, Zero)
                    }

                    Return (Ones)
                }

                Device (VGA)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x50)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                                Offset (0x2C), 
                        SVID,   32, 
                                Offset (0x4C), 
                        SMID,   32
                    }

                    Name (DOSA, Zero)
                    Method (_DOS, 1, NotSerialized)
                    {
                        Store (Arg0, DOSA)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Name (DODL, Package (0x05)
                        {
                            0x00010100, 
                            0x00010110, 
                            0x0200, 
                            0x00010210, 
                            0x00010220
                        })
                        Return (DODL)
                    }

                    Method (SWHD, 1, Serialized)
                    {
                        Store (One, UPDN)
                        Store (Arg0, NXTD)
                        Notify (VGA, 0x80)
                    }

                    Name (UPDN, One)
                    Name (NXTD, One)
                    Device (LCD)
                    {
                        Name (_ADR, 0x0110)
                        Name (BRLV, Package (0x11)
                        {
                            0x52, 
                            0x22, 
                            0x02, 
                            0x08, 
                            0x0E, 
                            0x16, 
                            0x1C, 
                            0x22, 
                            0x2A, 
                            0x30, 
                            0x36, 
                            0x3E, 
                            0x44, 
                            0x4B, 
                            0x52, 
                            0x58, 
                            0x64
                        })
                        Name (CUBL, 0x64)
                        Name (BLB0, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x08, 
                            0x0D, 
                            0x11, 
                            0x19, 
                            0x28, 
                            0x37, 
                            0x49, 
                            0x64
                        })
                        Name (BLB1, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x19, 
                            0x28, 
                            0x37, 
                            0x48, 
                            0x64
                        })
                        Name (MCBL, Package (0x0A)
                        {
                            0x64, 
                            0x28, 
                            0x0A, 
                            0x14, 
                            0x1E, 
                            0x28, 
                            0x37, 
                            0x46, 
                            0x55, 
                            0x64
                        })
                        Name (BL01, Package (0x0A)
                        {
                            0x64, 
                            0x16, 
                            0x07, 
                            0x0A, 
                            0x0E, 
                            0x16, 
                            0x21, 
                            0x2F, 
                            0x3F, 
                            0x64
                        })
                        Name (BL02, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0D, 
                            0x14, 
                            0x21, 
                            0x2E, 
                            0x3E, 
                            0x64
                        })
                        Name (BL03, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0E, 
                            0x14, 
                            0x21, 
                            0x2F, 
                            0x3F, 
                            0x64
                        })
                        Name (BL04, Package (0x0A)
                        {
                            0x64, 
                            0x16, 
                            0x08, 
                            0x0B, 
                            0x0F, 
                            0x16, 
                            0x24, 
                            0x33, 
                            0x45, 
                            0x64
                        })
                        Name (BL05, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x12, 
                            0x1A, 
                            0x2A, 
                            0x39, 
                            0x4B, 
                            0x64
                        })
                        Name (BL06, Package (0x0A)
                        {
                            0x64, 
                            0x1C, 
                            0x0A, 
                            0x0E, 
                            0x13, 
                            0x1C, 
                            0x2C, 
                            0x3D, 
                            0x50, 
                            0x64
                        })
                        Name (BL07, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x27, 
                            0x35, 
                            0x45, 
                            0x64
                        })
                        Name (BL08, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x19, 
                            0x27, 
                            0x35, 
                            0x46, 
                            0x64
                        })
                        Name (BL09, Package (0x0A)
                        {
                            0x64, 
                            0x17, 
                            0x08, 
                            0x0C, 
                            0x0F, 
                            0x17, 
                            0x24, 
                            0x31, 
                            0x40, 
                            0x64
                        })
                        Name (BL10, Package (0x0A)
                        {
                            0x64, 
                            0x1C, 
                            0x0A, 
                            0x0E, 
                            0x13, 
                            0x1C, 
                            0x2D, 
                            0x3E, 
                            0x53, 
                            0x64
                        })
                        Name (BL11, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x26, 
                            0x34, 
                            0x44, 
                            0x64
                        })
                        Name (BL12, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x26, 
                            0x34, 
                            0x45, 
                            0x64
                        })
                        Name (BL13, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x19, 
                            0x28, 
                            0x37, 
                            0x48, 
                            0x64
                        })
                        Name (BL14, Package (0x0A)
                        {
                            0x64, 
                            0x15, 
                            0x07, 
                            0x0B, 
                            0x0E, 
                            0x15, 
                            0x22, 
                            0x2E, 
                            0x3D, 
                            0x64
                        })
                        Name (BL15, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0E, 
                            0x14, 
                            0x21, 
                            0x2D, 
                            0x3B, 
                            0x64
                        })
                        Name (BL16, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0D, 
                            0x14, 
                            0x20, 
                            0x2C, 
                            0x3A, 
                            0x64
                        })
                        Name (BL17, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x1A, 
                            0x29, 
                            0x38, 
                            0x4A, 
                            0x64
                        })
                        Name (BL18, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x25, 
                            0x33, 
                            0x43, 
                            0x64
                        })
                        Name (BL19, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x1A, 
                            0x28, 
                            0x39, 
                            0x49, 
                            0x64
                        })
                        Name (BL20, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x1A, 
                            0x2A, 
                            0x39, 
                            0x4B, 
                            0x64
                        })
                        Name (MCB8, Package (0x67)
                        {
                            0x64, 
                            0x28, 
                            Zero, 
                            One, 
                            0x02, 
                            0x03, 
                            0x04, 
                            0x05, 
                            0x06, 
                            0x07, 
                            0x08, 
                            0x09, 
                            0x0A, 
                            0x0B, 
                            0x0C, 
                            0x0D, 
                            0x0E, 
                            0x0F, 
                            0x10, 
                            0x11, 
                            0x12, 
                            0x13, 
                            0x14, 
                            0x15, 
                            0x16, 
                            0x17, 
                            0x18, 
                            0x19, 
                            0x1A, 
                            0x1B, 
                            0x1C, 
                            0x1D, 
                            0x1E, 
                            0x1F, 
                            0x20, 
                            0x21, 
                            0x22, 
                            0x23, 
                            0x24, 
                            0x25, 
                            0x26, 
                            0x27, 
                            0x28, 
                            0x29, 
                            0x2A, 
                            0x2B, 
                            0x2C, 
                            0x2D, 
                            0x2E, 
                            0x2F, 
                            0x30, 
                            0x31, 
                            0x32, 
                            0x33, 
                            0x34, 
                            0x35, 
                            0x36, 
                            0x37, 
                            0x38, 
                            0x39, 
                            0x3A, 
                            0x3B, 
                            0x3C, 
                            0x3D, 
                            0x3E, 
                            0x3F, 
                            0x40, 
                            0x41, 
                            0x42, 
                            0x43, 
                            0x44, 
                            0x45, 
                            0x46, 
                            0x47, 
                            0x48, 
                            0x49, 
                            0x4A, 
                            0x4B, 
                            0x4C, 
                            0x4D, 
                            0x4E, 
                            0x4F, 
                            0x50, 
                            0x51, 
                            0x52, 
                            0x53, 
                            0x54, 
                            0x55, 
                            0x56, 
                            0x57, 
                            0x58, 
                            0x59, 
                            0x5A, 
                            0x5B, 
                            0x5C, 
                            0x5D, 
                            0x5E, 
                            0x5F, 
                            0x60, 
                            0x61, 
                            0x62, 
                            0x63, 
                            0x64
                        })
                        Name (SPDF, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            Zero, 
                            0x0D, 
                            0x1B, 
                            0x28, 
                            0x37, 
                            0x46, 
                            0x55, 
                            0x64
                        })
                        Method (GIBL, 1, Serialized)
                        {
                            If (LEqual (OSTB, 0x60))
                            {
                                Store (Match (MCB8, MEQ, Arg0, MTR, Zero, 0x02), Local1)
                            }
                            Else
                            {
                                Store (Match (MCBL, MEQ, Arg0, MTR, Zero, 0x02), Local1)
                            }

                            Subtract (Local1, 0x02, Local1)
                            Return (Local1)
                        }

                        Method (BLMP, 1, Serialized)
                        {
                            If (LEqual (LCDD, 0x149EAF06))
                            {
                                Store (BL01, Local0)
                            }
                            Else
                            {
                                If (LEqual (LCDD, 0x159EAF06))
                                {
                                    Store (BL02, Local0)
                                }
                                Else
                                {
                                    If (LEqual (LCDD, 0x20ECAF06))
                                    {
                                        Store (BL03, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (LCDD, 0x21ECAF06))
                                        {
                                            Store (BL04, Local0)
                                        }
                                        Else
                                        {
                                            If (LEqual (LCDD, 0x22ECAF06))
                                            {
                                                Store (BL05, Local0)
                                            }
                                            Else
                                            {
                                                If (LEqual (LCDD, 0x23ECAF06))
                                                {
                                                    Store (BL06, Local0)
                                                }
                                                Else
                                                {
                                                    If (LEqual (LCDD, 0x1728AF0D))
                                                    {
                                                        Store (BL07, Local0)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (LCDD, 0x1729AF0D))
                                                        {
                                                            Store (BL08, Local0)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (LCDD, 0x1592AF0D))
                                                            {
                                                                Store (BL09, Local0)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (LCDD, 0x02F6E430))
                                                                {
                                                                    Store (BL10, Local0)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (LCDD, 0x02F7E430))
                                                                    {
                                                                        Store (BL11, Local0)
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (LCDD, 0x02DCE430))
                                                                        {
                                                                            Store (BL12, Local0)
                                                                        }
                                                                        Else
                                                                        {
                                                                            If (LEqual (LCDD, 0x02E3E430))
                                                                            {
                                                                                Store (BL13, Local0)
                                                                            }
                                                                            Else
                                                                            {
                                                                                If (LEqual (LCDD, 0x033AE430))
                                                                                {
                                                                                    Store (BL14, Local0)
                                                                                }
                                                                                Else
                                                                                {
                                                                                    If (LEqual (LCDD, 0x3150A34C))
                                                                                    {
                                                                                        Store (BL15, Local0)
                                                                                    }
                                                                                    Else
                                                                                    {
                                                                                        If (LEqual (LCDD, 0x3250A34C))
                                                                                        {
                                                                                            Store (BL16, Local0)
                                                                                        }
                                                                                        Else
                                                                                        {
                                                                                            If (LEqual (LCDD, 0x504BA34C))
                                                                                            {
                                                                                                Store (BL17, Local0)
                                                                                            }
                                                                                            Else
                                                                                            {
                                                                                                If (LEqual (LCDD, 0x033BE430))
                                                                                                {
                                                                                                    Store (BL18, Local0)
                                                                                                }
                                                                                                Else
                                                                                                {
                                                                                                    If (LEqual (LCDD, 0x0396E430))
                                                                                                    {
                                                                                                        Store (BL19, Local0)
                                                                                                    }
                                                                                                    Else
                                                                                                    {
                                                                                                        If (LEqual (LCDD, 0x0397E430))
                                                                                                        {
                                                                                                            Store (BL20, Local0)
                                                                                                        }
                                                                                                        Else
                                                                                                        {
                                                                                                            If (LEqual (LDSZ, One))
                                                                                                            {
                                                                                                                Store (BLB0, Local0)
                                                                                                            }
                                                                                                            Else
                                                                                                            {
                                                                                                                Store (BLB1, Local0)
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            Add (Arg0, 0x02, Local1)
                            Return (DerefOf (Index (Local0, Local1)))
                        }

                        Method (_BCL, 0, NotSerialized)
                        {
                            If (LEqual (OSTB, 0x60))
                            {
                                Return (MCB8)
                            }
                            Else
                            {
                                Return (MCBL)
                            }
                        }

                        Method (_BCM, 1, NotSerialized)
                        {
                            Store (Arg0, CUBL)
                            Store (GIBL (Arg0), ^^^^^VALZ.BRTL)
                            Store (BLMP (^^^^^VALZ.BRTL), BRTL)
                            Acquire (^^^^LPC0.PSMX, 0xFFFF)
                            Store (0x72, BCMD)
                            KSMI (Zero)
                            Release (^^^^LPC0.PSMX)
                        }

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

                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (Zero)
                    }

                    Name (ATIB, Buffer (0x0100) {})
                    Method (ATIF, 2, Serialized)
                    {
                        If (LEqual (Arg0, Zero))
                        {
                            Return (AF00 ())
                        }

                        If (LEqual (Arg0, One))
                        {
                            Return (AF01 ())
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            Return (AF02 ())
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            Return (AF03 (DerefOf (Index (Arg1, 0x02)), DerefOf (Index (Arg1, 
                                0x04))))
                        }

                        If (LEqual (Arg0, 0x0F))
                        {
                            Return (AF15 ())
                        }
                        Else
                        {
                            CreateWordField (ATIB, Zero, SSZE)
                            CreateWordField (ATIB, 0x02, VERN)
                            CreateDWordField (ATIB, 0x04, NMSK)
                            CreateDWordField (ATIB, 0x08, SFUN)
                            Store (Zero, SSZE)
                            Store (Zero, VERN)
                            Store (Zero, NMSK)
                            Store (Zero, SFUN)
                            Return (ATIB)
                        }
                    }

                    Method (AF00, 0, NotSerialized)
                    {
                        And (^^^VGA.AZPS, 0xC0000001, ^^^VGA.AZPS)
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateWordField (ATIB, 0x02, VERN)
                        CreateDWordField (ATIB, 0x04, NMSK)
                        CreateDWordField (ATIB, 0x08, SFUN)
                        Store (0x0C, SSZE)
                        Store (One, VERN)
                        If (LEqual (^^^VGA.PXEN, 0x80000000))
                        {
                            Store (0x11, NMSK)
                        }
                        Else
                        {
                            Store (0x51, NMSK)
                        }

                        Store (NMSK, MSKN)
                        Store (0x4007, SFUN)
                        Return (ATIB)
                    }

                    Method (AF01, 0, NotSerialized)
                    {
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateDWordField (ATIB, 0x02, VMSK)
                        CreateDWordField (ATIB, 0x06, FLGS)
                        Store (0x0A, SSZE)
                        Store (0x03, VMSK)
                        Store (One, FLGS)
                        Return (ATIB)
                    }

                    Name (PSBR, Buffer (0x04)
                    {
                        0x00, 0x00, 0x00, 0x00
                    })
                    Name (MSKN, Zero)
                    Name (SEXM, Zero)
                    Name (STHG, Zero)
                    Name (STHI, Zero)
                    Name (SFPG, Zero)
                    Name (SFPI, Zero)
                    Name (SSPS, Zero)
                    Name (SSDM, 0x0A)
                    Name (SCDY, Zero)
                    Name (SACT, Buffer (0x07)
                    {
                        0x01, 0x02, 0x08, 0x80, 0x03, 0x09, 0x81
                    })
                    Method (AF02, 0, NotSerialized)
                    {
                        CreateBitField (PSBR, Zero, PDSW)
                        CreateBitField (PSBR, One, PEXM)
                        CreateBitField (PSBR, 0x02, PTHR)
                        CreateBitField (PSBR, 0x03, PFPS)
                        CreateBitField (PSBR, 0x04, PSPS)
                        CreateBitField (PSBR, 0x05, PDCC)
                        CreateBitField (PSBR, 0x06, PXPS)
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateDWordField (ATIB, 0x02, PSBI)
                        CreateByteField (ATIB, 0x06, EXPM)
                        CreateByteField (ATIB, 0x07, THRM)
                        CreateByteField (ATIB, 0x08, THID)
                        CreateByteField (ATIB, 0x09, FPWR)
                        CreateByteField (ATIB, 0x0A, FPID)
                        CreateByteField (ATIB, 0x0B, SPWR)
                        Store (0x0C, SSZE)
                        Store (PSBR, PSBI)
                        If (PDSW)
                        {
                            Store (Zero, PDSW)
                        }

                        If (PEXM)
                        {
                            Store (SEXM, EXPM)
                            Store (Zero, SEXM)
                            Store (Zero, PEXM)
                        }

                        If (PTHR)
                        {
                            Store (STHG, THRM)
                            Store (STHI, THID)
                            Store (Zero, STHG)
                            Store (Zero, STHI)
                            Store (Zero, PTHR)
                        }

                        If (PFPS)
                        {
                            Store (SFPG, FPWR)
                            Store (SFPI, FPWR)
                            Store (Zero, SFPG)
                            Store (Zero, SFPI)
                            Store (Zero, PFPS)
                        }

                        If (PSPS)
                        {
                            Store (SSPS, SPWR)
                            Store (Zero, PSPS)
                        }

                        If (PXPS)
                        {
                            Store (Zero, PXPS)
                        }

                        Return (ATIB)
                    }

                    Method (AF03, 2, NotSerialized)
                    {
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateWordField (ATIB, 0x02, SSDP)
                        CreateWordField (ATIB, 0x04, SCDP)
                        Store (Arg0, SSDP)
                        Store (Arg1, SCDP)
                        Name (NXTD, 0x06)
                        Name (CIDX, 0x06)
                        Store (SSDP, Local1)
                        And (Local1, 0x8B, Local1)
                        Store (SCDP, Local2)
                        Store (Local2, P80H)
                        Store (Zero, Local0)
                        While (LLess (Local0, SizeOf (SACT)))
                        {
                            Store (DerefOf (Index (SACT, Local0)), Local3)
                            If (LEqual (Local3, Local1))
                            {
                                Store (Local0, CIDX)
                                Store (SizeOf (SACT), Local0)
                            }
                            Else
                            {
                                Increment (Local0)
                            }
                        }

                        Store (CIDX, Local0)
                        While (LLess (Local0, SizeOf (SACT)))
                        {
                            Increment (Local0)
                            If (LEqual (Local0, SizeOf (SACT)))
                            {
                                Store (Zero, Local0)
                            }

                            Store (DerefOf (Index (SACT, Local0)), Local3)
                            If (LEqual (And (Local3, Local2), Local3))
                            {
                                Store (Local0, NXTD)
                                Store (SizeOf (SACT), Local0)
                            }
                        }

                        If (LEqual (NXTD, SizeOf (SACT)))
                        {
                            Store (Zero, SSDP)
                        }
                        Else
                        {
                            Store (NXTD, Local0)
                            Store (DerefOf (Index (SACT, Local0)), Local3)
                            And (SSDP, 0xFFFFFFF4, SSDP)
                            Or (SSDP, Local3, SSDP)
                        }

                        Store (0x04, SSZE)
                        Store (SSDP, P80H)
                        Return (ATIB)
                    }

                    Method (AFN0, 0, Serialized)
                    {
                        If (And (MSKN, One))
                        {
                            CreateBitField (PSBR, Zero, PDSW)
                            Store (One, PDSW)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AFN3, 2, Serialized)
                    {
                        If (And (MSKN, 0x08))
                        {
                            Store (Arg0, Local0)
                            Store (Local0, SFPI)
                            Store (Arg1, Local0)
                            Store (And (Local0, 0x03, Local0), SFPG)
                            CreateBitField (PSBR, 0x03, PFPS)
                            Store (One, PFPS)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AFN4, 1, Serialized)
                    {
                        If (And (MSKN, 0x10))
                        {
                            Store (Arg0, Local0)
                            Store (SSPS, Local1)
                            Store (Local0, SSPS)
                            If (LEqual (Local0, Local1)) {}
                            Else
                            {
                                CreateBitField (PSBR, 0x04, PSPS)
                                Store (One, PSPS)
                                Notify (VGA, 0x81)
                            }
                        }
                    }

                    Method (AFN5, 0, Serialized)
                    {
                        If (And (MSKN, 0x20))
                        {
                            CreateBitField (PSBR, 0x05, PDCC)
                            Store (One, PDCC)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AFN6, 0, Serialized)
                    {
                        If (And (MSKN, 0x40))
                        {
                            CreateBitField (PSBR, 0x06, PXPS)
                            Store (One, PXPS)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AF15, 0, NotSerialized)
                    {
                        Store (0xFF, P80H)
                        CreateWordField (ATIB, Zero, DNUM)
                        CreateWordField (ATIB, 0x02, DSZE)
                        CreateDWordField (ATIB, 0x04, FLAG)
                        CreateWordField (ATIB, 0x08, BUSN)
                        CreateWordField (ATIB, 0x0A, DEVN)
                        Store (0x08, DSZE)
                        Store (One, DNUM)
                        Store (0x04, FLAG)
                        Store (Zero, BUSN)
                        Store (One, DEVN)
                        Return (ATIB)
                    }

                    Name (AT00, Buffer (0xFF) {})
                    Name (AT01, Buffer (0x03) {})
                    Method (ATCS, 2, Serialized)
                    {
                        If (LEqual (Arg0, Zero))
                        {
                            ATC0 ()
                        }

                        If (LEqual (Arg0, One))
                        {
                            ATC1 ()
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            ATC2 (Arg1)
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            ATC3 ()
                        }

                        If (LEqual (Arg0, 0x04))
                        {
                            ATC4 (Arg1)
                        }

                        Return (AT00)
                    }

                    Method (ATC0, 0, NotSerialized)
                    {
                        CreateWordField (AT00, Zero, SZZE)
                        CreateWordField (AT00, 0x02, INTF)
                        CreateDWordField (AT00, 0x04, SUPP)
                        Store (0x08, SZZE)
                        Store (One, INTF)
                        Store (0x0F, SUPP)
                    }

                    Method (ATC1, 0, Serialized)
                    {
                        CreateWordField (AT00, Zero, SZZE)
                        CreateDWordField (AT00, 0x02, VFMK)
                        CreateDWordField (AT00, 0x06, FLAG)
                        CreateField (AT00, 0x30, One, DOCK)
                        Store (0x0A, SZZE)
                        Store (One, VFMK)
                        Store (Zero, FLAG)
                        Store (One, DOCK)
                    }

                    Method (ATC2, 1, Serialized)
                    {
                        CreateField (Arg0, 0x10, 0x03, FUCC)
                        CreateField (Arg0, 0x13, 0x06, DEVV)
                        CreateByteField (Arg0, 0x03, BUSS)
                        CreateDWordField (Arg0, 0x04, VFMK)
                        CreateDWordField (Arg0, 0x06, FLAG)
                        CreateField (Arg0, 0x30, One, ADVC)
                        CreateField (Arg0, 0x31, One, WFCM)
                        CreateByteField (Arg0, 0x08, RQST)
                        CreateByteField (Arg0, 0x09, PFRQ)
                        CreateWordField (AT00, Zero, SZZE)
                        CreateByteField (AT00, 0x02, RETV)
                        Store (0x03, SZZE)
                        Store (One, RETV)
                        Store (ALIB (0x02, Arg0), AT00)
                    }

                    Method (ATC3, 0, Serialized)
                    {
                        CreateWordField (AT00, Zero, SZZE)
                        CreateByteField (AT00, 0x02, RETV)
                        CreateWordField (AT01, Zero, SZZB)
                        CreateByteField (AT01, 0x02, PSPP)
                        Store (0x03, SZZE)
                        Store (One, RETV)
                        Store (0x03, SZZB)
                        Store (One, PSPP)
                        Store (ALIB (0x03, AT01), AT00)
                    }

                    Method (ATC4, 1, Serialized)
                    {
                        CreateField (Arg0, 0x10, 0x03, FUCC)
                        CreateField (Arg0, 0x13, 0x06, DEVV)
                        CreateByteField (Arg0, 0x03, BUSS)
                        CreateByteField (Arg0, 0x04, NULN)
                        CreateWordField (AT00, Zero, SZZE)
                        CreateByteField (AT00, 0x02, NULM)
                        Store (0x03, SZZE)
                        Store (One, NULM)
                        Store (ALIB (0x04, Arg0), AT00)
                    }
                }

                Device (HDAU)
                {
                    Name (_ADR, One)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x50)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                                Offset (0x2C), 
                        SVID,   32, 
                                Offset (0x4C), 
                        SMID,   32
                    }
                }
            }

            Device (PB3)
            {
                Name (_ADR, 0x00030000)
                Name (PR03, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKC, 
                        Zero
                    }
                })
                Name (AR03, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x13
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x10
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x12
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR03)
                    }

                    Return (PR03)
                }

                OperationRegion (XPEX, SystemMemory, 0xF8018100, 0x0100)
                Field (XPEX, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x28), 
                    VC0S,   32
                }

                OperationRegion (XPCB, PCI_Config, 0x58, 0x24)
                Field (XPCB, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    LKCN,   16, 
                    LKST,   16, 
                            Offset (0x18), 
                        ,   3, 
                    PDC8,   1, 
                        ,   2, 
                    PDS8,   1, 
                            Offset (0x19), 
                    HPC8,   1, 
                            Offset (0x1A), 
                        ,   3, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x1B), 
                    HPCS,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PMES,   1
                }

                OperationRegion (XPRI, PCI_Config, 0xE0, 0x08)
                Field (XPRI, ByteAcc, NoLock, Preserve)
                {
                    XPIR,   32, 
                    XPID,   32
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Method (XPDL, 0, NotSerialized)
                {
                    If (And (VC0S, 0x00020000))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Mutex (XPPM, 0x00)
                Method (XPRD, 1, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (XPID, Local0)
                    Store (Zero, XPIR)
                    Release (XPPM)
                    Return (Local0)
                }

                Method (XPWR, 2, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (Arg1, XPID)
                    Store (Zero, XPIR)
                    Release (XPPM)
                }

                Method (XPRT, 0, NotSerialized)
                {
                    Store (XPRD (0xA2), Local0)
                    And (Local0, 0xFFFFFFF8, Local0)
                    ShiftRight (Local0, 0x04, Local1)
                    And (Local1, 0x07, Local1)
                    Or (Local0, Local1, Local0)
                    Or (Local0, 0x0100, Local0)
                    XPWR (0xA2, Local0)
                }

                Method (XPR2, 0, NotSerialized)
                {
                    Store (LKCN, Local0)
                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LKCN)
                    Store (0x64, Local1)
                    Store (One, Local2)
                    While (LAnd (Local1, Local2))
                    {
                        Sleep (One)
                        Store (LKST, Local3)
                        If (And (Local3, 0x0800))
                        {
                            Decrement (Local1)
                        }
                        Else
                        {
                            Store (Zero, Local2)
                        }
                    }

                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    If (LNot (Local2))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local1)
                    Store (And (Local0, 0x0F), Local2)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                Method (XPPR, 1, NotSerialized)
                {
                    Name (HPOK, Zero)
                    Store (Zero, HPOK)
                    Store (ShiftLeft (XPPB (), 0x03), Local0)
                    If (Arg0)
                    {
                        XPLL (Local0, One)
                        XPLP (Local0, One)
                        Sleep (0xC8)
                        XPTR (Local0, One)
                        Store (0x0F, Local5)
                        While (LAnd (LNot (HPOK), LGreater (Local5, Zero)))
                        {
                            Store (One, PDC2)
                            Store (0x28, Local1)
                            While (LAnd (LNot (HPOK), LGreater (Local1, Zero)))
                            {
                                Store (XPRD (0xA5), Local2)
                                If (LEqual (And (Local2, 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LGreaterEqual (And (Local2, 0xFF), 0x04))
                                {
                                    Store (One, HPOK)
                                }

                                Decrement (Local1)
                            }

                            If (HPOK)
                            {
                                Store (And (XPRD (0xA5), 0xFF), Local2)
                                Store (And (ShiftRight (XPRD (0xA2), 0x04), 0x07), Local3)
                                If (LAnd (LEqual (Local2, 0x06), LAnd (LGreater (Local3, One), LLess (
                                    Local3, 0x05))))
                                {
                                    Store (Zero, HPOK)
                                }
                            }

                            If (HPOK)
                            {
                                Store (0x07D0, Local1)
                                Store (Zero, HPOK)
                                While (LAnd (LNot (HPOK), Local1))
                                {
                                    Store (And (XPRD (0xA5), 0xFF), Local2)
                                    If (LEqual (Local2, 0x07))
                                    {
                                        Store (One, Local1)
                                        Store (XPDL (), Local4)
                                        If (Local4)
                                        {
                                            XPRT ()
                                            Decrement (Local5)
                                        }
                                    }

                                    If (LEqual (Local2, 0x10))
                                    {
                                        Store (One, HPOK)
                                    }

                                    Sleep (One)
                                    Decrement (Local1)
                                }
                            }
                        }
                    }

                    If (HPOK)
                    {
                        XPTR (Local0, Zero)
                        XPLP (Local0, Zero)
                        XPLL (Local0, Zero)
                    }

                    Return (Ones)
                }

                Device (VGA)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x50)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                                Offset (0x2C), 
                        SVID,   32, 
                                Offset (0x4C), 
                        SMID,   32
                    }

                    Name (DOSA, Zero)
                    Method (_DOS, 1, NotSerialized)
                    {
                        Store (Arg0, DOSA)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Name (DODL, Package (0x05)
                        {
                            0x00010100, 
                            0x00010110, 
                            0x0200, 
                            0x00010210, 
                            0x00010220
                        })
                        Return (DODL)
                    }

                    Method (SWHD, 1, Serialized)
                    {
                        Store (One, UPDN)
                        Store (Arg0, NXTD)
                        Notify (VGA, 0x80)
                    }

                    Name (UPDN, One)
                    Name (NXTD, One)
                    Device (LCD)
                    {
                        Name (_ADR, 0x0110)
                        Name (BRLV, Package (0x11)
                        {
                            0x52, 
                            0x22, 
                            0x02, 
                            0x08, 
                            0x0E, 
                            0x16, 
                            0x1C, 
                            0x22, 
                            0x2A, 
                            0x30, 
                            0x36, 
                            0x3E, 
                            0x44, 
                            0x4B, 
                            0x52, 
                            0x58, 
                            0x64
                        })
                        Name (CUBL, 0x64)
                        Name (BLB0, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x08, 
                            0x0D, 
                            0x11, 
                            0x19, 
                            0x28, 
                            0x37, 
                            0x49, 
                            0x64
                        })
                        Name (BLB1, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x19, 
                            0x28, 
                            0x37, 
                            0x48, 
                            0x64
                        })
                        Name (MCBL, Package (0x0A)
                        {
                            0x64, 
                            0x28, 
                            0x0A, 
                            0x14, 
                            0x1E, 
                            0x28, 
                            0x37, 
                            0x46, 
                            0x55, 
                            0x64
                        })
                        Name (BL01, Package (0x0A)
                        {
                            0x64, 
                            0x16, 
                            0x07, 
                            0x0A, 
                            0x0E, 
                            0x16, 
                            0x21, 
                            0x2F, 
                            0x3F, 
                            0x64
                        })
                        Name (BL02, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0D, 
                            0x14, 
                            0x21, 
                            0x2E, 
                            0x3E, 
                            0x64
                        })
                        Name (BL03, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0E, 
                            0x14, 
                            0x21, 
                            0x2F, 
                            0x3F, 
                            0x64
                        })
                        Name (BL04, Package (0x0A)
                        {
                            0x64, 
                            0x16, 
                            0x08, 
                            0x0B, 
                            0x0F, 
                            0x16, 
                            0x24, 
                            0x33, 
                            0x45, 
                            0x64
                        })
                        Name (BL05, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x12, 
                            0x1A, 
                            0x2A, 
                            0x39, 
                            0x4B, 
                            0x64
                        })
                        Name (BL06, Package (0x0A)
                        {
                            0x64, 
                            0x1C, 
                            0x0A, 
                            0x0E, 
                            0x13, 
                            0x1C, 
                            0x2C, 
                            0x3D, 
                            0x50, 
                            0x64
                        })
                        Name (BL07, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x27, 
                            0x35, 
                            0x45, 
                            0x64
                        })
                        Name (BL08, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x19, 
                            0x27, 
                            0x35, 
                            0x46, 
                            0x64
                        })
                        Name (BL09, Package (0x0A)
                        {
                            0x64, 
                            0x17, 
                            0x08, 
                            0x0C, 
                            0x0F, 
                            0x17, 
                            0x24, 
                            0x31, 
                            0x40, 
                            0x64
                        })
                        Name (BL10, Package (0x0A)
                        {
                            0x64, 
                            0x1C, 
                            0x0A, 
                            0x0E, 
                            0x13, 
                            0x1C, 
                            0x2D, 
                            0x3E, 
                            0x53, 
                            0x64
                        })
                        Name (BL11, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x26, 
                            0x34, 
                            0x44, 
                            0x64
                        })
                        Name (BL12, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x26, 
                            0x34, 
                            0x45, 
                            0x64
                        })
                        Name (BL13, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x19, 
                            0x28, 
                            0x37, 
                            0x48, 
                            0x64
                        })
                        Name (BL14, Package (0x0A)
                        {
                            0x64, 
                            0x15, 
                            0x07, 
                            0x0B, 
                            0x0E, 
                            0x15, 
                            0x22, 
                            0x2E, 
                            0x3D, 
                            0x64
                        })
                        Name (BL15, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0E, 
                            0x14, 
                            0x21, 
                            0x2D, 
                            0x3B, 
                            0x64
                        })
                        Name (BL16, Package (0x0A)
                        {
                            0x64, 
                            0x14, 
                            0x07, 
                            0x0A, 
                            0x0D, 
                            0x14, 
                            0x20, 
                            0x2C, 
                            0x3A, 
                            0x64
                        })
                        Name (BL17, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x1A, 
                            0x29, 
                            0x38, 
                            0x4A, 
                            0x64
                        })
                        Name (BL18, Package (0x0A)
                        {
                            0x64, 
                            0x18, 
                            0x08, 
                            0x0C, 
                            0x10, 
                            0x18, 
                            0x25, 
                            0x33, 
                            0x43, 
                            0x64
                        })
                        Name (BL19, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x1A, 
                            0x28, 
                            0x39, 
                            0x49, 
                            0x64
                        })
                        Name (BL20, Package (0x0A)
                        {
                            0x64, 
                            0x1A, 
                            0x09, 
                            0x0D, 
                            0x11, 
                            0x1A, 
                            0x2A, 
                            0x39, 
                            0x4B, 
                            0x64
                        })
                        Name (MCB8, Package (0x67)
                        {
                            0x64, 
                            0x28, 
                            Zero, 
                            One, 
                            0x02, 
                            0x03, 
                            0x04, 
                            0x05, 
                            0x06, 
                            0x07, 
                            0x08, 
                            0x09, 
                            0x0A, 
                            0x0B, 
                            0x0C, 
                            0x0D, 
                            0x0E, 
                            0x0F, 
                            0x10, 
                            0x11, 
                            0x12, 
                            0x13, 
                            0x14, 
                            0x15, 
                            0x16, 
                            0x17, 
                            0x18, 
                            0x19, 
                            0x1A, 
                            0x1B, 
                            0x1C, 
                            0x1D, 
                            0x1E, 
                            0x1F, 
                            0x20, 
                            0x21, 
                            0x22, 
                            0x23, 
                            0x24, 
                            0x25, 
                            0x26, 
                            0x27, 
                            0x28, 
                            0x29, 
                            0x2A, 
                            0x2B, 
                            0x2C, 
                            0x2D, 
                            0x2E, 
                            0x2F, 
                            0x30, 
                            0x31, 
                            0x32, 
                            0x33, 
                            0x34, 
                            0x35, 
                            0x36, 
                            0x37, 
                            0x38, 
                            0x39, 
                            0x3A, 
                            0x3B, 
                            0x3C, 
                            0x3D, 
                            0x3E, 
                            0x3F, 
                            0x40, 
                            0x41, 
                            0x42, 
                            0x43, 
                            0x44, 
                            0x45, 
                            0x46, 
                            0x47, 
                            0x48, 
                            0x49, 
                            0x4A, 
                            0x4B, 
                            0x4C, 
                            0x4D, 
                            0x4E, 
                            0x4F, 
                            0x50, 
                            0x51, 
                            0x52, 
                            0x53, 
                            0x54, 
                            0x55, 
                            0x56, 
                            0x57, 
                            0x58, 
                            0x59, 
                            0x5A, 
                            0x5B, 
                            0x5C, 
                            0x5D, 
                            0x5E, 
                            0x5F, 
                            0x60, 
                            0x61, 
                            0x62, 
                            0x63, 
                            0x64
                        })
                        Name (SPDF, Package (0x0A)
                        {
                            0x64, 
                            0x19, 
                            Zero, 
                            0x0D, 
                            0x1B, 
                            0x28, 
                            0x37, 
                            0x46, 
                            0x55, 
                            0x64
                        })
                        Method (GIBL, 1, Serialized)
                        {
                            If (LEqual (OSTB, 0x60))
                            {
                                Store (Match (MCB8, MEQ, Arg0, MTR, Zero, 0x02), Local1)
                            }
                            Else
                            {
                                Store (Match (MCBL, MEQ, Arg0, MTR, Zero, 0x02), Local1)
                            }

                            Subtract (Local1, 0x02, Local1)
                            Return (Local1)
                        }

                        Method (BLMP, 1, Serialized)
                        {
                            If (LEqual (LCDD, 0x149EAF06))
                            {
                                Store (BL01, Local0)
                            }
                            Else
                            {
                                If (LEqual (LCDD, 0x159EAF06))
                                {
                                    Store (BL02, Local0)
                                }
                                Else
                                {
                                    If (LEqual (LCDD, 0x20ECAF06))
                                    {
                                        Store (BL03, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (LCDD, 0x21ECAF06))
                                        {
                                            Store (BL04, Local0)
                                        }
                                        Else
                                        {
                                            If (LEqual (LCDD, 0x22ECAF06))
                                            {
                                                Store (BL05, Local0)
                                            }
                                            Else
                                            {
                                                If (LEqual (LCDD, 0x23ECAF06))
                                                {
                                                    Store (BL06, Local0)
                                                }
                                                Else
                                                {
                                                    If (LEqual (LCDD, 0x1728AF0D))
                                                    {
                                                        Store (BL07, Local0)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (LCDD, 0x1729AF0D))
                                                        {
                                                            Store (BL08, Local0)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (LCDD, 0x1592AF0D))
                                                            {
                                                                Store (BL09, Local0)
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (LCDD, 0x02F6E430))
                                                                {
                                                                    Store (BL10, Local0)
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (LCDD, 0x02F7E430))
                                                                    {
                                                                        Store (BL11, Local0)
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (LCDD, 0x02DCE430))
                                                                        {
                                                                            Store (BL12, Local0)
                                                                        }
                                                                        Else
                                                                        {
                                                                            If (LEqual (LCDD, 0x02E3E430))
                                                                            {
                                                                                Store (BL13, Local0)
                                                                            }
                                                                            Else
                                                                            {
                                                                                If (LEqual (LCDD, 0x033AE430))
                                                                                {
                                                                                    Store (BL14, Local0)
                                                                                }
                                                                                Else
                                                                                {
                                                                                    If (LEqual (LCDD, 0x3150A34C))
                                                                                    {
                                                                                        Store (BL15, Local0)
                                                                                    }
                                                                                    Else
                                                                                    {
                                                                                        If (LEqual (LCDD, 0x3250A34C))
                                                                                        {
                                                                                            Store (BL16, Local0)
                                                                                        }
                                                                                        Else
                                                                                        {
                                                                                            If (LEqual (LCDD, 0x504BA34C))
                                                                                            {
                                                                                                Store (BL17, Local0)
                                                                                            }
                                                                                            Else
                                                                                            {
                                                                                                If (LEqual (LCDD, 0x033BE430))
                                                                                                {
                                                                                                    Store (BL18, Local0)
                                                                                                }
                                                                                                Else
                                                                                                {
                                                                                                    If (LEqual (LCDD, 0x0396E430))
                                                                                                    {
                                                                                                        Store (BL19, Local0)
                                                                                                    }
                                                                                                    Else
                                                                                                    {
                                                                                                        If (LEqual (LCDD, 0x0397E430))
                                                                                                        {
                                                                                                            Store (BL20, Local0)
                                                                                                        }
                                                                                                        Else
                                                                                                        {
                                                                                                            If (LEqual (LDSZ, One))
                                                                                                            {
                                                                                                                Store (BLB0, Local0)
                                                                                                            }
                                                                                                            Else
                                                                                                            {
                                                                                                                Store (BLB1, Local0)
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            Add (Arg0, 0x02, Local1)
                            Return (DerefOf (Index (Local0, Local1)))
                        }

                        Method (_BCL, 0, NotSerialized)
                        {
                            If (LEqual (OSTB, 0x60))
                            {
                                Return (MCB8)
                            }
                            Else
                            {
                                Return (MCBL)
                            }
                        }

                        Method (_BCM, 1, NotSerialized)
                        {
                            Store (Arg0, CUBL)
                            Store (GIBL (Arg0), ^^^^^VALZ.BRTL)
                            Store (BLMP (^^^^^VALZ.BRTL), BRTL)
                            Acquire (^^^^LPC0.PSMX, 0xFFFF)
                            Store (0x72, BCMD)
                            KSMI (Zero)
                            Release (^^^^LPC0.PSMX)
                        }

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

                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (Zero)
                    }

                    Name (ATIB, Buffer (0x0100) {})
                    Method (ATIF, 2, Serialized)
                    {
                        If (LEqual (Arg0, Zero))
                        {
                            Return (AF00 ())
                        }

                        If (LEqual (Arg0, One))
                        {
                            Return (AF01 ())
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            Return (AF02 ())
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            Return (AF03 (DerefOf (Index (Arg1, 0x02)), DerefOf (Index (Arg1, 
                                0x04))))
                        }

                        If (LEqual (Arg0, 0x0F))
                        {
                            Return (AF15 ())
                        }
                        Else
                        {
                            CreateWordField (ATIB, Zero, SSZE)
                            CreateWordField (ATIB, 0x02, VERN)
                            CreateDWordField (ATIB, 0x04, NMSK)
                            CreateDWordField (ATIB, 0x08, SFUN)
                            Store (Zero, SSZE)
                            Store (Zero, VERN)
                            Store (Zero, NMSK)
                            Store (Zero, SFUN)
                            Return (ATIB)
                        }
                    }

                    Method (AF00, 0, NotSerialized)
                    {
                        And (^^^VGA.AZPS, 0xC0000001, ^^^VGA.AZPS)
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateWordField (ATIB, 0x02, VERN)
                        CreateDWordField (ATIB, 0x04, NMSK)
                        CreateDWordField (ATIB, 0x08, SFUN)
                        Store (0x0C, SSZE)
                        Store (One, VERN)
                        If (LEqual (^^^VGA.PXEN, 0x80000000))
                        {
                            Store (0x11, NMSK)
                        }
                        Else
                        {
                            Store (0x51, NMSK)
                        }

                        Store (NMSK, MSKN)
                        Store (0x4007, SFUN)
                        Return (ATIB)
                    }

                    Method (AF01, 0, NotSerialized)
                    {
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateDWordField (ATIB, 0x02, VMSK)
                        CreateDWordField (ATIB, 0x06, FLGS)
                        Store (0x0A, SSZE)
                        Store (0x03, VMSK)
                        Store (One, FLGS)
                        Return (ATIB)
                    }

                    Name (PSBR, Buffer (0x04)
                    {
                        0x00, 0x00, 0x00, 0x00
                    })
                    Name (MSKN, Zero)
                    Name (SEXM, Zero)
                    Name (STHG, Zero)
                    Name (STHI, Zero)
                    Name (SFPG, Zero)
                    Name (SFPI, Zero)
                    Name (SSPS, Zero)
                    Name (SSDM, 0x0A)
                    Name (SCDY, Zero)
                    Name (SACT, Buffer (0x07)
                    {
                        0x01, 0x02, 0x08, 0x80, 0x03, 0x09, 0x81
                    })
                    Method (AF02, 0, NotSerialized)
                    {
                        CreateBitField (PSBR, Zero, PDSW)
                        CreateBitField (PSBR, One, PEXM)
                        CreateBitField (PSBR, 0x02, PTHR)
                        CreateBitField (PSBR, 0x03, PFPS)
                        CreateBitField (PSBR, 0x04, PSPS)
                        CreateBitField (PSBR, 0x05, PDCC)
                        CreateBitField (PSBR, 0x06, PXPS)
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateDWordField (ATIB, 0x02, PSBI)
                        CreateByteField (ATIB, 0x06, EXPM)
                        CreateByteField (ATIB, 0x07, THRM)
                        CreateByteField (ATIB, 0x08, THID)
                        CreateByteField (ATIB, 0x09, FPWR)
                        CreateByteField (ATIB, 0x0A, FPID)
                        CreateByteField (ATIB, 0x0B, SPWR)
                        Store (0x0C, SSZE)
                        Store (PSBR, PSBI)
                        If (PDSW)
                        {
                            Store (Zero, PDSW)
                        }

                        If (PEXM)
                        {
                            Store (SEXM, EXPM)
                            Store (Zero, SEXM)
                            Store (Zero, PEXM)
                        }

                        If (PTHR)
                        {
                            Store (STHG, THRM)
                            Store (STHI, THID)
                            Store (Zero, STHG)
                            Store (Zero, STHI)
                            Store (Zero, PTHR)
                        }

                        If (PFPS)
                        {
                            Store (SFPG, FPWR)
                            Store (SFPI, FPWR)
                            Store (Zero, SFPG)
                            Store (Zero, SFPI)
                            Store (Zero, PFPS)
                        }

                        If (PSPS)
                        {
                            Store (SSPS, SPWR)
                            Store (Zero, PSPS)
                        }

                        If (PXPS)
                        {
                            Store (Zero, PXPS)
                        }

                        Return (ATIB)
                    }

                    Method (AF03, 2, NotSerialized)
                    {
                        CreateWordField (ATIB, Zero, SSZE)
                        CreateWordField (ATIB, 0x02, SSDP)
                        CreateWordField (ATIB, 0x04, SCDP)
                        Store (Arg0, SSDP)
                        Store (Arg1, SCDP)
                        Name (NXTD, 0x06)
                        Name (CIDX, 0x06)
                        Store (SSDP, Local1)
                        And (Local1, 0x8B, Local1)
                        Store (SCDP, Local2)
                        Store (Local2, P80H)
                        Store (Zero, Local0)
                        While (LLess (Local0, SizeOf (SACT)))
                        {
                            Store (DerefOf (Index (SACT, Local0)), Local3)
                            If (LEqual (Local3, Local1))
                            {
                                Store (Local0, CIDX)
                                Store (SizeOf (SACT), Local0)
                            }
                            Else
                            {
                                Increment (Local0)
                            }
                        }

                        Store (CIDX, Local0)
                        While (LLess (Local0, SizeOf (SACT)))
                        {
                            Increment (Local0)
                            If (LEqual (Local0, SizeOf (SACT)))
                            {
                                Store (Zero, Local0)
                            }

                            Store (DerefOf (Index (SACT, Local0)), Local3)
                            If (LEqual (And (Local3, Local2), Local3))
                            {
                                Store (Local0, NXTD)
                                Store (SizeOf (SACT), Local0)
                            }
                        }

                        If (LEqual (NXTD, SizeOf (SACT)))
                        {
                            Store (Zero, SSDP)
                        }
                        Else
                        {
                            Store (NXTD, Local0)
                            Store (DerefOf (Index (SACT, Local0)), Local3)
                            And (SSDP, 0xFFFFFFF4, SSDP)
                            Or (SSDP, Local3, SSDP)
                        }

                        Store (0x04, SSZE)
                        Store (SSDP, P80H)
                        Return (ATIB)
                    }

                    Method (AFN0, 0, Serialized)
                    {
                        If (And (MSKN, One))
                        {
                            CreateBitField (PSBR, Zero, PDSW)
                            Store (One, PDSW)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AFN3, 2, Serialized)
                    {
                        If (And (MSKN, 0x08))
                        {
                            Store (Arg0, Local0)
                            Store (Local0, SFPI)
                            Store (Arg1, Local0)
                            Store (And (Local0, 0x03, Local0), SFPG)
                            CreateBitField (PSBR, 0x03, PFPS)
                            Store (One, PFPS)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AFN4, 1, Serialized)
                    {
                        If (And (MSKN, 0x10))
                        {
                            Store (Arg0, Local0)
                            Store (SSPS, Local1)
                            Store (Local0, SSPS)
                            If (LEqual (Local0, Local1)) {}
                            Else
                            {
                                CreateBitField (PSBR, 0x04, PSPS)
                                Store (One, PSPS)
                                Notify (VGA, 0x81)
                            }
                        }
                    }

                    Method (AFN5, 0, Serialized)
                    {
                        If (And (MSKN, 0x20))
                        {
                            CreateBitField (PSBR, 0x05, PDCC)
                            Store (One, PDCC)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AFN6, 0, Serialized)
                    {
                        If (And (MSKN, 0x40))
                        {
                            CreateBitField (PSBR, 0x06, PXPS)
                            Store (One, PXPS)
                            Notify (VGA, 0x81)
                        }
                    }

                    Method (AF15, 0, NotSerialized)
                    {
                        Store (0xFF, P80H)
                        CreateWordField (ATIB, Zero, DNUM)
                        CreateWordField (ATIB, 0x02, DSZE)
                        CreateDWordField (ATIB, 0x04, FLAG)
                        CreateWordField (ATIB, 0x08, BUSN)
                        CreateWordField (ATIB, 0x0A, DEVN)
                        Store (0x08, DSZE)
                        Store (One, DNUM)
                        Store (0x04, FLAG)
                        Store (Zero, BUSN)
                        Store (One, DEVN)
                        Return (ATIB)
                    }

                    Name (AT00, Buffer (0xFF) {})
                    Name (AT01, Buffer (0x03) {})
                    Method (ATCS, 2, Serialized)
                    {
                        If (LEqual (Arg0, Zero))
                        {
                            ATC0 ()
                        }

                        If (LEqual (Arg0, One))
                        {
                            ATC1 ()
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            ATC2 (Arg1)
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            ATC3 ()
                        }

                        If (LEqual (Arg0, 0x04))
                        {
                            ATC4 (Arg1)
                        }

                        Return (AT00)
                    }

                    Method (ATC0, 0, NotSerialized)
                    {
                        CreateWordField (AT00, Zero, SZZE)
                        CreateWordField (AT00, 0x02, INTF)
                        CreateDWordField (AT00, 0x04, SUPP)
                        Store (0x08, SZZE)
                        Store (One, INTF)
                        Store (0x0F, SUPP)
                    }

                    Method (ATC1, 0, Serialized)
                    {
                        CreateWordField (AT00, Zero, SZZE)
                        CreateDWordField (AT00, 0x02, VFMK)
                        CreateDWordField (AT00, 0x06, FLAG)
                        CreateField (AT00, 0x30, One, DOCK)
                        Store (0x0A, SZZE)
                        Store (One, VFMK)
                        Store (Zero, FLAG)
                        Store (One, DOCK)
                    }

                    Method (ATC2, 1, Serialized)
                    {
                        CreateField (Arg0, 0x10, 0x03, FUCC)
                        CreateField (Arg0, 0x13, 0x06, DEVV)
                        CreateByteField (Arg0, 0x03, BUSS)
                        CreateDWordField (Arg0, 0x04, VFMK)
                        CreateDWordField (Arg0, 0x06, FLAG)
                        CreateField (Arg0, 0x30, One, ADVC)
                        CreateField (Arg0, 0x31, One, WFCM)
                        CreateByteField (Arg0, 0x08, RQST)
                        CreateByteField (Arg0, 0x09, PFRQ)
                        CreateWordField (AT00, Zero, SZZE)
                        CreateByteField (AT00, 0x02, RETV)
                        Store (0x03, SZZE)
                        Store (One, RETV)
                        Store (ALIB (0x02, Arg0), AT00)
                    }

                    Method (ATC3, 0, Serialized)
                    {
                        CreateWordField (AT00, Zero, SZZE)
                        CreateByteField (AT00, 0x02, RETV)
                        CreateWordField (AT01, Zero, SZZB)
                        CreateByteField (AT01, 0x02, PSPP)
                        Store (0x03, SZZE)
                        Store (One, RETV)
                        Store (0x03, SZZB)
                        Store (One, PSPP)
                        Store (ALIB (0x03, AT01), AT00)
                    }

                    Method (ATC4, 1, Serialized)
                    {
                        CreateField (Arg0, 0x10, 0x03, FUCC)
                        CreateField (Arg0, 0x13, 0x06, DEVV)
                        CreateByteField (Arg0, 0x03, BUSS)
                        CreateByteField (Arg0, 0x04, NULN)
                        CreateWordField (AT00, Zero, SZZE)
                        CreateByteField (AT00, 0x02, NULM)
                        Store (0x03, SZZE)
                        Store (One, NULM)
                        Store (ALIB (0x04, Arg0), AT00)
                    }
                }

                Device (HDAU)
                {
                    Name (_ADR, One)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x50)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                                Offset (0x2C), 
                        SVID,   32, 
                                Offset (0x4C), 
                        SMID,   32
                    }
                }
            }

            Device (PB4)
            {
                Name (_ADR, 0x00040000)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x08, 0x04))
                }

                Name (PR04, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKD, 
                        Zero
                    }
                })
                Name (AR04, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x10
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x11
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x13
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR04)
                    }

                    Return (PR04)
                }

                OperationRegion (XPEX, SystemMemory, 0xF8020100, 0x0100)
                Field (XPEX, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x28), 
                    VC0S,   32
                }

                OperationRegion (XPCB, PCI_Config, 0x58, 0x24)
                Field (XPCB, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    LKCN,   16, 
                    LKST,   16, 
                            Offset (0x18), 
                        ,   3, 
                    PDC8,   1, 
                        ,   2, 
                    PDS8,   1, 
                            Offset (0x19), 
                    HPC8,   1, 
                            Offset (0x1A), 
                        ,   3, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x1B), 
                    HPCS,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PMES,   1
                }

                OperationRegion (XPRI, PCI_Config, 0xE0, 0x08)
                Field (XPRI, ByteAcc, NoLock, Preserve)
                {
                    XPIR,   32, 
                    XPID,   32
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Method (XPDL, 0, NotSerialized)
                {
                    If (And (VC0S, 0x00020000))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Mutex (XPPM, 0x00)
                Method (XPRD, 1, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (XPID, Local0)
                    Store (Zero, XPIR)
                    Release (XPPM)
                    Return (Local0)
                }

                Method (XPWR, 2, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (Arg1, XPID)
                    Store (Zero, XPIR)
                    Release (XPPM)
                }

                Method (XPRT, 0, NotSerialized)
                {
                    Store (XPRD (0xA2), Local0)
                    And (Local0, 0xFFFFFFF8, Local0)
                    ShiftRight (Local0, 0x04, Local1)
                    And (Local1, 0x07, Local1)
                    Or (Local0, Local1, Local0)
                    Or (Local0, 0x0100, Local0)
                    XPWR (0xA2, Local0)
                }

                Method (XPR2, 0, NotSerialized)
                {
                    Store (LKCN, Local0)
                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LKCN)
                    Store (0x64, Local1)
                    Store (One, Local2)
                    While (LAnd (Local1, Local2))
                    {
                        Sleep (One)
                        Store (LKST, Local3)
                        If (And (Local3, 0x0800))
                        {
                            Decrement (Local1)
                        }
                        Else
                        {
                            Store (Zero, Local2)
                        }
                    }

                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    If (LNot (Local2))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local1)
                    Store (And (Local0, 0x0F), Local2)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                Method (XPPR, 1, NotSerialized)
                {
                    Name (HPOK, Zero)
                    Store (Zero, HPOK)
                    Store (ShiftLeft (XPPB (), 0x03), Local0)
                    If (Arg0)
                    {
                        XPLL (Local0, One)
                        XPLP (Local0, One)
                        Sleep (0xC8)
                        XPTR (Local0, One)
                        Store (0x0F, Local5)
                        While (LAnd (LNot (HPOK), LGreater (Local5, Zero)))
                        {
                            Store (One, PDC2)
                            Store (0x28, Local1)
                            While (LAnd (LNot (HPOK), LGreater (Local1, Zero)))
                            {
                                Store (XPRD (0xA5), Local2)
                                If (LEqual (And (Local2, 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LGreaterEqual (And (Local2, 0xFF), 0x04))
                                {
                                    Store (One, HPOK)
                                }

                                Decrement (Local1)
                            }

                            If (HPOK)
                            {
                                Store (And (XPRD (0xA5), 0xFF), Local2)
                                Store (And (ShiftRight (XPRD (0xA2), 0x04), 0x07), Local3)
                                If (LAnd (LEqual (Local2, 0x06), LAnd (LGreater (Local3, One), LLess (
                                    Local3, 0x05))))
                                {
                                    Store (Zero, HPOK)
                                }
                            }

                            If (HPOK)
                            {
                                Store (0x07D0, Local1)
                                Store (Zero, HPOK)
                                While (LAnd (LNot (HPOK), Local1))
                                {
                                    Store (And (XPRD (0xA5), 0xFF), Local2)
                                    If (LEqual (Local2, 0x07))
                                    {
                                        Store (One, Local1)
                                        Store (XPDL (), Local4)
                                        If (Local4)
                                        {
                                            XPRT ()
                                            Decrement (Local5)
                                        }
                                    }

                                    If (LEqual (Local2, 0x10))
                                    {
                                        Store (One, HPOK)
                                    }

                                    Sleep (One)
                                    Decrement (Local1)
                                }
                            }
                        }
                    }

                    If (HPOK)
                    {
                        XPTR (Local0, Zero)
                        XPLP (Local0, Zero)
                        XPLL (Local0, Zero)
                    }

                    Return (Ones)
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x08)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32
                    }
                }
            }

            Device (PB5)
            {
                Name (_ADR, 0x00050000)
                Name (PR05, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKA, 
                        Zero
                    }
                })
                Name (AR05, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x11
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x12
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x10
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR05)
                    }

                    Return (PR05)
                }

                OperationRegion (XPEX, SystemMemory, 0xF8028100, 0x0100)
                Field (XPEX, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x28), 
                    VC0S,   32
                }

                OperationRegion (XPCB, PCI_Config, 0x58, 0x24)
                Field (XPCB, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    LKCN,   16, 
                    LKST,   16, 
                            Offset (0x18), 
                        ,   3, 
                    PDC8,   1, 
                        ,   2, 
                    PDS8,   1, 
                            Offset (0x19), 
                    HPC8,   1, 
                            Offset (0x1A), 
                        ,   3, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x1B), 
                    HPCS,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PMES,   1
                }

                OperationRegion (XPRI, PCI_Config, 0xE0, 0x08)
                Field (XPRI, ByteAcc, NoLock, Preserve)
                {
                    XPIR,   32, 
                    XPID,   32
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Method (XPDL, 0, NotSerialized)
                {
                    If (And (VC0S, 0x00020000))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Mutex (XPPM, 0x00)
                Method (XPRD, 1, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (XPID, Local0)
                    Store (Zero, XPIR)
                    Release (XPPM)
                    Return (Local0)
                }

                Method (XPWR, 2, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (Arg1, XPID)
                    Store (Zero, XPIR)
                    Release (XPPM)
                }

                Method (XPRT, 0, NotSerialized)
                {
                    Store (XPRD (0xA2), Local0)
                    And (Local0, 0xFFFFFFF8, Local0)
                    ShiftRight (Local0, 0x04, Local1)
                    And (Local1, 0x07, Local1)
                    Or (Local0, Local1, Local0)
                    Or (Local0, 0x0100, Local0)
                    XPWR (0xA2, Local0)
                }

                Method (XPR2, 0, NotSerialized)
                {
                    Store (LKCN, Local0)
                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LKCN)
                    Store (0x64, Local1)
                    Store (One, Local2)
                    While (LAnd (Local1, Local2))
                    {
                        Sleep (One)
                        Store (LKST, Local3)
                        If (And (Local3, 0x0800))
                        {
                            Decrement (Local1)
                        }
                        Else
                        {
                            Store (Zero, Local2)
                        }
                    }

                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    If (LNot (Local2))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local1)
                    Store (And (Local0, 0x0F), Local2)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                Method (XPPR, 1, NotSerialized)
                {
                    Name (HPOK, Zero)
                    Store (Zero, HPOK)
                    Store (ShiftLeft (XPPB (), 0x03), Local0)
                    If (Arg0)
                    {
                        XPLL (Local0, One)
                        XPLP (Local0, One)
                        Sleep (0xC8)
                        XPTR (Local0, One)
                        Store (0x0F, Local5)
                        While (LAnd (LNot (HPOK), LGreater (Local5, Zero)))
                        {
                            Store (One, PDC2)
                            Store (0x28, Local1)
                            While (LAnd (LNot (HPOK), LGreater (Local1, Zero)))
                            {
                                Store (XPRD (0xA5), Local2)
                                If (LEqual (And (Local2, 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LGreaterEqual (And (Local2, 0xFF), 0x04))
                                {
                                    Store (One, HPOK)
                                }

                                Decrement (Local1)
                            }

                            If (HPOK)
                            {
                                Store (And (XPRD (0xA5), 0xFF), Local2)
                                Store (And (ShiftRight (XPRD (0xA2), 0x04), 0x07), Local3)
                                If (LAnd (LEqual (Local2, 0x06), LAnd (LGreater (Local3, One), LLess (
                                    Local3, 0x05))))
                                {
                                    Store (Zero, HPOK)
                                }
                            }

                            If (HPOK)
                            {
                                Store (0x07D0, Local1)
                                Store (Zero, HPOK)
                                While (LAnd (LNot (HPOK), Local1))
                                {
                                    Store (And (XPRD (0xA5), 0xFF), Local2)
                                    If (LEqual (Local2, 0x07))
                                    {
                                        Store (One, Local1)
                                        Store (XPDL (), Local4)
                                        If (Local4)
                                        {
                                            XPRT ()
                                            Decrement (Local5)
                                        }
                                    }

                                    If (LEqual (Local2, 0x10))
                                    {
                                        Store (One, HPOK)
                                    }

                                    Sleep (One)
                                    Decrement (Local1)
                                }
                            }
                        }
                    }

                    If (HPOK)
                    {
                        XPTR (Local0, Zero)
                        XPLP (Local0, Zero)
                        XPLL (Local0, Zero)
                    }

                    Return (Ones)
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x08)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32
                    }
                }
            }

            Device (PB6)
            {
                Name (_ADR, 0x00060000)
                Name (PR06, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKB, 
                        Zero
                    }
                })
                Name (AR06, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x12
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x13
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x11
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR06)
                    }

                    Return (PR06)
                }

                OperationRegion (XPEX, SystemMemory, 0xF9030100, 0x0100)
                Field (XPEX, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x28), 
                    VC0S,   32
                }

                OperationRegion (XPCB, PCI_Config, 0x58, 0x24)
                Field (XPCB, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    LKCN,   16, 
                    LKST,   16, 
                            Offset (0x18), 
                        ,   3, 
                    PDC8,   1, 
                        ,   2, 
                    PDS8,   1, 
                            Offset (0x19), 
                    HPC8,   1, 
                            Offset (0x1A), 
                        ,   3, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x1B), 
                    HPCS,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PMES,   1
                }

                OperationRegion (XPRI, PCI_Config, 0xE0, 0x08)
                Field (XPRI, ByteAcc, NoLock, Preserve)
                {
                    XPIR,   32, 
                    XPID,   32
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Method (XPDL, 0, NotSerialized)
                {
                    If (And (VC0S, 0x00020000))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Mutex (XPPM, 0x00)
                Method (XPRD, 1, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (XPID, Local0)
                    Store (Zero, XPIR)
                    Release (XPPM)
                    Return (Local0)
                }

                Method (XPWR, 2, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (Arg1, XPID)
                    Store (Zero, XPIR)
                    Release (XPPM)
                }

                Method (XPRT, 0, NotSerialized)
                {
                    Store (XPRD (0xA2), Local0)
                    And (Local0, 0xFFFFFFF8, Local0)
                    ShiftRight (Local0, 0x04, Local1)
                    And (Local1, 0x07, Local1)
                    Or (Local0, Local1, Local0)
                    Or (Local0, 0x0100, Local0)
                    XPWR (0xA2, Local0)
                }

                Method (XPR2, 0, NotSerialized)
                {
                    Store (LKCN, Local0)
                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LKCN)
                    Store (0x64, Local1)
                    Store (One, Local2)
                    While (LAnd (Local1, Local2))
                    {
                        Sleep (One)
                        Store (LKST, Local3)
                        If (And (Local3, 0x0800))
                        {
                            Decrement (Local1)
                        }
                        Else
                        {
                            Store (Zero, Local2)
                        }
                    }

                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    If (LNot (Local2))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local1)
                    Store (And (Local0, 0x0F), Local2)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                Method (XPPR, 1, NotSerialized)
                {
                    Name (HPOK, Zero)
                    Store (Zero, HPOK)
                    Store (ShiftLeft (XPPB (), 0x03), Local0)
                    If (Arg0)
                    {
                        XPLL (Local0, One)
                        XPLP (Local0, One)
                        Sleep (0xC8)
                        XPTR (Local0, One)
                        Store (0x0F, Local5)
                        While (LAnd (LNot (HPOK), LGreater (Local5, Zero)))
                        {
                            Store (One, PDC2)
                            Store (0x28, Local1)
                            While (LAnd (LNot (HPOK), LGreater (Local1, Zero)))
                            {
                                Store (XPRD (0xA5), Local2)
                                If (LEqual (And (Local2, 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LGreaterEqual (And (Local2, 0xFF), 0x04))
                                {
                                    Store (One, HPOK)
                                }

                                Decrement (Local1)
                            }

                            If (HPOK)
                            {
                                Store (And (XPRD (0xA5), 0xFF), Local2)
                                Store (And (ShiftRight (XPRD (0xA2), 0x04), 0x07), Local3)
                                If (LAnd (LEqual (Local2, 0x06), LAnd (LGreater (Local3, One), LLess (
                                    Local3, 0x05))))
                                {
                                    Store (Zero, HPOK)
                                }
                            }

                            If (HPOK)
                            {
                                Store (0x07D0, Local1)
                                Store (Zero, HPOK)
                                While (LAnd (LNot (HPOK), Local1))
                                {
                                    Store (And (XPRD (0xA5), 0xFF), Local2)
                                    If (LEqual (Local2, 0x07))
                                    {
                                        Store (One, Local1)
                                        Store (XPDL (), Local4)
                                        If (Local4)
                                        {
                                            XPRT ()
                                            Decrement (Local5)
                                        }
                                    }

                                    If (LEqual (Local2, 0x10))
                                    {
                                        Store (One, HPOK)
                                    }

                                    Sleep (One)
                                    Decrement (Local1)
                                }
                            }
                        }
                    }

                    If (HPOK)
                    {
                        XPTR (Local0, Zero)
                        XPLP (Local0, Zero)
                        XPLL (Local0, Zero)
                    }

                    Return (Ones)
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0xFF)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32, 
                                Offset (0xCA), 
                        RGCA,   8, 
                        DISF,   8, 
                        FIFO,   8
                    }

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

                Device (XPD3)
                {
                    Name (_ADR, 0x03)
                    OperationRegion (PCFG, PCI_Config, Zero, 0xFF)
                    Field (PCFG, ByteAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32, 
                                Offset (0xAC), 
                        VDID,   32, 
                                Offset (0xE1), 
                        MISC,   8, 
                                Offset (0xFD), 
                        PLLM,   8
                    }
                }
            }

            Device (PB7)
            {
                Name (_ADR, 0x00070000)
                Method (_PRW, 0, NotSerialized)
                {
                    Store (^^LPC0.EC.EPWS, Local0)
                    If (LOr (LEqual (Local0, 0x03), LEqual (Local0, One)))
                    {
                        Return (GPRW (0x08, 0x04))
                    }
                    Else
                    {
                        Return (GPRW (0x08, 0x03))
                    }
                }

                Name (PR07, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKC, 
                        Zero
                    }
                })
                Name (AR07, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x13
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x10
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x12
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR07)
                    }

                    Return (PR07)
                }

                OperationRegion (XPEX, SystemMemory, 0xF8038100, 0x0100)
                Field (XPEX, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x28), 
                    VC0S,   32
                }

                OperationRegion (XPCB, PCI_Config, 0x58, 0x24)
                Field (XPCB, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    LKCN,   16, 
                    LKST,   16, 
                            Offset (0x18), 
                        ,   3, 
                    PDC8,   1, 
                        ,   2, 
                    PDS8,   1, 
                            Offset (0x19), 
                    HPC8,   1, 
                            Offset (0x1A), 
                        ,   3, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x1B), 
                    HPCS,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PMES,   1
                }

                OperationRegion (XPRI, PCI_Config, 0xE0, 0x08)
                Field (XPRI, ByteAcc, NoLock, Preserve)
                {
                    XPIR,   32, 
                    XPID,   32
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Method (XPDL, 0, NotSerialized)
                {
                    If (And (VC0S, 0x00020000))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Mutex (XPPM, 0x00)
                Method (XPRD, 1, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (XPID, Local0)
                    Store (Zero, XPIR)
                    Release (XPPM)
                    Return (Local0)
                }

                Method (XPWR, 2, NotSerialized)
                {
                    Acquire (XPPM, 0xFFFF)
                    Store (Arg0, XPIR)
                    Store (Arg1, XPID)
                    Store (Zero, XPIR)
                    Release (XPPM)
                }

                Method (XPRT, 0, NotSerialized)
                {
                    Store (XPRD (0xA2), Local0)
                    And (Local0, 0xFFFFFFF8, Local0)
                    ShiftRight (Local0, 0x04, Local1)
                    And (Local1, 0x07, Local1)
                    Or (Local0, Local1, Local0)
                    Or (Local0, 0x0100, Local0)
                    XPWR (0xA2, Local0)
                }

                Method (XPR2, 0, NotSerialized)
                {
                    Store (LKCN, Local0)
                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LKCN)
                    Store (0x64, Local1)
                    Store (One, Local2)
                    While (LAnd (Local1, Local2))
                    {
                        Sleep (One)
                        Store (LKST, Local3)
                        If (And (Local3, 0x0800))
                        {
                            Decrement (Local1)
                        }
                        Else
                        {
                            Store (Zero, Local2)
                        }
                    }

                    And (Local0, 0xFFFFFFDF, Local0)
                    Store (Local0, LKCN)
                    If (LNot (Local2))
                    {
                        Return (Ones)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local1)
                    Store (And (Local0, 0x0F), Local2)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                Method (XPPR, 1, NotSerialized)
                {
                    Name (HPOK, Zero)
                    Store (Zero, HPOK)
                    Store (ShiftLeft (XPPB (), 0x03), Local0)
                    If (Arg0)
                    {
                        XPLL (Local0, One)
                        XPLP (Local0, One)
                        Sleep (0xC8)
                        XPTR (Local0, One)
                        Store (0x0F, Local5)
                        While (LAnd (LNot (HPOK), LGreater (Local5, Zero)))
                        {
                            Store (One, PDC2)
                            Store (0x28, Local1)
                            While (LAnd (LNot (HPOK), LGreater (Local1, Zero)))
                            {
                                Store (XPRD (0xA5), Local2)
                                If (LEqual (And (Local2, 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LEqual (And (ShiftRight (Local2, 0x08), 0xFF), 0x3F))
                                {
                                    Store (One, Local1)
                                }

                                If (LGreaterEqual (And (Local2, 0xFF), 0x04))
                                {
                                    Store (One, HPOK)
                                }

                                Decrement (Local1)
                            }

                            If (HPOK)
                            {
                                Store (And (XPRD (0xA5), 0xFF), Local2)
                                Store (And (ShiftRight (XPRD (0xA2), 0x04), 0x07), Local3)
                                If (LAnd (LEqual (Local2, 0x06), LAnd (LGreater (Local3, One), LLess (
                                    Local3, 0x05))))
                                {
                                    Store (Zero, HPOK)
                                }
                            }

                            If (HPOK)
                            {
                                Store (0x07D0, Local1)
                                Store (Zero, HPOK)
                                While (LAnd (LNot (HPOK), Local1))
                                {
                                    Store (And (XPRD (0xA5), 0xFF), Local2)
                                    If (LEqual (Local2, 0x07))
                                    {
                                        Store (One, Local1)
                                        Store (XPDL (), Local4)
                                        If (Local4)
                                        {
                                            XPRT ()
                                            Decrement (Local5)
                                        }
                                    }

                                    If (LEqual (Local2, 0x10))
                                    {
                                        Store (One, HPOK)
                                    }

                                    Sleep (One)
                                    Decrement (Local1)
                                }
                            }
                        }
                    }

                    If (HPOK)
                    {
                        XPTR (Local0, Zero)
                        XPLP (Local0, Zero)
                        XPLL (Local0, Zero)
                    }

                    Return (Ones)
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x08)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32
                    }

                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (Zero)
                    }
                }
            }

            Device (SPB0)
            {
                Name (_ADR, 0x00150000)
                Name (_PRW, Package (0x02)
                {
                    0x08, 
                    0x04
                })
                Name (PR0A, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKD, 
                        Zero
                    }
                })
                Name (AR0A, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x10
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x11
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x13
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR0A)
                    }

                    Return (PR0A)
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local2)
                    Store (And (Local0, 0x0F), Local1)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                    PCMS,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x08)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32
                    }
                }
            }

            Device (SPB1)
            {
                Name (_ADR, 0x00150001)
                Name (_PRW, Package (0x02)
                {
                    0x08, 
                    0x04
                })
                Name (PR0B, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKA, 
                        Zero
                    }
                })
                Name (AR0B, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x11
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x12
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x10
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR0B)
                    }

                    Return (PR0B)
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local2)
                    Store (And (Local0, 0x0F), Local1)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                    PCMS,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x08)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32
                    }
                }
            }

            Device (SPB2)
            {
                Name (_ADR, 0x00150002)
                Name (_PRW, Package (0x02)
                {
                    0x08, 
                    0x04
                })
                Name (PR0C, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKB, 
                        Zero
                    }
                })
                Name (AR0C, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x12
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x13
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x11
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR0C)
                    }

                    Return (PR0C)
                }

                Method (XPPB, 0, NotSerialized)
                {
                    Store (_ADR, Local0)
                    Store (ShiftRight (Local0, 0x10), Local1)
                    Store (ShiftLeft (Local1, 0x03), Local2)
                    Store (And (Local0, 0x0F), Local1)
                    Store (Or (Local1, Local2), Local3)
                    Return (Local3)
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                    PCMS,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x08)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32
                    }
                }
            }

            Device (SPB3)
            {
                Name (_ADR, 0x00150003)
                Name (_PRW, Package (0x02)
                {
                    0x08, 
                    0x04
                })
                Name (PR0D, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKD, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKC, 
                        Zero
                    }
                })
                Name (AR0D, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x13
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x10
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x12
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR0D)
                    }

                    Return (PR0D)
                }

                OperationRegion (PCFG, PCI_Config, Zero, 0x20)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    DVID,   32, 
                    PCMS,   32, 
                            Offset (0x18), 
                    SBUS,   32
                }

                Device (XPDV)
                {
                    Name (_ADR, Zero)
                    OperationRegion (PCFG, PCI_Config, Zero, 0x08)
                    Field (PCFG, DWordAcc, NoLock, Preserve)
                    {
                        DVID,   32, 
                        PCMS,   32
                    }
                }
            }

            Device (HPET)
            {
                Name (_HID, EisaId ("PNP0103"))
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (And (HPAD, 0x03), 0x03))
                    {
                        If (LGreaterEqual (OSTB, 0x40))
                        {
                            Return (0x0F)
                        }

                        Store (And (HPAD, 0xFFFFFFE0), HPAD)
                        Return (One)
                    }

                    Return (One)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {0}
                        IRQNoFlags ()
                            {8}
                        Memory32Fixed (ReadOnly,
                            0xFED00000,         // Address Base
                            0x00000400,         // Address Length
                            )
                    })
                    CreateDWordField (BUF0, 0x0A, HPEB)
                    Store (HPAD, Local0)
                    And (Local0, 0xFFFFFC00, HPEB)
                    Return (BUF0)
                }
            }

            Device (AZAL)
            {
                Name (_ADR, 0x00140002)
                OperationRegion (PCI, PCI_Config, Zero, 0x0100)
                Field (PCI, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x42), 
                    DNSP,   1, 
                    DNSO,   1, 
                    ENSR,   1
                }
            }

            Device (OHC1)
            {
                Name (_ADR, 0x00120000)
                OperationRegion (O1CS, PCI_Config, 0xC4, 0x04)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x18, 0x03))
                }

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

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

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT5)
                    {
                        Name (_ADR, 0x05)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (OHC2)
            {
                Name (_ADR, 0x00130000)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x18, 0x03))
                }

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

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

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT5)
                    {
                        Name (_ADR, 0x05)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (OHC3)
            {
                Name (_ADR, 0x00160000)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x18, 0x03))
                }

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

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

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (OHC4)
            {
                Name (_ADR, 0x00140005)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x18, 0x04))
                }

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

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

            Device (EHC1)
            {
                Name (_ADR, 0x00120002)
                OperationRegion (PCFG, PCI_Config, 0xA0, 0x04)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    OSOW,   32
                }

                Method (STOS, 0, NotSerialized)
                {
                    Or (OSOW, 0x01000000, OSOW)
                }

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

                OperationRegion (U20P, PCI_Config, Zero, 0x0100)
                Field (U20P, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    MBAS,   32
                }

                Method (_PSW, 1, NotSerialized)
                {
                    Store (MBAS, Local0)
                    If (LNotEqual (Local0, Ones))
                    {
                        And (Local0, 0xFFFFFFF0, Local0)
                        OperationRegion (MMIO, SystemMemory, Local0, 0x0100)
                        Field (MMIO, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x64), 
                            RP0S,   16, 
                                    Offset (0x68), 
                            RP1S,   16, 
                                    Offset (0x6C), 
                            RP2S,   16, 
                                    Offset (0x70), 
                            RP3S,   16, 
                                    Offset (0x74), 
                            RP4S,   16
                        }

                        And (UPST, 0xFFE0, UPST)
                        If (And (RP0S, 0x2001))
                        {
                            Or (UPST, One, UPST)
                        }

                        If (And (RP1S, 0x2001))
                        {
                            Or (UPST, 0x02, UPST)
                        }

                        If (And (RP2S, 0x2001))
                        {
                            Or (UPST, 0x04, UPST)
                        }

                        If (And (RP3S, 0x2001))
                        {
                            Or (UPST, 0x08, UPST)
                        }

                        If (And (RP4S, 0x2001))
                        {
                            Or (UPST, 0x10, UPST)
                        }
                    }
                }

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT5)
                    {
                        Name (_ADR, 0x05)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (EHC2)
            {
                Name (_ADR, 0x00130002)
                OperationRegion (PCFG, PCI_Config, 0xA0, 0x04)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    OSOW,   32
                }

                Method (STOS, 0, NotSerialized)
                {
                    Or (OSOW, 0x01000000, OSOW)
                }

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

                OperationRegion (U20P, PCI_Config, Zero, 0x0100)
                Field (U20P, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    MBAS,   32
                }

                Method (_PSW, 1, NotSerialized)
                {
                    Store (MBAS, Local0)
                    If (LNotEqual (Local0, Ones))
                    {
                        And (Local0, 0xFFFFFFF0, Local0)
                        OperationRegion (MMIO, SystemMemory, Local0, 0x0100)
                        Field (MMIO, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x64), 
                            RP5S,   16, 
                                    Offset (0x68), 
                            RP6S,   16, 
                                    Offset (0x6C), 
                            RP7S,   16, 
                                    Offset (0x70), 
                            RP8S,   16, 
                                    Offset (0x74), 
                            RP9S,   16
                        }

                        And (UPST, 0x1F, UPST)
                        If (And (RP5S, 0x2001))
                        {
                            Or (UPST, 0x20, UPST)
                        }

                        If (And (RP6S, 0x2001))
                        {
                            Or (UPST, 0x40, UPST)
                        }

                        If (And (RP7S, 0x2001))
                        {
                            Or (UPST, 0x80, UPST)
                        }

                        If (And (RP8S, 0x2001))
                        {
                            Or (UPST, 0x0100, UPST)
                        }

                        If (And (RP9S, 0x2001))
                        {
                            Or (UPST, 0x0200, UPST)
                        }
                    }
                }

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT5)
                    {
                        Name (_ADR, 0x05)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (EHC3)
            {
                Name (_ADR, 0x00160002)
                OperationRegion (PCFG, PCI_Config, 0xA0, 0x04)
                Field (PCFG, DWordAcc, NoLock, Preserve)
                {
                    OSOW,   32
                }

                Method (STOS, 0, NotSerialized)
                {
                    Or (OSOW, 0x01000000, OSOW)
                }

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

                OperationRegion (U20P, PCI_Config, Zero, 0x0100)
                Field (U20P, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    MBAS,   32
                }

                Method (_PSW, 1, NotSerialized)
                {
                    Store (MBAS, Local0)
                    If (LNotEqual (Local0, Ones))
                    {
                        And (Local0, 0xFFFFFFF0, Local0)
                        OperationRegion (MMIO, SystemMemory, Local0, 0x0100)
                        Field (MMIO, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x64), 
                            RPAS,   16, 
                                    Offset (0x68), 
                            RPBS,   16, 
                                    Offset (0x6C), 
                            RPCS,   16, 
                                    Offset (0x70), 
                            RPDS,   16
                        }

                        And (UPST, 0x03FF, UPST)
                        If (And (RPAS, 0x2001))
                        {
                            Or (UPST, 0x0400, UPST)
                        }

                        If (And (RPBS, 0x2001))
                        {
                            Or (UPST, 0x0800, UPST)
                        }

                        If (And (RPCS, 0x2001))
                        {
                            Or (UPST, 0x1000, UPST)
                        }

                        If (And (RPDS, 0x2001))
                        {
                            Or (UPST, 0x2000, UPST)
                        }
                    }
                }

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT3)
                    {
                        Name (_ADR, 0x03)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (XHC0)
            {
                Name (_ADR, 0x00100000)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x18, 0x03))
                }

                OperationRegion (XPRT, PCI_Config, Zero, 0x0100)
                Field (XPRT, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    MBAS,   32
                }

                Method (_PSW, 1, NotSerialized)
                {
                    Store (MBAS, Local0)
                    If (LNotEqual (Local0, Ones))
                    {
                        And (Local0, 0xFFFFFF00, Local0)
                        Add (Local0, 0x0400, Local0)
                        OperationRegion (MMIO, SystemMemory, Local0, 0x0100)
                        Field (MMIO, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x40), 
                            RP0S,   8, 
                                    Offset (0x50), 
                            RP1S,   8
                        }

                        And (UPST, 0xF3FF, UPST)
                        If (And (RP0S, One))
                        {
                            Or (UPST, 0x0400, UPST)
                        }

                        If (And (RP1S, One))
                        {
                            Or (UPST, 0x0800, UPST)
                        }
                    }
                }

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (XHC1)
            {
                Name (_ADR, 0x00100001)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x18, 0x03))
                }

                OperationRegion (XPRT, PCI_Config, Zero, 0x0100)
                Field (XPRT, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    MBAS,   32
                }

                Method (_PSW, 1, NotSerialized)
                {
                    Store (MBAS, Local0)
                    If (LNotEqual (Local0, Ones))
                    {
                        And (Local0, 0xFFFFFF00, Local0)
                        Add (Local0, 0x0400, Local0)
                        OperationRegion (MMIO, SystemMemory, Local0, 0x0100)
                        Field (MMIO, ByteAcc, NoLock, Preserve)
                        {
                                    Offset (0x40), 
                            RP2S,   8, 
                                    Offset (0x50), 
                            RP3S,   8
                        }

                        And (UPST, 0xCFFF, UPST)
                        If (And (RP2S, One))
                        {
                            Or (UPST, 0x1000, UPST)
                        }

                        If (And (RP3S, One))
                        {
                            Or (UPST, 0x2000, UPST)
                        }
                    }
                }

                Device (XHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Name (_UPC, Package (0x04)
                        {
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA1, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Name (_UPC, Package (0x04)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero
                        })
                        Name (_PLD, Package (0x01)
                        {
                            Buffer (0x10)
                            {
                                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0xA0, 0x10, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
                            }
                        })
                    }
                }
            }

            Device (SMBS)
            {
                Name (_ADR, 0x00140000)
                OperationRegion (IRQF, PCI_Config, Zero, 0x0100)
                Field (IRQF, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x08), 
                    RVID,   8
                }

                OperationRegion (ERMM, SystemMemory, MMSO, 0x1000)
                Field (ERMM, AnyAcc, NoLock, Preserve)
                {
                            Offset (0xFF), 
                        ,   5, 
                    E000,   1, 
                    O000,   1, 
                    I000,   1, 
                        ,   5, 
                    E001,   1, 
                    O001,   1, 
                    I001,   1, 
                            Offset (0x105), 
                        ,   5, 
                    E006,   1, 
                    O006,   1, 
                    I006,   1, 
                        ,   5, 
                    E007,   1, 
                    O007,   1, 
                    I007,   1, 
                            Offset (0x10A), 
                        ,   5, 
                    E011,   1, 
                    O011,   1, 
                    I011,   1, 
                        ,   5, 
                    E012,   1, 
                    O012,   1, 
                    I012,   1, 
                        ,   5, 
                    E013,   1, 
                    O013,   1, 
                    I013,   1, 
                        ,   5, 
                    E014,   1, 
                    O014,   1, 
                    I014,   1, 
                        ,   5, 
                    E015,   1, 
                    O015,   1, 
                    I015,   1, 
                        ,   5, 
                    E016,   1, 
                    O016,   1, 
                    I016,   1, 
                            Offset (0x113), 
                        ,   5, 
                    E020,   1, 
                    O020,   1, 
                    I020,   1, 
                        ,   5, 
                    E021,   1, 
                    O021,   1, 
                    I021,   1, 
                        ,   5, 
                    E022,   1, 
                    O022,   1, 
                    I022,   1, 
                        ,   5, 
                    E023,   1, 
                    O023,   1, 
                    I023,   1, 
                        ,   5, 
                    E024,   1, 
                    O024,   1, 
                    I024,   1, 
                        ,   5, 
                    E025,   1, 
                    O025,   1, 
                    I025,   1, 
                            Offset (0x11A), 
                        ,   5, 
                    E027,   1, 
                    O027,   1, 
                    I027,   1, 
                        ,   5, 
                    E028,   1, 
                    O028,   1, 
                    I028,   1, 
                            Offset (0x11F), 
                        ,   5, 
                    E032,   1, 
                    O032,   1, 
                    I032,   1, 
                            Offset (0x122), 
                        ,   5, 
                    E035,   1, 
                    O035,   1, 
                    I035,   1, 
                            Offset (0x128), 
                        ,   1, 
                    H041,   1, 
                    S041,   1, 
                    U041,   1, 
                    D041,   1, 
                    E041,   1, 
                    O041,   1, 
                    I041,   1, 
                            Offset (0x12B), 
                        ,   5, 
                    E044,   1, 
                    O044,   1, 
                    I044,   1, 
                        ,   5, 
                    E045,   1, 
                    O045,   1, 
                    I045,   1, 
                        ,   1, 
                    H046,   1, 
                    S046,   1, 
                    U046,   1, 
                    D046,   1, 
                    E046,   1, 
                    O046,   1, 
                    I046,   1, 
                            Offset (0x132), 
                        ,   5, 
                    E051,   1, 
                    O051,   1, 
                    I051,   1, 
                            Offset (0x134), 
                        ,   5, 
                    E053,   1, 
                    O053,   1, 
                    I053,   1, 
                            Offset (0x136), 
                        ,   5, 
                    E055,   1, 
                    O055,   1, 
                    I055,   1, 
                            Offset (0x138), 
                        ,   5, 
                    E057,   1, 
                    O057,   1, 
                    I057,   1, 
                        ,   5, 
                    E058,   1, 
                    O058,   1, 
                    I058,   1, 
                        ,   5, 
                    E059,   1, 
                    O059,   1, 
                    I059,   1, 
                            Offset (0x13C), 
                        ,   1, 
                    H061,   1, 
                    S061,   1, 
                    U061,   1, 
                    D061,   1, 
                    E061,   1, 
                    O061,   1, 
                    I061,   1, 
                        ,   1, 
                    H062,   1, 
                    S062,   1, 
                    U062,   1, 
                    D062,   1, 
                    E062,   1, 
                    O062,   1, 
                    I062,   1, 
                        ,   1, 
                    H063,   1, 
                    S063,   1, 
                    U063,   1, 
                    D063,   1, 
                    E063,   1, 
                    O063,   1, 
                    I063,   1, 
                        ,   1, 
                    H064,   1, 
                    S064,   1, 
                    U064,   1, 
                    D064,   1, 
                    E064,   1, 
                    O064,   1, 
                    I064,   1, 
                            Offset (0x141), 
                        ,   5, 
                    E066,   1, 
                    O066,   1, 
                    I066,   1, 
                            Offset (0x162), 
                        ,   7, 
                    GE03,   1, 
                        ,   7, 
                    GE04,   1, 
                        ,   7, 
                    GE05,   1, 
                        ,   7, 
                    GE06,   1, 
                            Offset (0x16A), 
                        ,   7, 
                    GE09,   1, 
                        ,   7, 
                    GE12,   1, 
                        ,   7, 
                    GE13,   1, 
                        ,   7, 
                    GE14,   1, 
                        ,   7, 
                    GE15,   1, 
                        ,   7, 
                    GE16,   1, 
                            Offset (0x175), 
                        ,   7, 
                    GE22,   1, 
                            Offset (0x1A5), 
                        ,   5, 
                    E166,   1, 
                    O166,   1, 
                    I166,   1, 
                            Offset (0x1A9), 
                        ,   5, 
                    E170,   1, 
                    O170,   1, 
                    I170,   1, 
                        ,   5, 
                    E171,   1, 
                    O171,   1, 
                    I171,   1, 
                            Offset (0x1AE), 
                        ,   5, 
                    E175,   1, 
                    O175,   1, 
                    I175,   1, 
                        ,   5, 
                    E176,   1, 
                    O176,   1, 
                    I176,   1, 
                        ,   5, 
                    E177,   1, 
                    O177,   1, 
                    I177,   1, 
                        ,   5, 
                    E178,   1, 
                    O178,   1, 
                    I178,   1, 
                        ,   5, 
                    E179,   1, 
                    O179,   1, 
                    I179,   1, 
                        ,   5, 
                    E180,   1, 
                    O180,   1, 
                    I180,   1, 
                        ,   5, 
                    E181,   1, 
                    O181,   1, 
                    I181,   1, 
                        ,   5, 
                    E182,   1, 
                    O182,   1, 
                    I182,   1, 
                            Offset (0x1B7), 
                        ,   3, 
                    U184,   1, 
                    D184,   1, 
                    E184,   1, 
                    O184,   1, 
                    I184,   1, 
                            Offset (0x1BE), 
                        ,   5, 
                    E191,   1, 
                    O191,   1, 
                    I191,   1, 
                        ,   5, 
                    E192,   1, 
                    O192,   1, 
                    I192,   1, 
                            Offset (0x1C4), 
                        ,   5, 
                    E197,   1, 
                    O197,   1, 
                    I197,   1, 
                            Offset (0x1C6), 
                        ,   5, 
                    E199,   1, 
                    O199,   1, 
                    I199,   1, 
                        ,   5, 
                    E200,   1, 
                    O200,   1, 
                    I200,   1, 
                            Offset (0x1FF), 
                        ,   1, 
                    G01S,   1, 
                        ,   3, 
                    G05S,   1, 
                        ,   8, 
                    G14S,   1, 
                    G15S,   1, 
                    G16S,   1, 
                        ,   5, 
                    G22S,   1, 
                    G23S,   1, 
                            Offset (0x203), 
                        ,   1, 
                    G01E,   1, 
                        ,   3, 
                    G05E,   1, 
                        ,   8, 
                    G14E,   1, 
                    G15E,   1, 
                    G16E,   1, 
                        ,   5, 
                    G22E,   1, 
                    G23E,   1, 
                            Offset (0x207), 
                        ,   1, 
                    G01T,   1, 
                        ,   3, 
                    G05T,   1, 
                    G06T,   1, 
                        ,   6, 
                    G13T,   1, 
                    G14T,   1, 
                    G15T,   1, 
                    G16T,   1, 
                        ,   5, 
                    G22T,   1, 
                    G23T,   1, 
                            Offset (0x20B), 
                        ,   1, 
                    G01L,   1, 
                        ,   3, 
                    G05L,   1, 
                        ,   9, 
                    G15L,   1, 
                    G16L,   1, 
                        ,   5, 
                    G22L,   1, 
                    G23L,   1, 
                            Offset (0x287), 
                        ,   1, 
                    CLPS,   1, 
                            Offset (0x298), 
                        ,   7, 
                    G15A,   1, 
                            Offset (0x2AF), 
                        ,   2, 
                    SLPS,   2, 
                            Offset (0x32B), 
                    SM0E,   1, 
                            Offset (0x32D), 
                        ,   1, 
                    SM0S,   2, 
                            Offset (0x361), 
                        ,   6, 
                    MT3A,   1, 
                            Offset (0x376), 
                    EPNM,   1, 
                    DPPF,   1, 
                            Offset (0x3BA), 
                        ,   6, 
                    PWDE,   1, 
                            Offset (0x3BD), 
                        ,   5, 
                    ALLS,   1, 
                            Offset (0x3C7), 
                        ,   2, 
                    TFTE,   1, 
                            Offset (0x3DE), 
                    BLNK,   2, 
                            Offset (0x3EF), 
                    PHYD,   1, 
                            Offset (0x3FF), 
                    F0CT,   8, 
                    F0MS,   8, 
                    F0FQ,   8, 
                    F0LD,   8, 
                    F0MD,   8, 
                    F0MP,   8, 
                    LT0L,   8, 
                    LT0H,   8, 
                    MT0L,   8, 
                    MT0H,   8, 
                    HT0L,   8, 
                    HT0H,   8, 
                    LRG0,   8, 
                    LHC0,   8, 
                            Offset (0x40F), 
                    F1CT,   8, 
                    F1MS,   8, 
                    F1FQ,   8, 
                    F1LD,   8, 
                    F1MD,   8, 
                    F1MP,   8, 
                    LT1L,   8, 
                    LT1H,   8, 
                    MT1L,   8, 
                    MT1H,   8, 
                    HT1L,   8, 
                    HT1H,   8, 
                    LRG1,   8, 
                    LHC1,   8, 
                            Offset (0x41F), 
                    F2CT,   8, 
                    F2MS,   8, 
                    F2FQ,   8, 
                    F2LD,   8, 
                    F2MD,   8, 
                    F2MP,   8, 
                    LT2L,   8, 
                    LT2H,   8, 
                    MT2L,   8, 
                    MT2H,   8, 
                    HT2L,   8, 
                    HT2H,   8, 
                    LRG2,   8, 
                    LHC2,   8, 
                            Offset (0x42F), 
                    F3CT,   8, 
                    F3MS,   8, 
                    F3FQ,   8, 
                    F3LD,   8, 
                    F3MD,   8, 
                    F3MP,   8, 
                    LT3L,   8, 
                    LT3H,   8, 
                    MT3L,   8, 
                    MT3H,   8, 
                    HT3L,   8, 
                    HT3H,   8, 
                    LRG3,   8, 
                    LHC3,   8, 
                            Offset (0x6FF), 
                    SEC,    8, 
                            Offset (0x701), 
                    MIN,    8, 
                            Offset (0xD06), 
                    MX07,   8, 
                            Offset (0xD0E), 
                    MX15,   8, 
                    MX16,   8, 
                            Offset (0xD14), 
                    MX21,   8, 
                    MX22,   8, 
                    MX23,   8, 
                            Offset (0xD1A), 
                    MX27,   8, 
                    MX28,   8, 
                            Offset (0xD1F), 
                    MX32,   8, 
                            Offset (0xD2B), 
                    MX44,   8, 
                            Offset (0xD32), 
                    MX51,   8, 
                            Offset (0xD34), 
                    MX53,   8, 
                            Offset (0xD38), 
                    MX57,   8, 
                    MX58,   8, 
                    MX59,   8, 
                            Offset (0xD41), 
                    MX66,   8, 
                            Offset (0xD65), 
                    M102,   8, 
                            Offset (0xD6D), 
                    M110,   8, 
                            Offset (0xDA9), 
                    M170,   8, 
                            Offset (0xDAE), 
                    M175,   8, 
                    M176,   8, 
                    M177,   8, 
                            Offset (0xDB3), 
                    M180,   8, 
                            Offset (0xDB5), 
                    M182,   8, 
                            Offset (0xDC4), 
                    M197,   8, 
                            Offset (0xDC7), 
                    M200,   8, 
                            Offset (0xDFF), 
                    MS00,   8, 
                    MS01,   8, 
                    MS02,   8, 
                    MS03,   8, 
                    MS04,   8, 
                            Offset (0xE3F), 
                    MS40,   8, 
                            Offset (0xE80), 
                        ,   2, 
                    ECES,   1
                }

                OperationRegion (ERM1, SystemMemory, MMSO, 0x1000)
                Field (ERM1, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x100), 
                        ,   5, 
                    P01E,   1, 
                    P01O,   1, 
                    P01I,   1, 
                            Offset (0x105), 
                        ,   5, 
                    P06E,   1, 
                    P06O,   1, 
                    P06I,   1, 
                        ,   5, 
                    P07E,   1, 
                    P07O,   1, 
                    P07I,   1, 
                            Offset (0x10A), 
                        ,   5, 
                    P0BE,   1, 
                    P0BO,   1, 
                    P0BI,   1, 
                        ,   5, 
                    P0CE,   1, 
                    P0CO,   1, 
                    P0CI,   1, 
                        ,   5, 
                    P0DE,   1, 
                    P0DO,   1, 
                    P0DI,   1, 
                        ,   5, 
                    P0EE,   1, 
                    P0EO,   1, 
                    P0EI,   1, 
                        ,   5, 
                    P0FE,   1, 
                    P0FO,   1, 
                    P0FI,   1, 
                        ,   5, 
                    P10E,   1, 
                    P10O,   1, 
                    P10I,   1, 
                            Offset (0x113), 
                        ,   5, 
                    P14E,   1, 
                    P14O,   1, 
                    P14I,   1, 
                        ,   5, 
                    P15E,   1, 
                    P15O,   1, 
                    P15I,   1, 
                            Offset (0x11A), 
                        ,   5, 
                    P1BE,   1, 
                    P1BO,   1, 
                    P1BI,   1, 
                            Offset (0x11F), 
                        ,   5, 
                    P20E,   1, 
                    P20O,   1, 
                    P20I,   1, 
                        ,   5, 
                    P21E,   1, 
                    P21O,   1, 
                    P21I,   1, 
                        ,   5, 
                    P22E,   1, 
                    P22O,   1, 
                    P22I,   1, 
                        ,   5, 
                    P23E,   1, 
                    P23O,   1, 
                    P23I,   1, 
                            Offset (0x128), 
                        ,   5, 
                    P29E,   1, 
                    P29O,   1, 
                    P29I,   1, 
                            Offset (0x12B), 
                        ,   5, 
                    P2CE,   1, 
                    P2CO,   1, 
                    P2CI,   1, 
                        ,   5, 
                    P2DE,   1, 
                    P2DO,   1, 
                    P2DI,   1, 
                    PO2E,   8, 
                            Offset (0x132), 
                        ,   5, 
                    P33E,   1, 
                    P33O,   1, 
                    P33I,   1, 
                            Offset (0x134), 
                        ,   5, 
                    P35E,   1, 
                    P35O,   1, 
                    P35I,   1, 
                            Offset (0x136), 
                        ,   5, 
                    P37E,   1, 
                    P37O,   1, 
                    P37I,   1, 
                            Offset (0x138), 
                        ,   5, 
                    P39E,   1, 
                    P39O,   1, 
                    P39I,   1, 
                            Offset (0x13A), 
                        ,   5, 
                    P3BE,   1, 
                    P3BO,   1, 
                    P3BI,   1, 
                            Offset (0x13C), 
                    PO3D,   8, 
                    PO3E,   8, 
                    PO3F,   8, 
                    PO40,   8, 
                            Offset (0x164), 
                        ,   7, 
                            Offset (0x165), 
                        ,   5, 
                    P66E,   1, 
                    P66O,   1, 
                    P66I,   1, 
                            Offset (0x16A), 
                            Offset (0x16B), 
                        ,   5, 
                    P6CE,   1, 
                    P6CO,   1, 
                    P6CI,   1, 
                            Offset (0x16E), 
                        ,   7, 
                            Offset (0x16F), 
                        ,   7, 
                            Offset (0x170), 
                            Offset (0x174), 
                            Offset (0x175), 
                        ,   7, 
                            Offset (0x176), 
                            Offset (0x1A5), 
                    POA6,   8, 
                            Offset (0x1A9), 
                        ,   5, 
                    PAAE,   1, 
                    PAAO,   1, 
                    PAAI,   1, 
                            Offset (0x1AE), 
                        ,   5, 
                    PAFE,   1, 
                    PAFO,   1, 
                    PAFI,   1, 
                        ,   5, 
                    PB0E,   1, 
                    PB0O,   1, 
                    PB0I,   1, 
                        ,   5, 
                    PB1E,   1, 
                    PB1O,   1, 
                    PB1I,   1, 
                        ,   5, 
                    PB2E,   1, 
                    PB2O,   1, 
                    PB2I,   1, 
                        ,   5, 
                    PB3E,   1, 
                    PB3O,   1, 
                    PB3I,   1, 
                        ,   5, 
                    PB4E,   1, 
                    PB4O,   1, 
                    PB4I,   1, 
                        ,   5, 
                    PB5E,   1, 
                    PB5O,   1, 
                    PB5I,   1, 
                        ,   5, 
                    PB6E,   1, 
                    PB6O,   1, 
                    PB6I,   1, 
                            Offset (0x1C6), 
                        ,   5, 
                    PC7E,   1, 
                    PC7O,   1, 
                    PC7I,   1, 
                        ,   5, 
                    PC8E,   1, 
                    PC8O,   1, 
                    PC8I,   1, 
                            Offset (0x207), 
                        ,   1, 
                        ,   1, 
                        ,   3, 
                        ,   1, 
                        ,   9, 
                            Offset (0x209), 
                        ,   1, 
                        ,   5, 
                        ,   1, 
                        ,   3, 
                    E26C,   1, 
                            Offset (0xD00), 
                    MX01,   8, 
                            Offset (0xD1F), 
                            Offset (0xD20), 
                    MX33,   8, 
                    MX34,   8, 
                            Offset (0xD28), 
                    MX41,   8, 
                            Offset (0xDA9), 
                            Offset (0xDB3), 
                            Offset (0xDB4), 
                    M181,   8, 
                            Offset (0xDB6), 
                            Offset (0xDC6), 
                    M199,   8, 
                            Offset (0xDFF)
                }

                Mutex (SBX0, 0x00)
                OperationRegion (SMB0, SystemIO, 0x0B00, 0x10)
                Field (SMB0, ByteAcc, NoLock, Preserve)
                {
                    HST0,   8, 
                    SLV0,   8, 
                    CNT0,   8, 
                    CMD0,   8, 
                    ADD0,   8, 
                    DT00,   8, 
                    DT10,   8, 
                    BLK0,   8
                }

                Method (WBD0, 1, NotSerialized)
                {
                    Store (Arg0, Local0)
                    Store (Zero, Local2)
                    Store (HST0, Local3)
                    Store (And (Local3, 0x80), Local1)
                    While (LNotEqual (Local1, 0x80))
                    {
                        If (LLess (Local0, 0x0A))
                        {
                            Store (0x18, Local2)
                            Store (Zero, Local1)
                        }
                        Else
                        {
                            Sleep (0x0A)
                            Subtract (Local0, 0x0A, Local0)
                            Store (HST0, Local3)
                            Store (And (Local3, 0x80), Local1)
                        }
                    }

                    If (LNotEqual (Local2, 0x18))
                    {
                        Store (And (HST0, 0x1C), Local1)
                        If (Local1)
                        {
                            Store (0x07, Local2)
                        }
                    }

                    Return (Local2)
                }

                Method (WTC0, 1, NotSerialized)
                {
                    Store (Arg0, Local0)
                    Store (0x07, Local2)
                    Store (One, Local1)
                    While (LEqual (Local1, One))
                    {
                        Store (And (HST0, 0x1D), Local3)
                        If (LNotEqual (Local3, Zero))
                        {
                            If (LEqual (Local3, One))
                            {
                                If (LLess (Local0, 0x0A))
                                {
                                    Store (0x18, Local2)
                                    Store (Zero, Local1)
                                }
                                Else
                                {
                                    Sleep (0x0A)
                                    Subtract (Local0, 0x0A, Local0)
                                }
                            }
                            Else
                            {
                                Store (0x07, Local2)
                                Store (Zero, Local1)
                            }
                        }
                        Else
                        {
                            Store (Zero, Local2)
                            Store (Zero, Local1)
                        }
                    }

                    Store (Or (HST0, 0x1F), HST0)
                    Return (Local2)
                }

                Method (SBR0, 3, NotSerialized)
                {
                    Store (Package (0x03)
                        {
                            0x07, 
                            Zero, 
                            Zero
                        }, Local0)
                    Store (And (Arg0, 0x5F), Local4)
                    If (LNotEqual (Local4, 0x03))
                    {
                        If (LNotEqual (Local4, 0x05))
                        {
                            If (LNotEqual (Local4, 0x07))
                            {
                                If (LNotEqual (Local4, 0x09))
                                {
                                    If (LNotEqual (Local4, 0x0B))
                                    {
                                        Store (0x19, Index (Local0, Zero))
                                        Return (Local0)
                                    }
                                }
                            }
                        }
                    }

                    If (LEqual (Acquire (SBX0, 0xFFFF), Zero))
                    {
                        Store (Or (ShiftLeft (Arg1, One), One), ADD0)
                        Store (Arg2, CMD0)
                        Store (Or (HST0, 0x1F), HST0)
                        Store (And (Arg0, 0xA0), Local1)
                        Store (Or (And (CNT0, 0x5F), Local1), CNT0)
                        If (LEqual (Local4, 0x03))
                        {
                            Store (Or (And (CNT0, 0xA0), 0x40), CNT0)
                        }

                        If (LEqual (Local4, 0x05))
                        {
                            Store (Or (And (CNT0, 0xA0), 0x44), CNT0)
                        }

                        If (LEqual (Local4, 0x07))
                        {
                            Store (Or (And (CNT0, 0xA0), 0x48), CNT0)
                        }

                        If (LEqual (Local4, 0x09))
                        {
                            Store (Or (And (CNT0, 0xA0), 0x4C), CNT0)
                        }

                        If (LEqual (Local4, 0x0B))
                        {
                            Store (Or (HST0, 0x80), HST0)
                            Store (Zero, DT00)
                            Store (Or (And (CNT0, 0xA0), 0x54), CNT0)
                        }

                        Store (WTC0 (0x03E8), Local1)
                        Store (Local1, Index (Local0, Zero))
                        If (LEqual (Local1, Zero))
                        {
                            If (LEqual (Local4, 0x05))
                            {
                                Store (One, Index (Local0, One))
                                Store (DT00, Index (Local0, 0x02))
                            }

                            If (LEqual (Local4, 0x07))
                            {
                                Store (One, Index (Local0, One))
                                Store (DT00, Index (Local0, 0x02))
                            }

                            If (LEqual (Local4, 0x09))
                            {
                                Store (0x02, Index (Local0, One))
                                Store (DT10, Local2)
                                ShiftLeft (Local2, 0x08, Local2)
                                Add (Local2, DT00, Local2)
                                Store (Local2, Index (Local0, 0x02))
                            }

                            If (LEqual (Local4, 0x0B))
                            {
                                Store (WBD0 (0x01F4), Local1)
                                If (LNotEqual (Local1, Zero))
                                {
                                    Store (Local1, Index (Local0, Zero))
                                }
                                Else
                                {
                                    Store (DT00, Index (Local0, One))
                                    Store (DT00, Local1)
                                    Store (CNT0, Local2)
                                    Store (Zero, Local2)
                                    While (LLess (Local2, Local1))
                                    {
                                        Add (0x02, Local2, Local3)
                                        Store (BLK0, Index (Local0, Local3))
                                        Add (One, Local2, Local2)
                                    }

                                    Store (Or (HST0, 0x80), HST0)
                                }
                            }
                        }

                        Store (And (CNT0, 0x5F), CNT0)
                        Release (SBX0)
                    }

                    Return (Local0)
                }

                Method (SBW0, 5, NotSerialized)
                {
                    Store (Package (0x01)
                        {
                            0x07
                        }, Local0)
                    Store (And (Arg0, 0x5F), Local4)
                    If (LNotEqual (Local4, 0x02))
                    {
                        If (LNotEqual (Local4, 0x04))
                        {
                            If (LNotEqual (Local4, 0x06))
                            {
                                If (LNotEqual (Local4, 0x08))
                                {
                                    If (LNotEqual (Local4, 0x0A))
                                    {
                                        Store (0x19, Index (Local0, Zero))
                                        Return (Local0)
                                    }
                                }
                            }
                        }
                    }

                    If (LEqual (Acquire (SBX0, 0xFFFF), Zero))
                    {
                        Store (ShiftLeft (Arg1, One), ADD0)
                        Store (Arg2, CMD0)
                        Store (Or (HST0, 0x1F), HST0)
                        Store (And (Arg0, 0xA0), Local1)
                        Store (Or (And (CNT0, 0x5F), Local1), CNT0)
                        If (LEqual (Local4, 0x02))
                        {
                            Store (Or (And (CNT0, 0xA0), 0x40), CNT0)
                        }

                        If (LEqual (Local4, 0x04))
                        {
                            Store (Or (And (CNT0, 0xA0), 0x44), CNT0)
                        }

                        If (LEqual (Local4, 0x06))
                        {
                            Store (Arg4, DT00)
                            Store (Or (And (CNT0, 0xA0), 0x48), CNT0)
                        }

                        If (LEqual (Local4, 0x08))
                        {
                            And (Arg4, 0xFF, DT00)
                            ShiftRight (Arg4, 0x08, DT10)
                            Store (Or (And (CNT0, 0xA0), 0x4C), CNT0)
                        }

                        If (LEqual (Local4, 0x0A))
                        {
                            Store (Or (HST0, 0x80), HST0)
                            Store (CNT0, Local1)
                            Store (Arg3, DT00)
                            Store (Zero, Local2)
                            While (LLess (Local2, Arg3))
                            {
                                Store (Index (Arg4, Local2), BLK0)
                                Add (One, Local2, Local2)
                            }

                            Store (Or (And (CNT0, 0xA0), 0x54), CNT0)
                        }

                        Store (WTC0 (0x03E8), Index (Local0, Zero))
                        Store (And (CNT0, 0x5F), CNT0)
                        Release (SBX0)
                    }

                    Return (Local0)
                }
            }

            Device (LPC0)
            {
                Name (_ADR, 0x00140003)
                Mutex (PSMX, 0x00)
                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0081,             // Range Minimum
                            0x0081,             // Range Maximum
                            0x01,               // Alignment
                            0x0F,               // Length
                            )
                        IO (Decode16,
                            0x00C0,             // Range Minimum
                            0x00C0,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        DMA (Compatibility, NotBusMaster, Transfer8_16, )
                            {4}
                    })
                }

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

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

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0070,             // Range Minimum
                            0x0070,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                    })
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0070,             // Range Minimum
                            0x0070,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {8}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        If (LEqual (And (HPAD, 0x03), 0x03))
                        {
                            Return (BUF0)
                        }

                        Return (BUF1)
                    }
                }

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

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0040,             // Range Minimum
                            0x0040,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                    })
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0040,             // Range Minimum
                            0x0040,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {0}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        If (LEqual (And (HPAD, 0x03), 0x03))
                        {
                            Return (BUF0)
                        }

                        Return (BUF1)
                    }
                }

                Device (KBC0)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Range Minimum
                            0x0060,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0064,             // Range Minimum
                            0x0064,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {1}
                    })
                }

                Device (PS2M)
                {
                    Method (_HID, 0, NotSerialized)
                    {
                        If (LEqual (OG10, 0xAA))
                        {
                            Return (0x1003F351)
                        }
                        Else
                        {
                            If (LEqual (OG10, 0xBB))
                            {
                                Return (0x00029052)
                            }
                            Else
                            {
                                Return (0x130FD041)
                            }
                        }
                    }

                    Name (_CID, Package (0x03)
                    {
                        EisaId ("SYN1D00"), 
                        EisaId ("SYN0002"), 
                        EisaId ("PNP0F13")
                    })
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {12}
                    })
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0010,             // Range Minimum
                            0x0010,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x002E,             // Range Minimum
                            0x002E,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0072,             // Range Minimum
                            0x0072,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0080,             // Range Minimum
                            0x0080,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x00B0,             // Range Minimum
                            0x00B0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0092,             // Range Minimum
                            0x0092,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x025C,             // Range Minimum
                            0x025C,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0400,             // Range Minimum
                            0x0400,             // Range Maximum
                            0x01,               // Alignment
                            0xD0,               // Length
                            )
                        IO (Decode16,
                            0x04D0,             // Range Minimum
                            0x04D0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x04D6,             // Range Minimum
                            0x04D6,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0550,             // Range Minimum
                            0x0550,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0680,             // Range Minimum
                            0x0680,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x077A,             // Range Minimum
                            0x077A,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0C00,             // Range Minimum
                            0x0C00,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0C14,             // Range Minimum
                            0x0C14,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0C50,             // Range Minimum
                            0x0C50,             // Range Maximum
                            0x01,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0C6C,             // Range Minimum
                            0x0C6C,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0C6F,             // Range Minimum
                            0x0C6F,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0CD0,             // Range Minimum
                            0x0CD0,             // Range Maximum
                            0x01,               // Alignment
                            0x0C,               // Length
                            )
                        IO (Decode16,
                            0x0840,             // Range Minimum
                            0x0840,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                    })
                }

                Device (MEM)
                {
                    Name (_HID, EisaId ("PNP0C01"))
                    Name (MSRC, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0x000E0000,         // Address Base
                            0x00020000,         // Address Length
                            )
                        Memory32Fixed (ReadWrite,
                            0xFFF00000,         // Address Base
                            0x00100000,         // Address Length
                            )
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateDWordField (MSRC, 0x14, PSIZ)
                        CreateDWordField (MSRC, 0x10, PBAS)
                        Store (ROMS, PSIZ)
                        Subtract (ROMS, One, Local0)
                        Subtract (Ones, Local0, PBAS)
                        Return (MSRC)
                    }
                }

                Device (EC)
                {
                    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
                            )
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        Return (CRS)
                    }

                    Name (_GPE, 0x15)
                    Mutex (MUEC, 0x00)
                    Mutex (ASIO, 0x00)
                    Name (ECFL, Ones)
                    Method (ECAV, 0, NotSerialized)
                    {
                        If (LGreaterEqual (SLPT, 0x04))
                        {
                            Return (Zero)
                        }

                        If (LEqual (ECFL, Ones))
                        {
                            Return (Zero)
                        }

                        Return (ECFL)
                    }

                    OperationRegion (ECW1, SystemMemory, 0xFEFF0000, 0x80)
                    Field (ECW1, ByteAcc, Lock, Preserve)
                    {
                                Offset (0x01), 
                        EPWS,   8, 
                        EB0S,   8, 
                        EB1S,   8, 
                        EB0R,   8, 
                        EB1R,   8, 
                        EB0T,   8, 
                        EB1T,   8, 
                                Offset (0x10), 
                        B0PN,   16, 
                        B0VL,   16, 
                        B0RC,   16, 
                        B0FC,   16, 
                        B0ST,   16, 
                        B0CC,   16, 
                        B0TM,   16, 
                        B0C1,   16, 
                        B0CV,   16, 
                                Offset (0x30), 
                        B1PN,   16, 
                        B1VL,   16, 
                        B1RC,   16, 
                        B1FC,   16, 
                        B1ST,   16, 
                        B1CC,   16, 
                        B1TM,   16, 
                        B1C1,   16, 
                        B1CV,   16, 
                                Offset (0x50), 
                        B0DC,   16, 
                        B0DV,   16, 
                        B0SN,   16, 
                        B0MD,   16, 
                        B1DC,   16, 
                        B1DV,   8, 
                        B1SN,   8, 
                        B1MD,   8, 
                                Offset (0x60), 
                        TH1R,   8, 
                        TH1L,   8, 
                        TH0R,   8, 
                        TH0L,   8, 
                        ECRT,   8, 
                        EPSV,   8, 
                        EACT,   8, 
                        TERR,   8, 
                        F0TS,   16, 
                        F1TS,   16, 
                        F0CS,   8, 
                        F1CS,   8, 
                        PCPT,   16
                    }

                    OperationRegion (ECW2, SystemMemory, 0xFEFF0200, 0x80)
                    Field (ECW2, ByteAcc, Lock, Preserve)
                    {
                        ESEM,   8, 
                        CMD1,   8, 
                        CDT1,   8, 
                        CDT2,   8, 
                        CDT3,   8, 
                        CDT4,   8, 
                        CDT5,   8, 
                        CDT6,   8, 
                        CDT7,   8, 
                        CDT8,   8, 
                        CDT9,   8, 
                        CD10,   8, 
                        CD11,   8, 
                        CD12,   8, 
                                Offset (0x40), 
                        EDA1,   8, 
                        EDA2,   8, 
                        EDA3,   8, 
                        EDA4,   8, 
                        EDA5,   8, 
                        EDA6,   8, 
                        EDA7,   8, 
                        EDA8,   8, 
                        EDA9,   8, 
                        ED10,   8, 
                        ED11,   8, 
                        ED12,   8
                    }

                    OperationRegion (PHM0, SystemMemory, 0xFEFF0000, 0x80)
                    Field (PHM0, ByteAcc, Lock, Preserve)
                    {
                                Offset (0x12), 
                        BD25,   8, 
                        BD26,   8, 
                        BD27,   8, 
                        BD28,   8, 
                        BD29,   8, 
                        BD2A,   8, 
                        BD2D,   8, 
                        BD2E,   8, 
                        BD2F,   8, 
                        BD30,   8, 
                        BD31,   8, 
                        BD32,   8, 
                                Offset (0x22), 
                        BD33,   8, 
                        BD34,   8, 
                        BD35,   8, 
                        BD36,   8, 
                        BD37,   8, 
                        BD38,   8, 
                        BD39,   8, 
                        BD3A,   8, 
                                Offset (0x50), 
                        BD3B,   8, 
                        BD3C,   8, 
                        BD3D,   8, 
                        BD3E,   8, 
                                Offset (0x60), 
                        BD22,   8, 
                                Offset (0x62), 
                        BD21,   8, 
                                Offset (0x68), 
                        BD23,   8, 
                        BD24,   8
                    }

                    OperationRegion (PHM1, SystemMemory, 0xFEFF0200, 0xFF)
                    Field (PHM1, ByteAcc, Lock, Preserve)
                    {
                                Offset (0xB7), 
                        BD1E,   8, 
                        BD1F,   8, 
                                Offset (0xBA), 
                        BD1C,   8, 
                        BD1D,   8, 
                                Offset (0xBE), 
                        BD1A,   8, 
                        BD1B,   8, 
                                Offset (0xC5), 
                        PECR,   8, 
                                Offset (0xC8), 
                        CR01,   8, 
                        CR02,   8, 
                        CR03,   8, 
                        CR04,   8, 
                        CR05,   8
                    }

                    OperationRegion (ECWB, SystemMemory, 0xFEFF0200, 0x80)
                    Field (ECWB, ByteAcc, Lock, Preserve)
                    {
                        ESEB,   8, 
                        CMDB,   8, 
                        CDTB,   496, 
                        EDAB,   512
                    }

                    Method (_REG, 2, NotSerialized)
                    {
                        Store (Arg1, ECFL)
                        Store (RRAM (0x04A0), Local1)
                        Or (Local1, 0x88, Local1)
                        And (Local1, 0xFE, Local1)
                        WRAM (0x04A0, Local1)
                        Store (EPWS, Local2)
                        And (Local2, 0x03, Local2)
                        If (LEqual (Local2, 0x03))
                        {
                            Store (One, ACPF)
                            Store (One, DCPF)
                        }
                        Else
                        {
                            If (LEqual (Local2, 0x02))
                            {
                                Store (One, DCPF)
                            }
                            Else
                            {
                                If (LEqual (Local2, One))
                                {
                                    Store (One, ACPF)
                                }
                            }
                        }

                        TTPH ()
                        ECPH ()
                        If (LEqual (CPUD, Zero))
                        {
                            Store (Zero, \_PR.C000.PPCV)
                            Notify (\_PR.C000, 0x80)
                            Sleep (0x0A)
                            Store (Zero, \_PR.C001.PPCV)
                            Notify (\_PR.C001, 0x80)
                            Sleep (0x0A)
                            Store (Zero, \_PR.C002.PPCV)
                            Notify (\_PR.C002, 0x80)
                            Sleep (0x0A)
                            Store (Zero, \_PR.C003.PPCV)
                            Notify (\_PR.C003, 0x80)
                            Sleep (0x0A)
                        }
                        Else
                        {
                            Store (0x04, \_PR.C000.PPCV)
                            Notify (\_PR.C000, 0x80)
                            Sleep (0x0A)
                            Store (0x04, \_PR.C001.PPCV)
                            Notify (\_PR.C001, 0x80)
                            Sleep (0x0A)
                            Store (0x04, \_PR.C002.PPCV)
                            Notify (\_PR.C002, 0x80)
                            Sleep (0x0A)
                            Store (0x04, \_PR.C003.PPCV)
                            Notify (\_PR.C003, 0x80)
                            Sleep (0x0A)
                        }
                    }

                    Name (BADR, 0x0B)
                    Name (CADR, 0x09)
                    Name (SADR, 0x0A)
                    Name (ISHE, Zero)
                    Method (ALMH, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, BADR))
                        {
                            NBAT (0x80)
                        }
                    }

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

                    Name (BSLF, Zero)
                    Method (BIF0, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1MD, Local0)
                            }
                            Else
                            {
                                Store (B0MD, Local0)
                            }

                            If (LNotEqual (Local0, 0xFFFF))
                            {
                                ShiftRight (Local0, 0x0F, Local1)
                                And (Local1, One, Local1)
                                XOr (Local1, One, Local0)
                                Release (MUEC)
                            }
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BIF1, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Store (Ones, Local0)
                                Return (Local0)
                            }

                            If (BSLF)
                            {
                                Store (B1DC, Local0)
                            }
                            Else
                            {
                                Store (B0DC, Local0)
                            }

                            And (Local0, 0xFFFF, Local0)
                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BIF2, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1FC, Local0)
                            }
                            Else
                            {
                                Store (B0FC, Local0)
                            }

                            And (Local0, 0xFFFF, Local0)
                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BIF3, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1MD, Local0)
                            }
                            Else
                            {
                                Store (B0MD, Local0)
                            }

                            If (LNotEqual (Local0, 0xFFFF))
                            {
                                ShiftRight (Local0, 0x09, Local0)
                                And (Local0, One, Local0)
                                XOr (Local0, One, Local0)
                                Release (MUEC)
                            }
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BIF4, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1DV, Local0)
                            }
                            Else
                            {
                                Store (B0DV, Local0)
                            }

                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

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

                        Return (BSTR)
                    }

                    Method (BIFA, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1SN, Local0)
                            }
                            Else
                            {
                                Store (B0SN, Local0)
                            }

                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BSTS, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1ST, Local0)
                            }
                            Else
                            {
                                Store (B0ST, Local0)
                            }

                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BCRT, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1CC, Local0)
                            }
                            Else
                            {
                                Store (B0CC, Local0)
                            }

                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BRCP, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1RC, Local0)
                            }
                            Else
                            {
                                Store (B0RC, Local0)
                            }

                            If (LEqual (Local0, 0xFFFF))
                            {
                                Store (Ones, Local0)
                            }

                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BVOT, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (LNotEqual (Acquire (MUEC, 0xFFFF), Zero))
                            {
                                Return (Ones)
                            }

                            If (BSLF)
                            {
                                Store (B1VL, Local0)
                            }
                            Else
                            {
                                Store (B0VL, Local0)
                            }

                            Release (MUEC)
                        }
                        Else
                        {
                            Store (Ones, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BATP, 1, Serialized)
                    {
                        And (EPWS, 0x02, Local0)
                        If (Local0)
                        {
                            Store (One, DCPF)
                        }
                        Else
                        {
                            Store (Zero, DCPF)
                        }

                        If (Arg0)
                        {
                            Return (DCP2)
                        }
                        Else
                        {
                            Return (DCPF)
                        }
                    }

                    Method (NBAT, 1, NotSerialized)
                    {
                        If (BATP (Zero))
                        {
                            Notify (BAT0, Arg0)
                        }
                    }

                    Method (ACAP, 0, Serialized)
                    {
                        And (EPWS, One, Local0)
                        If (Local0)
                        {
                            Store (One, ACPF)
                        }
                        Else
                        {
                            Store (Zero, ACPF)
                        }

                        Return (ACPF)
                    }

                    Method (GBTT, 1, Serialized)
                    {
                        If (LEqual (Arg0, Zero))
                        {
                            Store (EB0T, Local0)
                        }
                        Else
                        {
                            Store (EB1T, Local0)
                        }

                        Return (Local0)
                    }

                    Method (BCHG, 1, Serialized)
                    {
                        If (Arg0)
                        {
                            If (ECAV ())
                            {
                                Store (EB1S, Local0)
                                And (Local0, 0xFF, Local0)
                                If (LNotEqual (Local0, 0xFF))
                                {
                                    And (Local0, 0x02, Local0)
                                }
                                Else
                                {
                                    Store (Zero, Local0)
                                }
                            }
                            Else
                            {
                                Store (Zero, Local0)
                            }

                            Return (Local0)
                        }
                        Else
                        {
                            If (ECAV ())
                            {
                                Store (EB0S, Local0)
                                And (Local0, 0xFF, Local0)
                                If (LNotEqual (Local0, 0xFF))
                                {
                                    And (Local0, 0x02, Local0)
                                }
                                Else
                                {
                                    Store (Zero, Local0)
                                }
                            }
                            Else
                            {
                                Store (Zero, Local0)
                            }

                            Return (Local0)
                        }
                    }

                    Method (RRAM, 1, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, Local0)
                            And (Local0, 0xFF, Local1)
                            ShiftRight (Local0, 0x08, Local0)
                            And (Local0, 0xFF, Local0)
                            Store (Local1, CDT2)
                            Store (Local0, CDT1)
                            Store (0x80, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (WRAM, 2, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, Local0)
                            And (Local0, 0xFF, Local1)
                            ShiftRight (Local0, 0x08, Local0)
                            And (Local0, 0xFF, Local0)
                            Store (Local1, CDT2)
                            Store (Local0, CDT1)
                            Store (Arg1, CDT3)
                            Store (0x81, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (SBRV, 1, Serialized)
                    {
                        WBOV (Zero, Arg0)
                    }

                    Name (DECF, Zero)
                    Method (SFNV, 2, Serialized)
                    {
                        Store (RRAM (0x0521), Local1)
                        Store (RRAM (0x0522), Local2)
                        Store (RRAM (0x0523), Local3)
                        Store (RRAM (0x0524), Local4)
                        If (LEqual (Arg0, Zero))
                        {
                            Or (Local3, 0x80, Local3)
                            Or (Local4, 0x80, Local4)
                            If (And (Local1, 0x80))
                            {
                                ShiftRight (Local1, 0x04, Local0)
                                And (Local0, 0x03, Local0)
                                If (LEqual (Local0, Zero))
                                {
                                    WRAM (0x0523, Local3)
                                }
                                Else
                                {
                                    If (LEqual (Local0, One))
                                    {
                                        WRAM (0x0524, Local4)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local0, 0x02))
                                        {
                                            WRAM (0x0523, Local3)
                                            WRAM (0x0524, Local4)
                                        }
                                    }
                                }
                            }

                            If (And (Local2, 0x80))
                            {
                                ShiftRight (Local2, 0x04, Local0)
                                And (Local0, 0x03, Local0)
                                If (LEqual (Local0, Zero))
                                {
                                    WRAM (0x0523, Local3)
                                }
                                Else
                                {
                                    If (LEqual (Local0, One))
                                    {
                                        WRAM (0x0524, Local4)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local0, 0x02))
                                        {
                                            WRAM (0x0523, Local3)
                                            WRAM (0x0524, Local4)
                                        }
                                    }
                                }
                            }

                            Return (Zero)
                        }

                        And (Local3, 0x7F, Local3)
                        And (Local4, 0x7F, Local4)
                        WRAM (0x0523, Local3)
                        WRAM (0x0524, Local4)
                        WFOV (Decrement (Arg0), Arg1)
                        Return (Zero)
                    }

                    Method (SPIN, 3, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, Local0)
                            Store (Arg1, Local1)
                            If (LGreaterEqual (Local0, 0x41))
                            {
                                Subtract (Local0, 0x41, Local0)
                            }

                            ShiftLeft (Local0, 0x04, Local0)
                            Or (Local0, Local1, Local0)
                            Store (Local0, CDT2)
                            If (LEqual (Arg2, One))
                            {
                                Store (0x20, Local2)
                            }
                            Else
                            {
                                Store (0x40, Local2)
                            }

                            Store (Local2, CDT1)
                            Store (0x87, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (RPIN, 2, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, Local0)
                            If (LGreaterEqual (Local0, 0x41))
                            {
                                Subtract (Local0, 0x41, Local0)
                            }

                            ShiftLeft (Local0, 0x04, Local0)
                            Or (Local0, Arg1, Local0)
                            Store (Local0, CDT2)
                            Store (Zero, CDT1)
                            Store (0x87, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    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 (WBLP, 0x8A)
                    Name (RBLP, 0x8B)
                    Name (PCLL, 0x0C)
                    Name (GOOD, Zero)
                    Name (UKER, 0x07)
                    Name (DAER, 0x10)
                    Name (DERR, 0x11)
                    Name (CMDN, 0x12)
                    Name (UKE2, 0x13)
                    Name (DADN, 0x17)
                    Name (SBTO, 0x18)
                    Name (USPT, 0x19)
                    Name (SBBY, 0x1A)
                    Method (SMBR, 3, Serialized)
                    {
                        Store (Package (0x03)
                            {
                                0x07, 
                                Zero, 
                                Zero
                            }, Local0)
                        OperationRegion (ECBD, SystemMemory, 0xFEFF0200, 0x80)
                        Field (ECBD, ByteAcc, Lock, Preserve)
                        {
                                    Offset (0x40), 
                            BCNT,   8, 
                            BDAT,   256
                        }

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

                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Zero, CDT1)
                            Store (Arg0, CDT2)
                            ShiftLeft (Arg1, One, Local1)
                            Store (Local1, CDT3)
                            Store (Arg2, CDT4)
                            Store (Zero, CDT5)
                            Store (0x9A, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local2)
                            While (LAnd (Local2, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local2)
                            }

                            If (LEqual (CMD1, Zero))
                            {
                                Store (GOOD, Index (Local0, Zero))
                                If (LEqual (Arg0, RDBL))
                                {
                                    Store (BCNT, Index (Local0, One))
                                    Store (BDAT, Index (Local0, 0x02))
                                }

                                If (LEqual (Arg0, RBLP))
                                {
                                    Store (BCNT, Index (Local0, One))
                                    Store (BDAT, Index (Local0, 0x02))
                                }

                                If (LEqual (Arg0, RDWD))
                                {
                                    Store (0x02, Index (Local0, One))
                                    Store (EDA1, Local1)
                                    ShiftLeft (Local1, 0x08, Local1)
                                    Or (Local1, EDA2, Local1)
                                    Store (Local1, Index (Local0, 0x02))
                                }

                                If (LEqual (Arg0, RDBT))
                                {
                                    Store (One, Index (Local0, One))
                                    Store (EDA1, Index (Local0, 0x02))
                                }

                                If (LEqual (Arg0, RCBT))
                                {
                                    Store (One, Index (Local0, One))
                                    Store (EDA1, Index (Local0, 0x02))
                                }
                            }

                            Release (MUEC)
                        }

                        Return (Local0)
                    }

                    Method (SMBW, 5, Serialized)
                    {
                        Store (Package (0x03)
                            {
                                0x07, 
                                Zero, 
                                Zero
                            }, Local0)
                        OperationRegion (ECBD, SystemMemory, 0xFEFF0000, 0x80)
                        Field (ECBD, ByteAcc, Lock, Preserve)
                        {
                                    Offset (0x07), 
                            BDAT,   256
                        }

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

                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Zero, CDT1)
                            Store (Arg0, CDT2)
                            ShiftLeft (Arg1, One, Local1)
                            Store (Local1, CDT3)
                            Store (Arg2, CDT4)
                            If (LEqual (Arg0, WRBL))
                            {
                                Store (Arg3, CDT5)
                                Store (Arg4, BDAT)
                            }

                            If (LEqual (Arg0, WBLP))
                            {
                                Store (Arg3, CDT5)
                                Store (Arg4, BDAT)
                            }

                            If (LEqual (Arg0, WRWD))
                            {
                                Store (Zero, CDT5)
                                Store (Arg4, CDT6)
                            }

                            If (LEqual (Arg0, WRBT))
                            {
                                Store (Zero, CDT5)
                                Store (Arg4, CDT6)
                            }

                            If (LEqual (Arg0, SDBT))
                            {
                                Store (Zero, CDT5)
                                Store (Arg4, CDT6)
                            }

                            Store (0x9A, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local2)
                            While (LAnd (Local2, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local2)
                            }

                            If (LEqual (CMD1, Zero))
                            {
                                Store (Zero, Index (Local0, Zero))
                            }
                            Else
                            {
                                Store (UKER, Index (Local0, Zero))
                            }

                            Release (MUEC)
                        }

                        Return (Local0)
                    }

                    Mutex (MUEP, 0x00)
                    Method (RBEP, 1, NotSerialized)
                    {
                        Return (Zero)
                    }

                    Method (WBEP, 2, NotSerialized)
                    {
                        Return (Zero)
                    }

                    Method (SDAC, 2, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (Arg1, CDT2)
                            Store (0x86, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (ECXT, 6, NotSerialized)
                    {
                        Store (Package (0x06)
                            {
                                0x10, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero
                            }, Local1)
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg1, CDT1)
                            Store (Arg2, CDT2)
                            Store (Arg3, CDT3)
                            Store (Arg4, CDT4)
                            Store (Arg5, CDT5)
                            Store (Arg0, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

                            If (LEqual (CMD1, Zero))
                            {
                                Store (Zero, Index (Local1, Zero))
                                Store (EDA1, Index (Local1, One))
                                Store (EDA2, Index (Local1, 0x02))
                                Store (EDA3, Index (Local1, 0x03))
                                Store (EDA4, Index (Local1, 0x04))
                                Store (EDA5, Index (Local1, 0x05))
                            }
                            Else
                            {
                                Store (0x10, Index (Local1, Zero))
                            }

                            Release (MUEC)
                        }

                        Return (Local1)
                    }

                    Method (ECX1, 1, Serialized)
                    {
                        Store (Package (0x0D)
                            {
                                0x10, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero
                            }, Local1)
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (DerefOf (Index (Arg0, One)), CDT1)
                            Store (DerefOf (Index (Arg0, 0x02)), CDT2)
                            Store (DerefOf (Index (Arg0, 0x03)), CDT3)
                            Store (DerefOf (Index (Arg0, 0x04)), CDT4)
                            Store (DerefOf (Index (Arg0, 0x05)), CDT5)
                            Store (DerefOf (Index (Arg0, 0x06)), CDT6)
                            Store (DerefOf (Index (Arg0, 0x07)), CDT7)
                            Store (DerefOf (Index (Arg0, 0x08)), CDT8)
                            Store (DerefOf (Index (Arg0, 0x09)), CDT9)
                            Store (DerefOf (Index (Arg0, 0x0A)), CD10)
                            Store (DerefOf (Index (Arg0, 0x0B)), CD11)
                            Store (DerefOf (Index (Arg0, 0x0C)), CD12)
                            Store (DerefOf (Index (Arg0, Zero)), CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

                            If (LEqual (CMD1, Zero))
                            {
                                Store (Zero, Index (Local1, Zero))
                                Store (EDA1, Index (Local1, One))
                                Store (EDA2, Index (Local1, 0x02))
                                Store (EDA3, Index (Local1, 0x03))
                                Store (EDA4, Index (Local1, 0x04))
                                Store (EDA5, Index (Local1, 0x05))
                                Store (EDA6, Index (Local1, 0x06))
                                Store (EDA7, Index (Local1, 0x07))
                                Store (EDA8, Index (Local1, 0x08))
                                Store (EDA9, Index (Local1, 0x09))
                                Store (ED10, Index (Local1, 0x0A))
                                Store (ED11, Index (Local1, 0x0B))
                                Store (ED12, Index (Local1, 0x0C))
                            }
                            Else
                            {
                                Store (0x10, Index (Local1, Zero))
                            }

                            Release (MUEC)
                        }

                        Return (Local1)
                    }

                    Method (ECSB, 6, NotSerialized)
                    {
                        Store (Package (0x05)
                            {
                                0x11, 
                                Zero, 
                                Zero, 
                                Zero, 
                                Zero
                            }, Local1)
                        If (LGreater (Arg0, One))
                        {
                            Return (Local1)
                        }

                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (Arg1, CDT2)
                            Store (Arg2, CDT3)
                            Store (Arg3, CDT4)
                            Store (Zero, CDT5)
                            Store (Arg4, CDT6)
                            Store (Arg5, CDT7)
                            Store (0x9A, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local2)
                            While (LAnd (Local2, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local2)
                            }

                            If (LEqual (CMD1, Zero))
                            {
                                Store (Zero, Index (Local1, Zero))
                                Store (EDA1, Index (Local1, One))
                                Store (EDA2, Index (Local1, 0x02))
                                Store (EDA3, Index (Local1, 0x03))
                                Store (EDA4, Index (Local1, 0x04))
                            }
                            Else
                            {
                                Store (0x10, Index (Local1, Zero))
                            }

                            Release (MUEC)
                        }

                        Return (Local1)
                    }

                    Method (WEIE, 0, Serialized)
                    {
                        Store (0x4000, Local0)
                        And (AEIC, 0x02, Local1)
                        While (LAnd (LNotEqual (Local0, Zero), LEqual (Local1, 0x02)))
                        {
                            And (AEIC, 0x02, Local1)
                            Decrement (Local0)
                        }
                    }

                    Method (WEOF, 0, Serialized)
                    {
                        Store (0x4000, Local0)
                        And (AEIC, One, Local1)
                        While (LAnd (LNotEqual (Local0, Zero), LEqual (Local1, Zero)))
                        {
                            And (AEIC, One, Local1)
                            Decrement (Local0)
                        }
                    }

                    Method (RFOV, 1, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (0x83, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (WFOV, 2, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (Arg1, CDT2)
                            Store (0x84, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (RBOV, 1, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (0x85, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (WBOV, 2, Serialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (Arg1, CDT2)
                            Store (0x86, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (PKEN, 1, NotSerialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (0xB1, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (FNLK, 1, NotSerialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            Store (Arg0, CDT1)
                            Store (0xB0, CMD1)
                            Store (0x0F, ESEM)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (PTHP, 1, NotSerialized)
                    {
                        If (LEqual (Acquire (MUEC, 0xFFFF), Zero))
                        {
                            CreateField (Arg0, Zero, 0x01F0, CDB0)
                            Store (CDB0, CDTB)
                            Store (0x97, CMDB)
                            Store (0x0F, ESEB)
                            Store (0x7F, Local0)
                            While (LAnd (Local0, CMD1))
                            {
                                Sleep (One)
                                Decrement (Local0)
                            }

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

                            Release (MUEC)
                            Return (Local0)
                        }

                        Return (Ones)
                    }

                    Method (ECPH, 0, Serialized)
                    {
                        WRAM (0x0780, Zero)
                    }

                    Method (ACPS, 0, Serialized)
                    {
                        Return (And (GPWS (), One))
                    }

                    Method (DCPS, 1, Serialized)
                    {
                        Store (GPWS (), Local0)
                        If (Arg0)
                        {
                            And (Local0, 0x04, Local0)
                        }
                        Else
                        {
                            And (Local0, 0x02, Local0)
                        }

                        If (Local0)
                        {
                            Store (One, Local0)
                        }
                        Else
                        {
                            Store (Zero, Local0)
                        }

                        Return (Local0)
                    }

                    Method (GPWS, 0, Serialized)
                    {
                        Store (EPWS, Local0)
                        Return (Local0)
                    }

                    Method (BCLE, 1, Serialized)
                    {
                        If (Arg0)
                        {
                            If (ECAV ())
                            {
                                Store (EB1S, Local1)
                                And (Local1, 0xFFFF, Local1)
                                If (LNotEqual (Local1, 0xFFFF))
                                {
                                    And (Local1, 0x16, Local1)
                                    If (LEqual (Local1, 0x04))
                                    {
                                        Store (Zero, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local1, 0x02))
                                        {
                                            Store (One, Local0)
                                        }
                                        Else
                                        {
                                            If (LEqual (Local1, 0x10))
                                            {
                                                Store (One, Local0)
                                            }
                                        }
                                    }
                                }

                                Store (Ones, Local0)
                            }
                            Else
                            {
                                Store (Ones, Local0)
                            }

                            Return (Local0)
                        }
                        Else
                        {
                            If (ECAV ())
                            {
                                Store (EB0S, Local1)
                                And (Local1, 0xFFFF, Local1)
                                If (LNotEqual (Local1, 0xFFFF))
                                {
                                    And (Local1, 0x16, Local1)
                                    If (LEqual (Local1, 0x04))
                                    {
                                        Store (Zero, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local1, 0x02))
                                        {
                                            Store (One, Local0)
                                        }
                                        Else
                                        {
                                            If (LEqual (Local1, 0x10))
                                            {
                                                Store (One, Local0)
                                            }
                                        }
                                    }
                                }

                                Store (Ones, Local0)
                            }
                            Else
                            {
                                Store (Ones, Local0)
                            }

                            Return (Local0)
                        }
                    }

                    Method (_QA0, 0, NotSerialized)
                    {
                        Store (0xA0, IO80)
                        Store (One, ^^^^VALZ.ISFT)
                        If (ACPS ())
                        {
                            Store (One, ACPF)
                            Store (0x58, Local0)
                        }
                        Else
                        {
                            Store (Zero, ACPF)
                            Store (0x57, Local0)
                        }

                        If (LLess (OSTB, 0x40)) {}
                        Notify (AC0, 0x80)
                        If (ATKP) {}
                        Sleep (0x64)
                        Sleep (0x0A)
                        NBAT (0x80)
                        TTPH ()
                        ECPH ()
                    }

                    Method (_QA1, 0, NotSerialized)
                    {
                        Store (0xA1, IO80)
                        Store (One, ^^^^VALZ.ISFT)
                        Store (DCPS (Zero), DCPF)
                        If (DCPF)
                        {
                            Sleep (0x07D0)
                        }

                        Notify (BAT0, 0x80)
                        Notify (BAT0, 0x81)
                        ^^^^VALZ.GBIF ()
                        ^^^^VALZ.GSMB ()
                        TTPH ()
                        ECPH ()
                    }

                    Method (_QA3, 0, NotSerialized)
                    {
                        Store (0xA3, IO80)
                        If (BATP (Zero))
                        {
                            Store (BCLE (Zero), Local0)
                            If (LEqual (Local0, Zero))
                            {
                                Notify (BAT0, 0x80)
                            }
                            Else
                            {
                                Notify (BAT0, 0x81)
                                Notify (AC0, 0x80)
                            }
                        }

                        ECPH ()
                    }

                    Method (_QA5, 0, NotSerialized)
                    {
                        Store (0xA5, IO80)
                        If (ATKP) {}
                        Else
                        {
                            If (BATP (Zero))
                            {
                                Notify (BAT0, 0x80)
                            }
                        }

                        ECPH ()
                    }

                    Method (_QB2, 0, NotSerialized)
                    {
                        Store (0xB2, IO80)
                        ^^^^VALZ.PUTE (0x0401)
                        ECPH ()
                    }

                    Method (_QB3, 0, NotSerialized)
                    {
                        Store (0xB3, IO80)
                        ECPH ()
                    }

                    Method (_QB4, 0, NotSerialized)
                    {
                        Store (0xB4, IO80)
                        ECPH ()
                    }

                    Method (_QB0, 0, NotSerialized)
                    {
                        Store (0xB0, IO80)
                        Store (RRAM (0x051C), Local0)
                        If (And (Local0, 0x02))
                        {
                            Store (One, \_TZ.CRTF)
                        }

                        Notify (\_TZ.THZ0, 0x81)
                        Notify (\_TZ.THZ0, 0x80)
                        ECPH ()
                    }

                    Name (PSVF, Zero)
                    Method (_QB5, 0, NotSerialized)
                    {
                        Store (0xB5, IO80)
                        If (LEqual (PSVF, Zero))
                        {
                            Store (One, PSVF)
                            Notify (\_TZ.THZ0, 0x80)
                            Notify (\_TZ.THZ0, 0x81)
                        }

                        ECPH ()
                    }

                    Method (_QB6, 0, NotSerialized)
                    {
                        Store (0xB6, IO80)
                        If (LEqual (PSVF, One))
                        {
                            Store (Zero, PSVF)
                            Notify (\_TZ.THZ0, 0x80)
                            Notify (\_TZ.THZ0, 0x81)
                        }

                        ECPH ()
                    }

                    Method (_Q68, 0, NotSerialized)
                    {
                        Store (0x68, IO80)
                        ECPH ()
                    }

                    Method (_Q73, 0, NotSerialized)
                    {
                        Store (0x73, IO80)
                        ECPH ()
                    }

                    Method (_QD6, 0, NotSerialized)
                    {
                        Store (0xD6, IO80)
                        ^^^^VALZ.PUTE (0x01FF)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_QD7, 0, NotSerialized)
                    {
                        Store (0xD7, IO80)
                        ^^^^VALZ.PUTE (0x0100)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_QD0, 0, NotSerialized)
                    {
                        Store (0xD0, IO80)
                        ^^^^VALZ.PUTE (0x0C91)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_QD2, 0, NotSerialized)
                    {
                        Store (0xD2, IO80)
                        ^^^^VALZ.PUTE (0x0C9F)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_QD1, 0, NotSerialized)
                    {
                        Store (0xD1, IO80)
                        ^^^^VALZ.PUTE (0x0C92)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_QD3, 0, NotSerialized)
                    {
                        Store (0xD3, IO80)
                        ^^^^VALZ.PUTE (0x19B7)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_QD4, 0, NotSerialized)
                    {
                        Store (0xD4, IO80)
                        ^^^^VALZ.PUTE (0x19B6)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q0A, 0, NotSerialized)
                    {
                        Store (0x0A, IO80)
                        If (KBTY)
                        {
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero))) {}
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x013B)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q2A, 0, NotSerialized)
                    {
                        Store (0x2A, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01BB)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                ECXT (0xB8, One, Zero, Zero, Zero, Zero)
                            }
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q0B, 0, NotSerialized)
                    {
                        Store (0x0B, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x013C)
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x013C)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q2B, 0, NotSerialized)
                    {
                        Store (0x2B, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x01BC)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                Notify (^^^VGA.LCD, 0x87)
                            }
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01BC)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q0C, 0, NotSerialized)
                    {
                        Store (0x0C, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x013D)
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x013D)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q2C, 0, NotSerialized)
                    {
                        Store (0x2C, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x01BD)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                Notify (^^^VGA.LCD, 0x86)
                            }
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01BD)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                ECXT (0xB8, 0x02, Zero, Zero, Zero, Zero)
                            }
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q0D, 0, NotSerialized)
                    {
                        Store (0x0D, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x013E)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                ECXT (0xB8, 0x05, Zero, Zero, Zero, Zero)
                            }
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x013E)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q2D, 0, NotSerialized)
                    {
                        Store (0x2D, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x01BE)
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01BE)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q0E, 0, NotSerialized)
                    {
                        Store (0x0E, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x013F)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                _Q84 ()
                            }
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x013F)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                ECXT (0xB8, 0x05, Zero, Zero, Zero, Zero)
                            }
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q2E, 0, NotSerialized)
                    {
                        Store (0x2E, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x01BF)
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01BF)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q0F, 0, NotSerialized)
                    {
                        Store (0x0F, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x0140)
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q2F, 0, NotSerialized)
                    {
                        Store (0x2F, IO80)
                        If (KBTY)
                        {
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero))) {}
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01C0)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                Notify (^^^VGA.LCD, 0x87)
                            }
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q10, 0, NotSerialized)
                    {
                        Store (0x10, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x0141)
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q30, 0, NotSerialized)
                    {
                        Store (0x30, IO80)
                        If (KBTY)
                        {
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero))) {}
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01C1)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                Notify (^^^VGA.LCD, 0x86)
                            }
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q11, 0, NotSerialized)
                    {
                        Store (0x11, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x0142)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                If (LAnd (WLDP, WRST))
                                {
                                    SGPL (0xD3, One, Zero)
                                    Store (Zero, WRST)
                                    SGPL (0xD2, One, Zero)
                                    Store (Zero, BRST)
                                    SGPL (0xAB, One, Zero)
                                }
                                Else
                                {
                                    SGPL (0xD3, One, One)
                                    Store (One, WRST)
                                    SGPL (0xD2, One, One)
                                    Store (One, BRST)
                                    SGPL (0xAB, One, One)
                                }
                            }
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q31, 0, NotSerialized)
                    {
                        Store (0x31, IO80)
                        If (KBTY)
                        {
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero))) {}
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01C2)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q12, 0, NotSerialized)
                    {
                        Store (0x12, IO80)
                        If (KBTY)
                        {
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                Store (RRAM (0x07C7), Local0)
                                If (And (Local0, One))
                                {
                                    ECXT (0xB5, Zero, Zero, Zero, Zero, Zero)
                                    Store (One, TPON)
                                }
                                Else
                                {
                                    ECXT (0xB5, One, Zero, Zero, Zero, Zero)
                                    Store (Zero, TPON)
                                }
                            }
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x0143)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                _Q84 ()
                            }
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q32, 0, NotSerialized)
                    {
                        Store (0x32, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01C3)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q13, 0, NotSerialized)
                    {
                        Store (0x13, IO80)
                        If (KBTY)
                        {
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                ECXT (0xB8, 0x04, Zero, Zero, Zero, Zero)
                            }
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x1BB0)
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q33, 0, NotSerialized)
                    {
                        Store (0x33, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x1BB1)
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q14, 0, NotSerialized)
                    {
                        Store (0x14, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x0157)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                ECXT (0xB8, Zero, Zero, Zero, Zero, Zero)
                            }
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x1BB2)
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q34, 0, NotSerialized)
                    {
                        Store (0x34, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x01D7)
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x1BB3)
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q15, 0, NotSerialized)
                    {
                        Store (0x15, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x0158)
                        }
                        Else
                        {
                        }

                        If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                        {
                            If (LAnd (WLDP, WRST))
                            {
                                SGPL (0xD3, One, Zero)
                                Store (Zero, WRST)
                                SGPL (0xD2, One, Zero)
                                Store (Zero, BRST)
                                SGPL (0xAB, One, Zero)
                            }
                            Else
                            {
                                SGPL (0xD3, One, One)
                                Store (One, WRST)
                                SGPL (0xD2, One, One)
                                Store (One, BRST)
                                SGPL (0xAB, One, One)
                            }
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q35, 0, NotSerialized)
                    {
                        Store (0x35, IO80)
                        If (KBTY)
                        {
                            ^^^^VALZ.PUTE (0x01D8)
                        }
                        Else
                        {
                            ^^^^VALZ.PUTE (0x01C0)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero))) {}
                        }

                        ECPH ()
                        Return (One)
                    }

                    Method (_Q6B, 0, NotSerialized)
                    {
                        Store (0x6B, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x0101)
                            If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                            {
                                ECXT (0xB8, Zero, Zero, Zero, Zero, Zero)
                            }
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q8B, 0, NotSerialized)
                    {
                        Store (0x8B, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ^^^^VALZ.PUTE (0x0181)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q6C, 0, NotSerialized)
                    {
                        Store (0x6C, IO80)
                        ^^^^VALZ.PUTE (0x0102)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q8C, 0, NotSerialized)
                    {
                        Store (0x8C, IO80)
                        ^^^^VALZ.PUTE (0x0182)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q6D, 0, NotSerialized)
                    {
                        Store (0x6D, IO80)
                        ^^^^VALZ.PUTE (0x0103)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q8D, 0, NotSerialized)
                    {
                        Store (0x8D, IO80)
                        ^^^^VALZ.PUTE (0x0183)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q69, 0, NotSerialized)
                    {
                        Store (0x69, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ECXT (0xB8, 0x03, Zero, Zero, Zero, Zero)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q89, 0, NotSerialized)
                    {
                        Store (0x89, IO80)
                        If (KBTY) {}
                        Else
                        {
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q6A, 0, NotSerialized)
                    {
                        Store (0x6A, IO80)
                        If (KBTY) {}
                        Else
                        {
                            ECXT (0xB8, 0x04, Zero, Zero, Zero, Zero)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q8A, 0, NotSerialized)
                    {
                        Store (0x8A, IO80)
                        If (KBTY) {}
                        Else
                        {
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q60, 0, NotSerialized)
                    {
                        Store (0x60, IO80)
                        Notify (VALZ, 0x8E)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q80, 0, NotSerialized)
                    {
                        Store (0x80, IO80)
                        ECPH ()
                    }

                    Method (_Q81, 0, NotSerialized)
                    {
                        Store (0x81, IO80)
                        If (LEqual (WINF, Zero))
                        {
                            If (LEqual (RPIN (0x07, 0x02), Zero))
                            {
                                Store (One, LDEV)
                                Notify (VALZ, 0x8F)
                                ^^^^VALZ.PUTE (0x19B3)
                            }
                            Else
                            {
                                ^^^^VALZ.PUTE (0x19B2)
                            }

                            Notify (LID, 0x80)
                        }

                        ECPH ()
                    }

                    Method (_Q84, 0, NotSerialized)
                    {
                        Store (0x84, IO80)
                        If (LOr (LEqual (^^^^VALZ.ENFG, Zero), LEqual (^^^^VALZ.OSMD, Zero)))
                        {
                            Store (RRAM (0x07C7), Local0)
                            If (LAnd (Local0, One))
                            {
                                ECXT (0xB5, Zero, Zero, Zero, Zero, Zero)
                                Store (One, TPON)
                            }
                            Else
                            {
                                ECXT (0xB5, One, Zero, Zero, Zero, Zero)
                                Store (Zero, TPON)
                            }
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q88, 0, NotSerialized)
                    {
                        Store (0x88, IO80)
                        If (LEqual (RPIN (0x09, 0x04), Zero))
                        {
                            Store (Zero, ^^^^VALZ.LCDS)
                            ^^^^VALZ.PUTE (0x19B1)
                            ^^^^VALZ.PUTE (0x19B3)
                        }
                        Else
                        {
                            Store (One, ^^^^VALZ.LCDS)
                            ^^^^VALZ.PUTE (0x19B0)
                            ^^^^VALZ.PUTE (0x19B2)
                        }

                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q6F, 0, NotSerialized)
                    {
                        Store (0x6F, IO80)
                        ^^^^VALZ.PUTE (0x0139)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q8F, 0, NotSerialized)
                    {
                        Store (0x8F, IO80)
                        ^^^^VALZ.PUTE (0x01B9)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q70, 0, NotSerialized)
                    {
                        Store (0x70, IO80)
                        ^^^^VALZ.PUTE (0x012C)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q90, 0, NotSerialized)
                    {
                        Store (0x90, IO80)
                        ^^^^VALZ.PUTE (0x01AC)
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q00, 0, NotSerialized)
                    {
                        ECPH ()
                        Return (Zero)
                    }

                    Method (_Q01, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q02, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q03, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q04, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q05, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q06, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q07, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q08, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q09, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q16, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q17, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q18, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q19, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q1A, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q1B, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q1C, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q1D, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q1E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q1F, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q20, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q21, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q22, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q23, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q24, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q25, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q26, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q27, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q28, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q29, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q36, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q37, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q38, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q39, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q3A, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q3B, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q3C, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q3D, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q3E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q3F, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q40, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q41, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q42, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q43, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q44, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q45, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q46, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q47, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q48, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q49, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q4A, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q4B, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q4C, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q4D, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q4E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q4F, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

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

                    Method (_Q51, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q52, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q53, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q54, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q55, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q56, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q57, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q58, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q59, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q5A, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q5B, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q5C, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q5D, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q5E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q5F, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q61, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q62, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q63, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q64, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q65, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q66, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q67, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q6E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q71, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q72, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q74, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q75, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q76, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q77, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q78, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q79, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q7A, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q7B, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q7C, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q7D, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q7E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q7F, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q82, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q83, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q85, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q86, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q87, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q8E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q91, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q92, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q93, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q94, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q95, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q96, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q97, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q98, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q99, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q9A, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q9B, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q9C, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q9D, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q9E, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_Q9F, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QA2, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QA4, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QA6, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QA7, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QA8, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QA9, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QAA, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QAB, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QAC, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QAD, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QAE, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QAF, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QB1, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QB7, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QB8, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QB9, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QBA, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QBB, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QBC, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QBD, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QBE, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QBF, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC0, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC1, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC2, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC3, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC4, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC5, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC6, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC7, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC8, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QC9, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QCA, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QCB, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QCC, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QCD, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QCE, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QCF, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QD5, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QD8, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QD9, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QDA, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QDB, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QDC, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QDD, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QDE, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QDF, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE0, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE1, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE2, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE3, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE4, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE5, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE6, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE7, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE8, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QE9, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QEA, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QEB, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QEC, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QED, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QEE, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QEF, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF0, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF1, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF2, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF3, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF4, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF5, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF6, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF7, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF8, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QF9, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QFA, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QFB, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QFC, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QFD, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QFE, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Method (_QFF, 0, NotSerialized)
                    {
                        _Q00 ()
                    }

                    Name (AACV, Zero)
                    Name (ABCV, Zero)
                    Name (TMLP, Buffer (0x40) {})
                    Name (TTAC, 0xFF)
                    Method (TTPH, 0, Serialized)
                    {
                        If (LEqual (TTAC, 0xFF))
                        {
                            Store (RRAM (0x0523), Local0)
                            And (Local0, 0xF8, Local0)
                            Store (Local0, AACV)
                            Store (RRAM (0x0524), Local0)
                            And (Local0, 0xF8, Local0)
                            Store (Local0, ABCV)
                            Store (ACPF, TTAC)
                            PCF0 ()
                            If (LOr (LEqual (^^^VGA.SDID, 0x3B), LEqual (^^^VGA.SDID, 0x49)))
                            {
                                PDST ()
                                TF1V ()
                            }
                        }
                        Else
                        {
                            If (LNotEqual (TTAC, ACPF))
                            {
                                Store (ACPF, TTAC)
                                PCF0 ()
                            }
                        }

                        Sleep (0x01F4)
                        Notify (\_TZ.THZ0, 0x80)
                        Notify (\_TZ.THZ0, 0x81)
                    }

                    Method (PCF0, 0, NotSerialized)
                    {
                        If (ACPF)
                        {
                            CALA ()
                            TF0A ()
                        }
                        Else
                        {
                            CALD ()
                            TF0D ()
                        }
                    }

                    Name (CADT, Buffer (0x30)
                    {
                        /* 0000 */    0x63, 0x62, 0x61, 0x62, 0x55, 0x44, 0x73, 0x3F, 
                        /* 0008 */    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x60, 
                        /* 0010 */    0x0A, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 
                        /* 0018 */    0x6E, 0x9D, 0x9D, 0x9D, 0x9D, 0x9D, 0x9D, 0x9D, 
                        /* 0020 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0028 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
                    })
                    Name (CAAT, Buffer (0x30)
                    {
                        /* 0000 */    0x63, 0x62, 0x61, 0x62, 0x55, 0x44, 0x73, 0x32, 
                        /* 0008 */    0x3C, 0x41, 0x46, 0x4E, 0x4E, 0x4E, 0x4E, 0x60, 
                        /* 0010 */    0x0F, 0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B, 
                        /* 0018 */    0x6E, 0x8A, 0x9D, 0xB8, 0xCE, 0xCE, 0xCE, 0xCE, 
                        /* 0020 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0028 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
                    })
                    Name (AMDG, Buffer (0x2A)
                    {
                        /* 0000 */    0x73, 0x32, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 
                        /* 0008 */    0x5F, 0x5F, 0x0A, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 
                        /* 0010 */    0x0C, 0x0C, 0x6E, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 
                        /* 0018 */    0xCE, 0xCE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0020 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0028 */    0xFF, 0xFF
                    })
                    Name (F0DC, Buffer (0x10)
                    {
                        /* 0000 */    0x7A, 0xFE, 0xDC, 0xFE, 0xDC, 0xFE, 0xDC, 0xFE, 
                        /* 0008 */    0xDC, 0xFE, 0xDC, 0xFE, 0xDC, 0xFE, 0xDC, 0xFE
                    })
                    Name (F0AC, Buffer (0x10)
                    {
                        /* 0000 */    0x7A, 0xFE, 0xBD, 0xFE, 0xDC, 0xFE, 0xFC, 0xFE, 
                        /* 0008 */    0x10, 0xFF, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0xFF
                    })
                    Name (F1VG, Buffer (0x10)
                    {
                        /* 0000 */    0x7A, 0xFE, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0xFF, 
                        /* 0008 */    0x10, 0xFF, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0xFF
                    })
                    Method (CALD, 0, Serialized)
                    {
                        CLPB ()
                        Store (Zero, Index (TMLP, Zero))
                        Or (AACV, 0x1F, Local2)
                        Store (Local2, Index (TMLP, One))
                        Store (Zero, Local0)
                        Store (0x02, Local1)
                        While (LLessEqual (Local1, 0x31))
                        {
                            Store (DerefOf (Index (CADT, Local0)), Index (TMLP, Local1))
                            Increment (Local0)
                            Increment (Local1)
                        }

                        PTHP (TMLP)
                    }

                    Method (CALA, 0, Serialized)
                    {
                        CLPB ()
                        Store (Zero, Index (TMLP, Zero))
                        Or (AACV, 0x1F, Local2)
                        Store (Local2, Index (TMLP, One))
                        Store (Zero, Local0)
                        Store (0x02, Local1)
                        While (LLessEqual (Local1, 0x31))
                        {
                            Store (DerefOf (Index (CAAT, Local0)), Index (TMLP, Local1))
                            Increment (Local0)
                            Increment (Local1)
                        }

                        PTHP (TMLP)
                    }

                    Method (PDST, 0, Serialized)
                    {
                        CLPB ()
                        Store (One, Index (TMLP, Zero))
                        Store (0x9F, Local2)
                        Store (Local2, Index (TMLP, One))
                        Store (RRAM (0x0530), Local1)
                        Store (Local1, Index (TMLP, 0x02))
                        Store (RRAM (0x0531), Local1)
                        Store (Local1, Index (TMLP, 0x03))
                        Store (RRAM (0x0532), Local1)
                        Store (Local1, Index (TMLP, 0x04))
                        Store (RRAM (0x0533), Local1)
                        Store (Local1, Index (TMLP, 0x05))
                        Store (RRAM (0x0534), Local1)
                        Store (Local1, Index (TMLP, 0x06))
                        Store (RRAM (0x0535), Local1)
                        Store (Local1, Index (TMLP, 0x07))
                        Store (Zero, Local0)
                        Store (0x08, Local1)
                        While (LLessEqual (Local1, 0x31))
                        {
                            Store (DerefOf (Index (AMDG, Local0)), Index (TMLP, Local1))
                            Increment (Local0)
                            Increment (Local1)
                        }

                        Store (RRAM (0x053F), Local1)
                        Store (Local1, Index (TMLP, 0x11))
                        PTHP (TMLP)
                        Store (0x0521, Local0)
                        Store (RRAM (Local0), Local1)
                        And (Local1, 0xCF, Local1)
                        Or (Local1, 0x20, Local1)
                        WRAM (Local0, Local1)
                    }

                    Method (TF0D, 0, Serialized)
                    {
                        CLPB ()
                        Store (0x02, Index (TMLP, Zero))
                        Store (Zero, Local0)
                        Store (One, Local1)
                        While (LLessEqual (Local1, 0x10))
                        {
                            Store (DerefOf (Index (F0DC, Local0)), Index (TMLP, Local1))
                            Increment (Local0)
                            Increment (Local1)
                        }

                        PTHP (TMLP)
                    }

                    Method (TF0A, 0, Serialized)
                    {
                        CLPB ()
                        Store (0x02, Index (TMLP, Zero))
                        Store (Zero, Local0)
                        Store (One, Local1)
                        While (LLessEqual (Local1, 0x10))
                        {
                            Store (DerefOf (Index (F0AC, Local0)), Index (TMLP, Local1))
                            Increment (Local0)
                            Increment (Local1)
                        }

                        PTHP (TMLP)
                    }

                    Method (TF1V, 0, Serialized)
                    {
                        CLPB ()
                        Store (0x03, Index (TMLP, Zero))
                        Store (Zero, Local0)
                        Store (One, Local1)
                        While (LLessEqual (Local1, 0x10))
                        {
                            Store (DerefOf (Index (F1VG, Local0)), Index (TMLP, Local1))
                            Increment (Local0)
                            Increment (Local1)
                        }

                        PTHP (TMLP)
                    }

                    Method (CLPB, 0, NotSerialized)
                    {
                        Store (Zero, Local0)
                        While (LLess (Local0, 0x40))
                        {
                            Store (Zero, Index (TMLP, Local0))
                            Increment (Local0)
                        }
                    }
                }

                OperationRegion (LCLM, SystemIO, 0x0C50, 0x03)
                Field (LCLM, ByteAcc, NoLock, Preserve)
                {
                    CLMI,   8, 
                    CLMD,   8, 
                    CLGP,   8
                }

                IndexField (CLMI, CLMD, ByteAcc, NoLock, Preserve)
                {
                    IDRG,   8, 
                            Offset (0x02), 
                    TSTS,   8, 
                    TINT,   8, 
                            Offset (0x12), 
                    I2CC,   8, 
                    GPIO,   8
                }

                Method (RGPM, 0, NotSerialized)
                {
                    Store (GPIO, Local0)
                    And (Local0, 0xFFFFFF3F, Local0)
                    Store (Local0, GPIO)
                    Store (CLGP, Local1)
                    Return (Local1)
                }
            }

            Device (P2P)
            {
                Name (_ADR, 0x00140004)
                Method (_PRW, 0, NotSerialized)
                {
                    If (LEqual (WKPM, One))
                    {
                        Return (GPRW (0x04, 0x05))
                    }
                    Else
                    {
                        Return (GPRW (0x04, Zero))
                    }
                }

                OperationRegion (PCPC, PCI_Config, Zero, 0xFF)
                Field (PCPC, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x04), 
                    PCMD,   8, 
                            Offset (0x1C), 
                    IOW1,   8, 
                    IOW2,   8, 
                            Offset (0x48), 
                    PR48,   8, 
                    PR49,   8, 
                    PR4A,   8, 
                    PR4B,   8
                }

                Name (PR09, Package (0x08)
                {
                    Package (0x04)
                    {
                        0x0004FFFF, 
                        Zero, 
                        LNKF, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        One, 
                        LNKG, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x02, 
                        LNKH, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x03, 
                        LNKE, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        Zero, 
                        LNKE, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        One, 
                        LNKF, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x02, 
                        LNKG, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x03, 
                        LNKH, 
                        Zero
                    }
                })
                Name (AR09, Package (0x08)
                {
                    Package (0x04)
                    {
                        0x0004FFFF, 
                        Zero, 
                        Zero, 
                        0x15
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        One, 
                        Zero, 
                        0x16
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x02, 
                        Zero, 
                        0x17
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x03, 
                        Zero, 
                        0x14
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        Zero, 
                        Zero, 
                        0x14
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        One, 
                        Zero, 
                        0x15
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x02, 
                        Zero, 
                        0x16
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x03, 
                        Zero, 
                        0x17
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR09)
                    }

                    Return (PR09)
                }
            }

            Device (SATA)
            {
                Name (_ADR, 0x00110000)
                Name (B5EN, Zero)
                Name (BA_5, Zero)
                Name (SBAR, 0xF0451000)
                OperationRegion (SATX, PCI_Config, Zero, 0x44)
                Field (SATX, AnyAcc, NoLock, Preserve)
                {
                    VIDI,   32, 
                            Offset (0x0A), 
                    STCL,   16, 
                            Offset (0x24), 
                    BA05,   32, 
                            Offset (0x40), 
                    WTEN,   1, 
                            Offset (0x42), 
                    DIS0,   1, 
                    DIS1,   1, 
                    DIS2,   1, 
                    DIS3,   1, 
                    DIS4,   1, 
                    DIS5,   1
                }

                Field (SATX, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x42), 
                    DISP,   6
                }

                Method (GBAA, 0, Serialized)
                {
                    Store (BA05, BA_5)
                    If (LOr (LEqual (BA_5, Ones), LNotEqual (STCL, 0x0101)))
                    {
                        Store (Zero, B5EN)
                        Return (SBAR)
                    }
                    Else
                    {
                        Store (One, B5EN)
                        Return (BA_5)
                    }
                }

                OperationRegion (BAR5, SystemMemory, GBAA (), 0x1000)
                Field (BAR5, AnyAcc, NoLock, Preserve)
                {
                    NOPT,   5, 
                            Offset (0x0C), 
                    PTI0,   1, 
                    PTI1,   1, 
                    PTI2,   1, 
                    PTI3,   1, 
                    PTI4,   1, 
                    PTI5,   1, 
                    PTI6,   1, 
                    PTI7,   1, 
                            Offset (0x118), 
                    CST0,   1, 
                            Offset (0x120), 
                        ,   7, 
                    BSY0,   1, 
                            Offset (0x128), 
                    DET0,   4, 
                            Offset (0x129), 
                    IPM0,   4, 
                            Offset (0x12C), 
                    DDI0,   4, 
                            Offset (0x198), 
                    CST1,   1, 
                            Offset (0x1A0), 
                        ,   7, 
                    BSY1,   1, 
                            Offset (0x1A8), 
                    DET1,   4, 
                            Offset (0x1A9), 
                    IPM1,   4, 
                            Offset (0x1AC), 
                    DDI1,   4, 
                            Offset (0x218), 
                    CST2,   1, 
                            Offset (0x220), 
                        ,   7, 
                    BSY2,   1, 
                            Offset (0x228), 
                    DET2,   4, 
                            Offset (0x229), 
                    IPM2,   4, 
                            Offset (0x22C), 
                    DDI2,   4, 
                            Offset (0x298), 
                    CST3,   1, 
                            Offset (0x2A0), 
                        ,   7, 
                    BSY3,   1, 
                            Offset (0x2A8), 
                    DET3,   4, 
                            Offset (0x2A9), 
                    IPM3,   4, 
                            Offset (0x2AC), 
                    DDI3,   4, 
                            Offset (0x318), 
                    CST4,   1, 
                            Offset (0x320), 
                        ,   7, 
                    BSY4,   1, 
                            Offset (0x328), 
                    DET4,   4, 
                            Offset (0x329), 
                    IPM4,   4, 
                            Offset (0x32C), 
                    DDI4,   4, 
                            Offset (0x398), 
                    CST5,   1, 
                            Offset (0x3A0), 
                        ,   7, 
                    BSY5,   1, 
                            Offset (0x3A8), 
                    DET5,   4, 
                            Offset (0x3A9), 
                    IPM5,   4, 
                            Offset (0x3AC), 
                    DDI5,   4
                }

                Field (BAR5, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x0C), 
                    PTI,    6
                }

                Method (_INI, 0, NotSerialized)
                {
                    GBAA ()
                }

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

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SPTM)
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        GBAA ()
                        If (LAnd (LOr (LGreaterEqual (TPOS, 0x40), LEqual (TPOS, 0x04)), 
                            B5EN))
                        {
                            If (IPM0)
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY0, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }

                            If (IPM2)
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY2, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }
                        }
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_STA, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LEqual (B5EN, Zero))
                            {
                                Return (Zero)
                            }

                            If (LEqual (DET0, 0x03))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Name (S12P, Zero)
                        Method (_PS0, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LAnd (LAnd (LLess (TPOS, 0x40), LNotEqual (TPOS, 0x04)), 
                                B5EN))
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY0, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                        }

                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, One)
                        Method (_STA, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LEqual (B5EN, Zero))
                            {
                                Return (Zero)
                            }

                            If (LEqual (DET2, 0x03))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Name (S12P, Zero)
                        Method (_PS0, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LAnd (LAnd (LLess (TPOS, 0x40), LNotEqual (TPOS, 0x04)), 
                                B5EN))
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY2, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                        }

                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x02)
                    Name (SPTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0010 */    0x1F, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SPTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SPTM)
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        GBAA ()
                        If (LAnd (LOr (LGreaterEqual (TPOS, 0x40), LEqual (TPOS, 0x04)), 
                            B5EN))
                        {
                            If (IPM1)
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY1, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }

                            If (IPM3)
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY3, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }
                        }
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_STA, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LEqual (B5EN, Zero))
                            {
                                Return (Zero)
                            }

                            If (LEqual (DET1, 0x03))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LAnd (LAnd (LLess (TPOS, 0x40), LNotEqual (TPOS, 0x04)), 
                                B5EN))
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY1, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                        }

                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, One)
                        Method (_STA, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LEqual (B5EN, Zero))
                            {
                                Return (Zero)
                            }

                            If (LEqual (DET3, 0x03))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            GBAA ()
                            If (LAnd (LAnd (LLess (TPOS, 0x40), LNotEqual (TPOS, 0x04)), 
                                B5EN))
                            {
                                Store (0x32, Local0)
                                While (LAnd (LEqual (BSY3, One), Local0))
                                {
                                    Sleep (0xFA)
                                    Decrement (Local0)
                                }
                            }
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                        }

                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Method (ENP, 2, NotSerialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Store (Not (Arg1), DIS0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, One))
                        {
                            Store (Not (Arg1), DIS1)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (Not (Arg1), DIS2)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    Store (Not (Arg1), DIS3)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        Store (Not (Arg1), DIS4)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            Store (Not (Arg1), DIS5)
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Store (One, WTEN)
                    If (LEqual (Arg0, Zero))
                    {
                        Store (Arg1, PTI0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, One))
                        {
                            Store (Arg1, PTI1)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (Arg1, PTI2)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    Store (Arg1, PTI3)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        Store (Arg1, PTI4)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            Store (Arg1, PTI5)
                                        }
                                    }
                                }
                            }
                        }
                    }

                    If (LEqual (DISP, 0x3F))
                    {
                        Store (One, PTI0)
                    }
                    Else
                    {
                        If (LAnd (DIS0, XOr (And (DISP, 0x3E), 0x3E)))
                        {
                            Store (Zero, PTI0)
                        }
                    }

                    Store (PTI, Local0)
                    Store (Zero, Local1)
                    While (Local0)
                    {
                        If (And (Local0, One))
                        {
                            Increment (Local1)
                        }

                        ShiftRight (Local0, One, Local0)
                    }

                    Store (Decrement (Local1), NOPT)
                    Store (Zero, WTEN)
                }

                Device (PRT1)
                {
                    Name (_ADR, One)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (ODZC, One))
                        {
                            Return (Zero)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }

                    Method (DIS, 0, NotSerialized)
                    {
                        ENP (One, Zero)
                    }

                    Method (ENA, 0, NotSerialized)
                    {
                        ENP (One, One)
                    }

                    Device (ODD)
                    {
                        Name (_ADR, Zero)
                        Method (_RMV, 0, NotSerialized)
                        {
                            Return (Zero)
                        }
                    }
                }

                Device (ODDZ)
                {
                    Name (_ADR, One)
                    Name (ODPS, Zero)
                    Name (ODDB, Zero)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LAnd (LEqual (ODZC, One), LEqual (^^^SMBS.GE16, Zero)))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0xDF00, P80H)
                        If (LAnd (LEqual (ODZC, One), LEqual (^^^SMBS.GE16, Zero)))
                        {
                            If (LOr (LEqual (ODDB, One), LAnd (LEqual (ODDB, Zero), 
                                LNotEqual (IPM1, Zero))))
                            {
                                If (LOr (LEqual (VIDI, 0x78041022), LEqual (VIDI, 0x78011022)))
                                {
                                    Store (Zero, DIS1)
                                    Sleep (0x28)
                                    Store (One, ^^^SMBS.O171)
                                    Store (Zero, ^^^SMBS.E171)
                                    Sleep (0x28)
                                    Store (Zero, CST1)
                                    Sleep (One)
                                    Store (One, DDI1)
                                    Sleep (One)
                                    Store (Zero, DDI1)
                                }

                                If (LOr (LEqual (VIDI, 0x78031022), LEqual (VIDI, 0x78021022)))
                                {
                                    Store (Zero, DIS1)
                                    Sleep (0x28)
                                    Store (One, ^^^SMBS.O171)
                                    Store (Zero, ^^^SMBS.E171)
                                    Sleep (0x28)
                                    Store (Zero, CST1)
                                    Sleep (One)
                                    Store (One, DDI1)
                                    Sleep (One)
                                    Store (Zero, DDI1)
                                }
                            }
                        }

                        Store (One, ODDB)
                        Store (Zero, ODPS)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (0xDF03, P80H)
                        If (LAnd (LEqual (ODZC, One), LEqual (^^^SMBS.GE16, Zero)))
                        {
                            If (LOr (LEqual (VIDI, 0x78041022), LEqual (VIDI, 0x78011022)))
                            {
                                Sleep (0x28)
                                Store (Zero, ^^^SMBS.O171)
                                Store (Zero, ^^^SMBS.E171)
                                Sleep (0x28)
                                Store (One, DIS1)
                            }

                            If (LOr (LEqual (VIDI, 0x78031022), LEqual (VIDI, 0x78021022)))
                            {
                                Sleep (0x28)
                                Store (Zero, ^^^SMBS.O171)
                                Store (Zero, ^^^SMBS.E171)
                                Sleep (0x28)
                                Store (One, DIS1)
                            }

                            Store (Not (^^^SMBS.GE06), ^^^SMBS.G06T)
                        }

                        Store (0x03, ODPS)
                    }

                    Method (_EJ0, 1, NotSerialized)
                    {
                        _PS3 ()
                        ^^PRT1.DIS ()
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        Return (ODPS)
                    }
                }

                Device (PRT3)
                {
                    Name (_ADR, 0x03)
                    Device (ESAT)
                    {
                        Name (_ADR, Zero)
                        Method (_RMV, 0, NotSerialized)
                        {
                            Return (One)
                        }
                    }
                }
            }

            Device (IDE)
            {
                Name (_ADR, 0x00140001)
                Name (UDMT, Package (0x08)
                {
                    0x78, 
                    0x5A, 
                    0x3C, 
                    0x2D, 
                    0x1E, 
                    0x14, 
                    Zero, 
                    Zero
                })
                Name (PIOT, Package (0x06)
                {
                    0x0258, 
                    0x0186, 
                    0x010E, 
                    0xB4, 
                    0x78, 
                    Zero
                })
                Name (PITR, Package (0x06)
                {
                    0x99, 
                    0x47, 
                    0x34, 
                    0x22, 
                    0x20, 
                    0x99
                })
                Name (MDMT, Package (0x04)
                {
                    0x01E0, 
                    0x96, 
                    0x78, 
                    Zero
                })
                Name (MDTR, Package (0x04)
                {
                    0x77, 
                    0x21, 
                    0x20, 
                    0xFF
                })
                OperationRegion (IDE, PCI_Config, 0x40, 0x20)
                Field (IDE, WordAcc, NoLock, Preserve)
                {
                    PPIT,   16, 
                    SPIT,   16, 
                    PMDT,   16, 
                    SMDT,   16, 
                    PPIC,   8, 
                    SPIC,   8, 
                    PPIM,   8, 
                    SPIM,   8, 
                            Offset (0x14), 
                    PUDC,   2, 
                    SUDC,   2, 
                            Offset (0x16), 
                    PUDM,   8, 
                    SUDM,   8
                }

                Method (GETT, 1, NotSerialized)
                {
                    Store (And (Arg0, 0x0F), Local0)
                    Store (ShiftRight (Arg0, 0x04), Local1)
                    Return (Multiply (0x1E, Add (Add (Local0, One), Add (Local1, 
                        One))))
                }

                Method (GTM, 1, NotSerialized)
                {
                    CreateByteField (Arg0, Zero, PIT1)
                    CreateByteField (Arg0, One, PIT0)
                    CreateByteField (Arg0, 0x02, MDT1)
                    CreateByteField (Arg0, 0x03, MDT0)
                    CreateByteField (Arg0, 0x04, PICX)
                    CreateByteField (Arg0, 0x05, UDCX)
                    CreateByteField (Arg0, 0x06, UDMX)
                    Name (BUF, Buffer (0x14)
                    {
                        /* 0000 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x00, 0x00, 0x00, 0x00
                    })
                    CreateDWordField (BUF, Zero, PIO0)
                    CreateDWordField (BUF, 0x04, DMA0)
                    CreateDWordField (BUF, 0x08, PIO1)
                    CreateDWordField (BUF, 0x0C, DMA1)
                    CreateDWordField (BUF, 0x10, FLAG)
                    If (And (PICX, One))
                    {
                        Return (BUF)
                    }

                    Store (GETT (PIT0), PIO0)
                    Store (GETT (PIT1), PIO1)
                    If (And (UDCX, One))
                    {
                        Or (FLAG, One, FLAG)
                        Store (DerefOf (Index (UDMT, And (UDMX, 0x0F))), DMA0)
                    }
                    Else
                    {
                        If (LNotEqual (MDT0, 0xFF))
                        {
                            Store (GETT (MDT0), DMA0)
                        }
                    }

                    If (And (UDCX, 0x02))
                    {
                        Or (FLAG, 0x04, FLAG)
                        Store (DerefOf (Index (UDMT, ShiftRight (UDMX, 0x04))), DMA1)
                    }
                    Else
                    {
                        If (LNotEqual (MDT1, 0xFF))
                        {
                            Store (GETT (MDT1), DMA1)
                        }
                    }

                    Or (FLAG, 0x1A, FLAG)
                    Return (BUF)
                }

                Method (STM, 3, NotSerialized)
                {
                    CreateDWordField (Arg0, Zero, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Name (BUF, Buffer (0x07)
                    {
                        0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                    })
                    CreateByteField (BUF, Zero, PIT1)
                    CreateByteField (BUF, One, PIT0)
                    CreateByteField (BUF, 0x02, MDT1)
                    CreateByteField (BUF, 0x03, MDT0)
                    CreateByteField (BUF, 0x04, PIMX)
                    CreateByteField (BUF, 0x05, UDCX)
                    CreateByteField (BUF, 0x06, UDMX)
                    Store (Match (PIOT, MLE, PIO0, MTR, Zero, Zero), Local0)
                    Divide (Local0, 0x05, Local0)
                    Store (Match (PIOT, MLE, PIO1, MTR, Zero, Zero), Local1)
                    Divide (Local1, 0x05, Local1)
                    Store (Or (ShiftLeft (Local1, 0x04), Local0), PIMX)
                    Store (DerefOf (Index (PITR, Local0)), PIT0)
                    Store (DerefOf (Index (PITR, Local1)), PIT1)
                    If (And (FLAG, One))
                    {
                        Store (Match (UDMT, MLE, DMA0, MTR, Zero, Zero), Local0)
                        Divide (Local0, 0x06, Local0)
                        Or (UDMX, Local0, UDMX)
                        Or (UDCX, One, UDCX)
                    }
                    Else
                    {
                        If (LNotEqual (DMA0, Ones))
                        {
                            Store (Match (MDMT, MLE, DMA0, MTR, Zero, Zero), Local0)
                            Store (DerefOf (Index (MDTR, Local0)), MDT0)
                        }
                    }

                    If (And (FLAG, 0x04))
                    {
                        Store (Match (UDMT, MLE, DMA1, MTR, Zero, Zero), Local0)
                        Divide (Local0, 0x06, Local0)
                        Or (UDMX, ShiftLeft (Local0, 0x04), UDMX)
                        Or (UDCX, 0x02, UDCX)
                    }
                    Else
                    {
                        If (LNotEqual (DMA1, Ones))
                        {
                            Store (Match (MDMT, MLE, DMA1, MTR, Zero, Zero), Local0)
                            Store (DerefOf (Index (MDTR, Local0)), MDT1)
                        }
                    }

                    Return (BUF)
                }

                Method (GTF, 2, NotSerialized)
                {
                    CreateByteField (Arg1, Zero, MDT1)
                    CreateByteField (Arg1, One, MDT0)
                    CreateByteField (Arg1, 0x02, PIMX)
                    CreateByteField (Arg1, 0x03, UDCX)
                    CreateByteField (Arg1, 0x04, UDMX)
                    If (LEqual (Arg0, 0xA0))
                    {
                        Store (And (PIMX, 0x0F), Local0)
                        Store (MDT0, Local1)
                        And (UDCX, One, Local2)
                        Store (And (UDMX, 0x0F), Local3)
                    }
                    Else
                    {
                        Store (ShiftRight (PIMX, 0x04), Local0)
                        Store (MDT1, Local1)
                        And (UDCX, 0x02, Local2)
                        Store (ShiftRight (UDMX, 0x04), Local3)
                    }

                    Name (BUF, Buffer (0x0E)
                    {
                        /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF, 0x03, 
                        /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF
                    })
                    CreateByteField (BUF, One, PMOD)
                    CreateByteField (BUF, 0x08, DMOD)
                    CreateByteField (BUF, 0x05, CMDA)
                    CreateByteField (BUF, 0x0C, CMDB)
                    Store (Arg0, CMDA)
                    Store (Arg0, CMDB)
                    Or (Local0, 0x08, PMOD)
                    If (Local2)
                    {
                        Or (Local3, 0x40, DMOD)
                    }
                    Else
                    {
                        If (LNotEqual (Local1, 0xFF))
                        {
                            Store (Match (MDMT, MLE, GETT (Local1), MTR, Zero, Zero), Local4)
                            If (LLess (Local4, 0x03))
                            {
                                Or (0x20, Local4, DMOD)
                            }
                        }
                    }

                    Return (BUF)
                }

                Device (PRID)
                {
                    Name (_ADR, Zero)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, Zero, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIC)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (PPIT, VPIT)
                        Store (PMDT, VMDT)
                        Store (PPIC, VPIC)
                        Store (PUDC, VUDC)
                        Store (PUDM, VUDM)
                        Return (GTM (BUF))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, Zero, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIM)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (STM (Arg0, Arg1, Arg2), BUF)
                        Store (VPIT, PPIT)
                        Store (VMDT, PMDT)
                        Store (VPIM, PPIM)
                        Store (VUDC, PUDC)
                        Store (VUDM, PUDM)
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, Zero, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (PMDT, VMDT)
                            Store (PPIM, VPIM)
                            Store (PUDC, VUDC)
                            Store (PUDM, VUDM)
                            Return (GTF (0xA0, BUF))
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, One)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, Zero, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (PMDT, VMDT)
                            Store (PPIM, VPIM)
                            Store (PUDC, VUDC)
                            Store (PUDM, VUDM)
                            Return (GTF (0xB0, BUF))
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, One)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, Zero, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIC)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (SPIT, VPIT)
                        Store (SMDT, VMDT)
                        Store (SPIC, VPIC)
                        Store (SUDC, VUDC)
                        Store (SUDM, VUDM)
                        Return (GTM (BUF))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, Zero, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIM)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (STM (Arg0, Arg1, Arg2), BUF)
                        Store (VPIT, SPIT)
                        Store (VMDT, SMDT)
                        Store (VPIM, SPIM)
                        Store (VUDC, SUDC)
                        Store (VUDM, SUDM)
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, Zero, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (SMDT, VMDT)
                            Store (SPIM, VPIM)
                            Store (SUDC, VUDC)
                            Store (SUDM, VUDM)
                            Return (GTF (0xA0, BUF))
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, One)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, Zero, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (SMDT, VMDT)
                            Store (SPIM, VPIM)
                            Store (SUDC, VUDC)
                            Store (SUDM, VUDM)
                            Return (GTF (0xB0, BUF))
                        }
                    }
                }
            }

            Name (AFCB, Buffer (0xB8) {})
            Name (CALB, Buffer (0x05) {})
            Name (XUPC, Package (0x04)
            {
                0xFF, 
                0xFF, 
                Zero, 
                Zero
            })
            Name (XPLD, Buffer (0x10)
            {
                /* 0000 */    0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                /* 0008 */    0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
            })
            Scope (OHC1)
            {
                Device (RHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Method (_UPC, 0, Serialized)
                        {
                            Return (XUPC)
                        }

                        Method (_PLD, 0, Serialized)
                        {
                            Return (XPLD)
                        }
                    }

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

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Method (_UPC, 0, Serialized)
                        {
                            Return (XUPC)
                        }

                        Method (_PLD, 0, Serialized)
                        {
                            Return (XPLD)
                        }
                    }
                }
            }

            Scope (EHC1)
            {
                Device (RHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Method (_UPC, 0, Serialized)
                        {
                            Return (XUPC)
                        }

                        Method (_PLD, 0, Serialized)
                        {
                            Return (XPLD)
                        }
                    }

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

                    Device (PRT4)
                    {
                        Name (_ADR, 0x04)
                        Method (_UPC, 0, Serialized)
                        {
                            Return (XUPC)
                        }

                        Method (_PLD, 0, Serialized)
                        {
                            Return (XPLD)
                        }
                    }
                }
            }

            Scope (OHC4)
            {
                Device (RHUB)
                {
                    Name (_ADR, Zero)
                    Device (PRT1)
                    {
                        Name (_ADR, One)
                        Method (_UPC, 0, Serialized)
                        {
                            Return (XUPC)
                        }

                        Method (_PLD, 0, Serialized)
                        {
                            Return (XPLD)
                        }
                    }

                    Device (PRT2)
                    {
                        Name (_ADR, 0x02)
                        Method (_UPC, 0, Serialized)
                        {
                            Return (XUPC)
                        }

                        Method (_PLD, 0, Serialized)
                        {
                            Return (XPLD)
                        }
                    }
                }
            }

            Scope (\_SB.PCI0)
            {
                Method (CHGS, 1, Serialized)
                {
                    Store (^LPC0.EC.BCHG (Arg0), Local0)
                    Return (Local0)
                }

                Name (BSLF, Zero)
                Method (BATS, 1, Serialized)
                {
                    If (Arg0)
                    {
                        Store (One, BSLF)
                    }
                    Else
                    {
                        Store (Zero, BSLF)
                    }
                }

                Device (BAT0)
                {
                    Name (_HID, EisaId ("PNP0C0A"))
                    Name (_UID, One)
                    Name (_PCL, Package (0x01)
                    {
                        PCI0
                    })
                    Name (LOW2, 0x012C)
                    Name (DVOT, 0x0D)
                    Name (PUNT, One)
                    Name (LFCC, 0x1770)
                    Name (NBIF, Package (0x0D)
                    {
                        Zero, 
                        Ones, 
                        Ones, 
                        One, 
                        Ones, 
                        Ones, 
                        Ones, 
                        Ones, 
                        Ones, 
                        "", 
                        "", 
                        "", 
                        ""
                    })
                    Name (PBIF, Package (0x0D)
                    {
                        One, 
                        0x1770, 
                        0x1770, 
                        One, 
                        0x39D0, 
                        0x0258, 
                        0x012C, 
                        0x3C, 
                        0x3C, 
                        "M3N", 
                        "  ", 
                        "LIon", 
                        "TKBSS"
                    })
                    Name (PBST, Package (0x04)
                    {
                        Zero, 
                        Ones, 
                        Ones, 
                        Ones
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (^^LPC0.EC.BATP (Zero))
                        {
                            Return (0x1F)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }

                    Method (FBIF, 5, NotSerialized)
                    {
                        Store (Arg0, PUNT)
                        Store (Arg1, Local1)
                        Store (Arg2, Local2)
                        If (LEqual (PUNT, Zero))
                        {
                            Multiply (Local1, 0x0A, Local1)
                            Multiply (Local2, 0x0A, Local2)
                        }

                        Store (Arg0, Index (PBIF, Zero))
                        Store (Local1, Index (PBIF, One))
                        Store (Local2, Index (PBIF, 0x02))
                        Store (Local2, LFCC)
                        Store (Arg3, Index (PBIF, 0x03))
                        Store (Arg4, Index (PBIF, 0x04))
                        If (LLess (OSTB, 0x40))
                        {
                            Divide (Local1, 0x64, Local3, Local5)
                        }
                        Else
                        {
                            Divide (Local2, 0x64, Local3, Local5)
                        }

                        Multiply (Local5, 0x0A, Local6)
                        Store (Local6, Index (PBIF, 0x05))
                        Multiply (Local5, One, 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, Zero))
                            Multiply (DerefOf (Index (PBIF, One)), DVOT, Index (PBIF, One
                                ))
                            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, Serialized)
                    {
                        If (LNot (^^LPC0.EC.BATP (Zero)))
                        {
                            Return (NBIF)
                        }

                        If (LEqual (^^LPC0.EC.GBTT (Zero), 0xFF))
                        {
                            Return (NBIF)
                        }

                        BATS (Zero)
                        Store (^^LPC0.EC.BIF9 (), Index (PBIF, 0x09))
                        Store (^^LPC0.EC.BIF0 (), Local0)
                        Store (^^LPC0.EC.BIF1 (), Local1)
                        Store (^^LPC0.EC.BIF2 (), Local2)
                        Store (^^LPC0.EC.BIF3 (), Local3)
                        Store (^^LPC0.EC.BIF4 (), Local4)
                        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, Zero))
                        {
                            Multiply (Local2, 0x0A, Local2)
                        }

                        Store (Local2, LFCC)
                        Return (PBIF)
                    }

                    Method (FBST, 4, NotSerialized)
                    {
                        And (Arg1, 0xFFFF, Local1)
                        Store (Zero, Local0)
                        If (^^LPC0.EC.ACAP ())
                        {
                            Store (One, Local0)
                        }

                        If (Local0)
                        {
                            If (CHGS (Zero))
                            {
                                Store (0x02, Local0)
                            }
                            Else
                            {
                                Store (Zero, Local0)
                            }
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        And (Arg0, 0x0300, Local2)
                        If (Local2)
                        {
                            ShiftLeft (One, 0x02, Local2)
                            Or (Local0, Local2, Local0)
                        }

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

                        Store (Arg2, Local2)
                        If (LEqual (And (^^^VALZ.PKFG, 0x07), Zero))
                        {
                            If (LEqual (And (Local0, 0x03), Zero))
                            {
                                Store (LFCC, Local2)
                            }
                        }

                        If (LEqual (PUNT, Zero))
                        {
                            Multiply (Local1, DVOT, Local1)
                            Multiply (Local2, 0x0A, Local2)
                        }

                        And (Local0, 0x02, Local3)
                        If (LNot (Local3))
                        {
                            Subtract (LFCC, Local2, Local3)
                            Divide (LFCC, 0xC8, Local4, Local5)
                            If (LLess (Local3, Local5))
                            {
                                Store (LFCC, Local2)
                            }
                        }
                        Else
                        {
                            Divide (LFCC, 0xC8, Local4, Local5)
                            Subtract (LFCC, Local5, Local4)
                            Subtract (Local4, One, Local4)
                            If (LGreater (Local2, Local4))
                            {
                                Store (Local4, Local2)
                            }
                        }

                        If (LNot (^^LPC0.EC.ACAP ()))
                        {
                            Divide (Local2, 0x0A, Local3, Local4)
                            If (LLess (Local1, Local4))
                            {
                                Store (Local4, Local1)
                            }
                        }

                        Store (Local0, Index (PBST, Zero))
                        Store (Local1, Index (PBST, One))
                        Store (Local2, Index (PBST, 0x02))
                        Store (Arg3, Index (PBST, 0x03))
                    }

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

                    Method (_BST, 0, Serialized)
                    {
                        Store (Zero, Index (PBST, Zero))
                        Store (Ones, Index (PBST, One))
                        Store (Ones, Index (PBST, 0x02))
                        Store (Ones, Index (PBST, 0x03))
                        If (LNot (^^LPC0.EC.BATP (Zero)))
                        {
                            Return (PBST)
                        }

                        If (LEqual (^^LPC0.EC.GBTT (Zero), 0xFF))
                        {
                            Return (PBST)
                        }

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

                        BATS (Zero)
                        Store (^^LPC0.EC.BSTS (), Local0)
                        Store (^^LPC0.EC.BCRT (), Local1)
                        Store (^^LPC0.EC.BRCP (), Local2)
                        Store (^^LPC0.EC.BVOT (), Local3)
                        If (LNotEqual (Local0, Ones))
                        {
                            If (LNotEqual (Local1, Ones))
                            {
                                If (LNotEqual (Local2, Ones))
                                {
                                    If (LNotEqual (Local3, Ones))
                                    {
                                        FBST (Local0, Local1, Local2, Local3)
                                        CBST ()
                                    }
                                }
                            }
                        }

                        Return (PBST)
                    }
                }
            }

            Scope (\_SB.PCI0)
            {
                Device (AC0)
                {
                    Name (_HID, "ACPI0003")
                    Name (XX00, Buffer (0x03) {})
                    Method (_PSR, 0, NotSerialized)
                    {
                        Store (Zero, Local0)
                        If (^^LPC0.EC.ECAV ())
                        {
                            Acquire (^^LPC0.PSMX, 0xFFFF)
                            Store (^^LPC0.EC.EPWS, Local0)
                            And (Local0, One, Local0)
                            Release (^^LPC0.PSMX)
                        }

                        CreateWordField (XX00, Zero, SSZE)
                        CreateByteField (XX00, 0x02, ACST)
                        Store (0x03, SSZE)
                        If (Local0)
                        {
                            ^^VGA.AFN4 (One)
                            Store (Zero, ACST)
                        }
                        Else
                        {
                            ^^VGA.AFN4 (0x02)
                            Store (One, ACST)
                        }

                        ALIB (One, XX00)
                        Return (Local0)
                    }

                    Name (_PCL, Package (0x01)
                    {
                        PCI0
                    })
                }
            }
        }

        OperationRegion (PIRQ, SystemIO, 0x0C00, 0x02)
        Field (PIRQ, ByteAcc, NoLock, Preserve)
        {
            PIDX,   8, 
            PDAT,   8
        }

        IndexField (PIDX, PDAT, ByteAcc, NoLock, Preserve)
        {
            PIRA,   8, 
            PIRB,   8, 
            PIRC,   8, 
            PIRD,   8, 
            PIRE,   8, 
            PIRF,   8, 
            PIRG,   8, 
            PIRH,   8, 
                    Offset (0x10), 
            PIRS,   8, 
                    Offset (0x13), 
            HDAD,   8, 
                    Offset (0x15), 
            GEC,    8, 
                    Offset (0x30), 
            USB1,   8, 
            USB2,   8, 
            USB3,   8, 
            USB4,   8, 
            USB5,   8, 
            USB6,   8, 
            USB7,   8, 
                    Offset (0x40), 
            IDE,    8, 
            SATA,   8, 
                    Offset (0x50), 
            GPP0,   8, 
            GPP1,   8, 
            GPP2,   8, 
            GPP3,   8
        }

        OperationRegion (KBDD, SystemIO, 0x64, One)
        Field (KBDD, ByteAcc, NoLock, Preserve)
        {
            PD64,   8
        }

        Method (DSPI, 0, NotSerialized)
        {
            INTA (0x1F)
            INTB (0x1F)
            INTC (0x1F)
            INTD (0x1F)
            Store (PD64, Local1)
            Store (0x1F, PIRE)
            Store (0x1F, PIRF)
            Store (0x1F, PIRG)
            Store (0x1F, PIRH)
        }

        Method (INTA, 1, NotSerialized)
        {
            Store (Arg0, PIRA)
            Store (Arg0, HDAD)
            Store (Arg0, GEC)
            Store (Arg0, GPP0)
            Store (Arg0, GPP0)
        }

        Method (INTB, 1, NotSerialized)
        {
            Store (Arg0, PIRB)
            Store (Arg0, USB2)
            Store (Arg0, USB4)
            Store (Arg0, USB6)
            Store (Arg0, GPP1)
            Store (Arg0, IDE)
        }

        Method (INTC, 1, NotSerialized)
        {
            Store (Arg0, PIRC)
            Store (Arg0, USB1)
            Store (Arg0, USB3)
            Store (Arg0, USB5)
            Store (Arg0, USB7)
            Store (Arg0, GPP2)
        }

        Method (INTD, 1, NotSerialized)
        {
            Store (Arg0, PIRD)
            Store (Arg0, SATA)
            Store (Arg0, GPP3)
        }

        Name (PRS1, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {3,4,5,7,10,11,12,14,15}
        })
        Name (BUFA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {15}
        })
        Name (IPRA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {5,10,11}
        })
        Name (IPRB, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {5,10,11}
        })
        Name (IPRC, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {5,10,11}
        })
        Name (IPRD, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {5,10,11}
        })
        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, One)
            Method (_STA, 0, NotSerialized)
            {
                If (PIRA)
                {
                    Return (0x0B)
                }
                Else
                {
                    Return (0x09)
                }
            }

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

            Method (_DIS, 0, NotSerialized)
            {
                INTA (0x1F)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRA, IRQX)
                Return (BUFA)
            }

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

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

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

            Method (_DIS, 0, NotSerialized)
            {
                INTB (0x1F)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRB, IRQX)
                Return (BUFA)
            }

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

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

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

            Method (_DIS, 0, NotSerialized)
            {
                INTC (0x1F)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRC, IRQX)
                Return (BUFA)
            }

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

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

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

            Method (_DIS, 0, NotSerialized)
            {
                INTD (0x1F)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRD, IRQX)
                Return (BUFA)
            }

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

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

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

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x1F, PIRE)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRE, IRQX)
                Return (BUFA)
            }

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

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

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

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x1F, PIRF)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRF, IRQX)
                Return (BUFA)
            }

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

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

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

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x1F, PIRG)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRG, IRQX)
                Return (BUFA)
            }

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

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

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

            Method (_DIS, 0, NotSerialized)
            {
                Store (0x1F, PIRH)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, One, IRQX)
                ShiftLeft (One, PIRH, IRQX)
                Return (BUFA)
            }

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

        Mutex (LSMI, 0x00)
        Method (GSMI, 1, NotSerialized)
        {
            Acquire (LSMI, 0xFFFF)
            Store (Arg0, APMD)
            Store (0xE4, APMC)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Release (LSMI)
        }

        Method (S80H, 1, NotSerialized)
        {
            Acquire (LSMI, 0xFFFF)
            Store (Arg0, APMD)
            Store (0xE5, APMC)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Release (LSMI)
        }

        Method (BSMI, 1, NotSerialized)
        {
            Acquire (LSMI, 0xFFFF)
            Store (Arg0, APMC)
            Stall (0xFF)
            Release (LSMI)
        }

        Method (KSMI, 1, NotSerialized)
        {
            Store (Arg0, APMD)
            Store (0xBE, APMC)
            Stall (0xFF)
        }

        Scope (\_SB)
        {
            Method (ALIC, 2, NotSerialized)
            {
                If (LEqual (Arg0, 0x07))
                {
                    If (LEqual (Arg1, Zero))
                    {
                        Store (Zero, ^PCI0.SMBS.O053)
                        Store (Zero, ^PCI0.SMBS.E053)
                    }
                    Else
                    {
                        Store (One, ^PCI0.SMBS.O053)
                        Store (Zero, ^PCI0.SMBS.E053)
                    }
                }

                If (LEqual (Arg0, 0x04))
                {
                    If (LEqual (Arg1, Zero))
                    {
                        Store (Zero, ^PCI0.SMBS.O025)
                        Store (Zero, ^PCI0.SMBS.E025)
                    }
                    Else
                    {
                        Store (One, ^PCI0.SMBS.O025)
                        Store (Zero, ^PCI0.SMBS.E025)
                    }
                }

                If (LEqual (Arg0, 0x05))
                {
                    If (LEqual (Arg1, Zero))
                    {
                        Store (Zero, ^PCI0.SMBS.O000)
                        Store (Zero, ^PCI0.SMBS.E000)
                    }
                    Else
                    {
                        Store (One, ^PCI0.SMBS.O000)
                        Store (Zero, ^PCI0.SMBS.E000)
                    }
                }

                If (LEqual (Arg0, 0x06))
                {
                    If (LEqual (Arg1, Zero))
                    {
                        Store (Zero, ^PCI0.SMBS.O027)
                        Store (Zero, ^PCI0.SMBS.E027)
                    }
                    Else
                    {
                        Store (One, ^PCI0.SMBS.O027)
                        Store (Zero, ^PCI0.SMBS.E027)
                    }
                }
            }
        }

        Scope (\_SB)
        {
            Device (LID)
            {
                Name (_HID, EisaId ("PNP0C0D"))
                Method (_LID, 0, NotSerialized)
                {
                    If (LEqual (^^PCI0.LPC0.EC.ECFL, One))
                    {
                        Store (^^PCI0.LPC0.EC.RPIN (0x07, 0x02), Local0)
                        If (LOr (LEqual (Local0, Ones), LEqual (Local0, One)))
                        {
                            Notify (PCI0, Zero)
                            Return (One)
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }
                    Else
                    {
                        Notify (PCI0, Zero)
                        Return (One)
                    }
                }

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

        Scope (\_GPE)
        {
            Method (_L16, 0, NotSerialized)
            {
                Store (And (\_SB.PCI0.SMBS.GE22, One), Local0)
                If (\_SB.PCI0.SMBS.G22T)
                {
                    Sleep (0x14)
                    If (And (Local0, One))
                    {
                        Store (Zero, \_SB.PCI0.SMBS.G22T)
                        Store (0xC001, P80H)
                    }
                }
                Else
                {
                    Sleep (0x14)
                    If (LNot (And (Local0, One)))
                    {
                        Store (One, \_SB.PCI0.SMBS.G22T)
                        Store (0xC000, P80H)
                    }
                }

                Notify (\_SB.LID, 0x80)
            }
        }

        Name (ATKP, Zero)
        Name (CELT, One)
        Device (VALZ)
        {
            Name (_HID, EisaId ("TOS1900"))
            Method (_STA, 0, NotSerialized)
            {
                If (LLess (OSTB, 0x40))
                {
                    Return (Zero)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Name (_DDN, "VALZeneral")
            Name (HKEV, 0x0B)
            Name (OSMD, Zero)
            Name (ENFG, Zero)
            Mutex (MUEV, 0x00)
            Name (EVCT, Zero)
            Name (EVCD, Package (0x64) {})
            Name (RETP, Package (0x06) {})
            Name (USFN, Package (0x06)
            {
                0x8000, 
                Zero, 
                Zero, 
                Zero, 
                Zero, 
                Zero
            })
            Name (NULP, Package (0x06)
            {
                Zero, 
                Zero, 
                Zero, 
                Zero, 
                Zero, 
                Zero
            })
            Name (BRTL, Zero)
            Name (BRIL, Zero)
            Name (STA5, Zero)
            Name (BSY5, Zero)
            Name (BATV, Zero)
            Name (CRFR, Zero)
            Name (FADR, Zero)
            Name (ST06, Zero)
            Name (ST08, Zero)
            Name (ST09, Zero)
            Name (ST10, Zero)
            Name (ST11, Zero)
            Name (ST12, Zero)
            Name (ST16, Zero)
            Name (CNT1, Zero)
            Name (CNT2, Zero)
            Name (CNT3, Zero)
            Name (CNT4, Zero)
            Name (CNT5, Zero)
            Name (BACR, Zero)
            Name (BATP, Zero)
            Name (REFM, 0x10)
            Name (TIMC, Zero)
            Name (GCV1, Zero)
            Name (ACAV, Zero)
            Name (ACAC, Zero)
            Name (GCV2, Zero)
            Name (GBS1, Zero)
            Name (GBS2, Zero)
            Name (GBS3, Zero)
            Name (GBS4, Zero)
            Name (GBS5, Zero)
            Name (CTOV, Zero)
            Name (CTO1, Zero)
            Name (PCCF, Zero)
            Name (CTPN, Buffer (0x0C) {})
            Name (NNAM, Buffer (0x0C) {})
            Name (MDAT, Buffer (0x02) {})
            Name (SNUM, Buffer (0x02) {})
            Name (TST0, Package (0x06)
            {
                Buffer (0x1C) {}, 
                Zero, 
                Zero, 
                Zero, 
                Zero, 
                Zero
            })
            Name (TST1, Package (0x06)
            {
                "0000000000000000000000000000", 
                Zero, 
                Zero, 
                Zero, 
                Zero, 
                Zero
            })
            Name (HMBB, Buffer (0x1C) {})
            Name (HMTP, Buffer (0x1C) {})
            Name (CYCT, Zero)
            Name (EVCS, Zero)
            Name (HPCS, Zero)
            Name (TEMP, Zero)
            Name (INDX, 0xFF)
            Name (LCDS, One)
            Name (LLCD, Zero)
            Name (FRST, One)
            Name (MSRV, Zero)
            Name (AVR0, Zero)
            Name (AVR1, Zero)
            Name (AVR2, Zero)
            Name (AVR3, Zero)
            Name (AVR4, Zero)
            Name (AVR5, Zero)
            Name (AVR6, Zero)
            Name (AVR7, Zero)
            Name (AVR8, Zero)
            Name (AVR9, Zero)
            Name (AV10, Zero)
            Name (AV11, Zero)
            Name (AV12, Zero)
            Name (AV13, Zero)
            Name (AV14, Zero)
            Name (AV15, Zero)
            Name (ISFT, One)
            Name (ISAC, Zero)
            Name (ISDC, Zero)
            Name (ENLE, Zero)
            Name (USCF, Zero)
            Name (UDT1, Zero)
            Name (UDT2, Zero)
            Name (SCPT, Zero)
            Name (BLIM, 0x0A)
            Name (BSCF, 0x04)
            Name (UPSW, One)
            Name (STMD, Zero)
            Name (CMMD, Zero)
            Name (PSMD, Zero)
            Name (IMMD, Zero)
            Name (IPMD, Zero)
            Name (RLMD, Zero)
            Name (PKFG, Zero)
            Name (STTD, Zero)
            Name (STTH, Zero)
            Name (STTM, Zero)
            Name (STTS, Zero)
            Name (STPD, Zero)
            Name (STPH, Zero)
            Name (STPM, Zero)
            Name (STPS, Zero)
            Method (_INI, 0, Serialized)
            {
            }

            Method (VWAK, 1, Serialized)
            {
            }

            Method (VPTS, 1, Serialized)
            {
            }

            Method (FKMC, 1, Serialized)
            {
                If (Arg0)
                {
                    Or (HKEV, 0x10, HKEV)
                    ^^PCI0.LPC0.EC.ECXT (0xC0, One, Zero, Zero, Zero, Zero)
                }
                Else
                {
                    And (HKEV, 0xEF, HKEV)
                    ^^PCI0.LPC0.EC.ECXT (0xC0, Zero, Zero, Zero, Zero, Zero)
                }
            }

            Method (ENAB, 0, Serialized)
            {
                Store (One, OSMD)
                Store (^^PCI0.LPC0.EC.RRAM (0x07B0), Local0)
                ^^PCI0.LPC0.EC.WRAM (0x07B0, Or (Local0, One))
                If (LEqual (KBTY, Zero))
                {
                    ^^PCI0.LPC0.EC.ECXT (0xC0, 0x10, Zero, Zero, Zero, Zero)
                }
                Else
                {
                    If (LEqual (FNKS, One))
                    {
                        FKMC (One)
                    }
                    Else
                    {
                        FKMC (Zero)
                    }
                }

                Store (One, ENFG)
            }

            Method (PCTP, 1, Serialized)
            {
                Store (Package (0x04)
                    {
                        Zero, 
                        Zero, 
                        Zero, 
                        Zero
                    }, Local0)
                Add (Arg0, RTSS, Local1)
                Divide (Local1, 0x3C, Local1, Local2)
                Add (Local2, RTCM, Local2)
                Divide (Local2, 0x3C, Local2, Local3)
                Add (Local3, RTCH, Local3)
                Divide (Local3, 0x18, Local3, Local4)
                Add (Local4, RTCD, Local4)
                Store (Local1, Index (Local0, Zero))
                Store (Local2, Index (Local0, One))
                Store (Local3, Index (Local0, 0x02))
                Store (Local4, Index (Local0, 0x03))
                Return (Local0)
            }

            Method (PCAR, 1, Serialized)
            {
                Store (PCTP (Arg0), Local0)
                Store (DerefOf (Index (Local0, Zero)), STTS)
                Store (DerefOf (Index (Local0, One)), STTM)
                Store (DerefOf (Index (Local0, 0x02)), STTH)
                Store (DerefOf (Index (Local0, 0x03)), STTD)
                If (LGreater (STTD, RTCD))
                {
                    Store (0x04, STTD)
                }
                Else
                {
                    Store (0x02, STTD)
                }
            }

            Method (PCAP, 1, Serialized)
            {
                Store (PCTP (Arg0), Local0)
                Store (DerefOf (Index (Local0, Zero)), STPS)
                Store (DerefOf (Index (Local0, One)), STPM)
                Store (DerefOf (Index (Local0, 0x02)), STPH)
                Store (DerefOf (Index (Local0, 0x03)), STPD)
                If (LGreater (STPD, RTCD))
                {
                    Store (0x04, STPD)
                }
                Else
                {
                    Store (0x02, STPD)
                }
            }

            Method (T2SC, 3, Serialized)
            {
                Multiply (Arg0, 0x3C, Local0)
                Add (Local0, Arg1, Local0)
                Multiply (Local0, 0x3C, Local0)
                Add (Local0, Arg2, Local0)
                Return (Local0)
            }

            Method (SPFC, 6, Serialized)
            {
                Name (_T_6, Zero)
                Name (_T_5, Zero)
                Name (_T_4, Zero)
                Name (_T_3, Zero)
                Name (_T_2, Zero)
                Name (_T_1, Zero)
                Name (_T_0, Zero)
                Store (One, OSMD)
                CopyObject (NULP, RETP)
                If (LEqual (CMST (Arg0, Arg1, Arg2, Arg3, Arg4, Arg5), Zero))
                {
                    Return (USFN)
                }

                Store (Zero, Local0)
                Store (Zero, Local1)
                Store (Zero, Local2)
                Store (Zero, Local3)
                If (ISFT)
                {
                    PINT ()
                    Store (Zero, ISFT)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0x2A)))
                {
                    Store (Zero, Index (RETP, Zero))
                    GBNL ()
                    Store (BRIL, Index (RETP, 0x02))
                    Store (0x07, Local0)
                    ShiftLeft (Local0, 0x0D, Local0)
                    Store (Local0, Index (RETP, 0x03))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0x42)))
                {
                    If (LEqual (ToInteger (Arg2), One))
                    {
                        Store (One, REFM)
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg2), 0x10))
                    {
                        Store (0x10, REFM)
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (0x8300, Index (RETP, Zero))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0x9F)))
                {
                    Store (0xFE00, SWMF)
                    Store (0x9F, SWSF)
                    If (LEqual (ToInteger (Arg2), Zero))
                    {
                        Store (Zero, Index (RETP, Zero))
                        BSMI (0xD5)
                        If (LEqual (PHNV, 0xFFFF))
                        {
                            Store (Zero, PHNV)
                        }

                        Store (PHNV, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg2), 0xFFFF))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x0200, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    Store (0x8300, Index (RETP, Zero))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0x9F)))
                {
                    Store (0xFF00, SWMF)
                    Store (0x9F, SWSF)
                    If (LEqual (ToInteger (Arg2), Zero))
                    {
                        Store (ToInteger (Arg3), Local0)
                        Store (Local0, PHNV)
                        BSMI (0xD5)
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                    Else
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xA1)))
                {
                    If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                        ToInteger (Arg5), One)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg2), 0x02))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), Zero))
                    {
                        Store (Zero, Index (RETP, Zero))
                        If (DCPF)
                        {
                            Store (Zero, Local0)
                            Store (Zero, Local1)
                            Store (^^PCI0.LPC0.EC.BD26, Local0)
                            ShiftLeft (Local0, 0x08, Local0)
                            Or (Local0, Local1, Local1)
                            Store (^^PCI0.LPC0.EC.BD25, Local0)
                            Or (Local0, Local1, Local1)
                            Divide (Local1, 0x64, Local0, Local1)
                            Store (Local1, BATV)
                        }
                        Else
                        {
                            Store (0xFF, BATV)
                        }

                        Store (One, STA5)
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), One))
                    {
                        If (LEqual (STA5, Zero))
                        {
                            Store (0x8D50, Index (RETP, Zero))
                            Return (RETP)
                        }
                        Else
                        {
                            Store (Zero, Index (RETP, Zero))
                            Store (BATV, Index (RETP, 0x02))
                            Store (Zero, STA5)
                            Return (RETP)
                        }
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xA2)))
                {
                    If (LEqual (ToInteger (Arg2), One))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                        ToInteger (Arg5), One)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), Zero))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (^^PCI0.LPC0.EC.BD24, Local0)
                        ShiftLeft (Local0, 0x08, Local0)
                        Or (Local0, Local1, Local1)
                        Store (^^PCI0.LPC0.EC.BD23, Local0)
                        Or (Local0, Local1, Local1)
                        If (LNotEqual (Local1, Zero))
                        {
                            Subtract (0xFFFF, Local1, Local1)
                            If (LNotEqual (Local1, Zero))
                            {
                                Divide (0x000E4000, Local1, Local0, Local1)
                            }
                        }

                        Store (Local1, CRFR)
                        Store (One, ST06)
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), One))
                    {
                        If (LEqual (ST06, Zero))
                        {
                            Store (0x8D50, Index (RETP, Zero))
                            Return (RETP)
                        }
                        Else
                        {
                            If (LEqual (ToInteger (Arg3), Zero))
                            {
                                Store (Zero, Index (RETP, Zero))
                                Store (CRFR, Index (RETP, 0x02))
                                Store (Zero, ST06)
                                Return (RETP)
                            }

                            If (LEqual (ToInteger (Arg3), One))
                            {
                                Store (Zero, Index (RETP, Zero))
                                Store (CRFR, Index (RETP, 0x02))
                                Store (0x1209, Index (RETP, 0x03))
                                Store (Zero, ST06)
                                Return (RETP)
                            }
                        }
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xA7)))
                {
                    If (LAnd (LEqual (ToInteger (Arg2), Zero), LEqual (ToInteger (Arg3
                        ), Zero)))
                    {
                        If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                            ToInteger (Arg5), One)))
                        {
                            Store (0x8300, Index (RETP, Zero))
                            Return (RETP)
                        }

                        If (LEqual (ToInteger (Arg5), Zero))
                        {
                            Store (Zero, Index (RETP, Zero))
                            Store (Zero, Local0)
                            Store (Zero, Local1)
                            Store (Zero, Local2)
                            Store (Zero, Local3)
                            Store (0xFF, Local0)
                            If (LOr (LEqual (^^PCI0.VGA.SDID, 0x3B), LEqual (^^PCI0.VGA.SDID, 0x49)))
                            {
                                Store (^^PCI0.LPC0.EC.BD22, Local0)
                            }

                            ShiftLeft (Local0, 0x18, Local0)
                            Or (Local0, Local1, Local1)
                            Store (Zero, Local0)
                            ShiftLeft (Local0, 0x10, Local0)
                            Or (Local0, Local1, Local1)
                            Store (^^PCI0.LPC0.EC.BD21, Local0)
                            ShiftLeft (Local0, 0x08, Local0)
                            Or (Local0, Local1, Local1)
                            If (ACPF)
                            {
                                If (LEqual (And (PKFG, One), Zero))
                                {
                                    Store (^^PCI0.LPC0.EC.BD1D, Local0)
                                    ShiftLeft (Local0, 0x08, Local0)
                                    Or (Local0, Local2, Local2)
                                    Store (^^PCI0.LPC0.EC.BD1C, Local0)
                                    Or (Local0, Local2, Local2)
                                    Multiply (Local2, 0x57, Local2)
                                    Divide (Local2, 0x64, Local3, Local2)
                                    Store (Local2, ACAV)
                                }
                                Else
                                {
                                    Store (0xFF, ACAV)
                                }
                            }
                            Else
                            {
                                Store (0xFF, ACAV)
                            }

                            Or (ACAV, Local1, Local1)
                            Store (Local1, GCV1)
                            Store (One, ST08)
                            Return (RETP)
                        }

                        If (LEqual (ToInteger (Arg5), One))
                        {
                            If (LEqual (ST08, Zero))
                            {
                                Store (0x8D50, Index (RETP, Zero))
                                Return (RETP)
                            }
                            Else
                            {
                                Store (Zero, Index (RETP, Zero))
                                Store (Zero, Local0)
                                Store (Zero, Local1)
                                Store (Zero, Local2)
                                Store (Zero, Local3)
                                ShiftLeft (Local0, 0x18, Local0)
                                Or (Local0, Local1, Local1)
                                If (ACPF)
                                {
                                    If (LEqual (And (PKFG, One), Zero))
                                    {
                                        Store (^^PCI0.LPC0.EC.BD1B, Local0)
                                        ShiftLeft (Local0, 0x08, Local0)
                                        Or (Local0, Local2, Local2)
                                        Store (^^PCI0.LPC0.EC.BD1A, Local0)
                                        Or (Local0, Local2, Local2)
                                        Store (AVR1, AVR0)
                                        Store (AVR2, AVR1)
                                        Store (AVR3, AVR2)
                                        Store (AVR4, AVR3)
                                        Store (AVR5, AVR4)
                                        Store (AVR6, AVR5)
                                        Store (AVR7, AVR6)
                                        Store (AVR8, AVR7)
                                        Store (AVR9, AVR8)
                                        Store (Local2, AVR9)
                                        Store (Zero, Local2)
                                        Add (AVR0, AVR1, Local2)
                                        Add (AVR2, Local2, Local2)
                                        Add (AVR3, Local2, Local2)
                                        Add (AVR4, Local2, Local2)
                                        Add (AVR5, Local2, Local2)
                                        Add (AVR6, Local2, Local2)
                                        Add (AVR7, Local2, Local2)
                                        Add (AVR8, Local2, Local2)
                                        Add (AVR9, Local2, Local2)
                                        Divide (Local2, 0x0A, Local3, Local2)
                                        Multiply (0x101D, Local2, Local2)
                                        Divide (Local2, 0x40, Local3, Local2)
                                        Store (Local2, ACAC)
                                    }
                                    Else
                                    {
                                        Store (0xFFFF, ACAC)
                                    }
                                }
                                Else
                                {
                                    Store (0xFFFF, ACAC)
                                }

                                Or (ACAC, Local1, Local1)
                                Store (0x78, Local2)
                                ShiftLeft (Local2, 0x10, Local2)
                                Or (Local2, Local1, Local1)
                                Store (Local1, GCV2)
                                Store (GCV1, Index (RETP, 0x02))
                                Store (GCV2, Index (RETP, 0x03))
                                Store (Zero, ST08)
                                Return (RETP)
                            }
                        }
                    }
                }

                If (LAnd (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (
                    Arg1), 0xA8)), LEqual (ToInteger (Arg4), 0x98)))
                {
                    If (LEqual (ToInteger (Arg2), 0x02))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                        ToInteger (Arg5), One)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), Zero))
                    {
                        Store (Zero, Index (RETP, Zero))
                        If (DCPF)
                        {
                            Store (^^PCI0.LPC0.EC.BD30, Local0)
                            ShiftLeft (Local0, 0x08, Local0)
                            Or (Local0, Local1, Local1)
                            Store (^^PCI0.LPC0.EC.BD2F, Local0)
                            Or (Local0, Local1, Local1)
                            If (LGreaterEqual (Local1, 0x8000))
                            {
                                Subtract (0xFFFF, Local1, Local1)
                                Add (Local1, One, Local1)
                            }

                            Store (Local1, BACR)
                            Store (Zero, Local0)
                            Store (Zero, Local1)
                            Store (^^PCI0.LPC0.EC.BD32, Local0)
                            ShiftLeft (Local0, 0x08, Local0)
                            Or (Local0, Local1, Local1)
                            Store (^^PCI0.LPC0.EC.BD31, Local0)
                            Or (Local0, Local1, Local1)
                            Subtract (Local1, 0x0AAA, Local1)
                            Divide (Local1, 0x0A, Local3, Local1)
                            Store (Local1, BATP)
                        }
                        Else
                        {
                            Store (0xFFFF, BACR)
                            Store (0xFF, BATP)
                        }

                        Store (One, ST09)
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), One))
                    {
                        If (LEqual (ST09, Zero))
                        {
                            Store (0x8D50, Index (RETP, Zero))
                            Return (RETP)
                        }
                        Else
                        {
                            Store (Zero, Index (RETP, Zero))
                            Store (BACR, Index (RETP, 0x02))
                            Store (BATP, Index (RETP, 0x03))
                            Store (Zero, ST09)
                            Return (RETP)
                        }
                    }
                }

                If (LAnd (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (
                    Arg1), 0xA8)), LEqual (ToInteger (Arg4), 0x9A)))
                {
                    If (LEqual (ToInteger (Arg2), One))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                        ToInteger (Arg5), One)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), Zero))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (^^PCI0.LPC0.EC.ECXT (0x83, Zero, Zero, Zero, Zero, Zero), Local0)
                        Store (DerefOf (Index (Local0, Zero)), Local3)
                        Store (Zero, FADR)
                        If (LEqual (Local3, Zero))
                        {
                            Store (DerefOf (Index (Local0, One)), FADR)
                        }

                        Store (One, ST10)
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), One))
                    {
                        If (LEqual (ST10, Zero))
                        {
                            Store (0x8D50, Index (RETP, Zero))
                            Return (RETP)
                        }
                        Else
                        {
                            Store (Zero, Index (RETP, Zero))
                            Store (FADR, Index (RETP, 0x02))
                            Store (Zero, ST10)
                            Return (RETP)
                        }
                    }
                }

                If (LAnd (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (
                    Arg1), 0xA8)), LEqual (ToInteger (Arg4), 0x9B)))
                {
                    If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                        ToInteger (Arg5), One)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), Zero))
                    {
                        Store (Zero, Index (RETP, Zero))
                        GPCT (ToInteger (Arg2))
                        Store (One, ST11)
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), One))
                    {
                        If (LEqual (ST11, Zero))
                        {
                            Store (0x8D50, Index (RETP, Zero))
                            Return (RETP)
                        }
                        Else
                        {
                            If (LEqual (ToInteger (Arg2), Zero))
                            {
                                Store (Zero, Index (RETP, Zero))
                                Store (CNT1, Index (RETP, 0x03))
                                Store (CNT2, Index (RETP, 0x02))
                                CPCT (Zero)
                                Store (Zero, ST11)
                                Return (RETP)
                            }

                            If (LEqual (ToInteger (Arg2), One))
                            {
                                Store (CNT3, Index (RETP, 0x02))
                                CPCT (One)
                                Store (Zero, ST11)
                                Return (RETP)
                            }

                            If (LEqual (ToInteger (Arg2), 0x02))
                            {
                                Store (CNT4, Index (RETP, 0x03))
                                Store (CNT5, Index (RETP, 0x02))
                                CPCT (0x02)
                                Store (Zero, ST11)
                                Return (RETP)
                            }
                        }
                    }
                }

                If (LAnd (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (
                    Arg1), 0xA8)), LEqual (ToInteger (Arg4), 0xA0)))
                {
                    If (LEqual (ToInteger (Arg3), Zero))
                    {
                        If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                            ToInteger (Arg5), One)))
                        {
                            Store (0x8300, Index (RETP, Zero))
                            Return (RETP)
                        }
                        Else
                        {
                            If (LEqual (ToInteger (Arg5), Zero))
                            {
                                Store (Zero, Index (RETP, Zero))
                                Store (One, ST12)
                                Return (RETP)
                            }

                            If (LEqual (ToInteger (Arg5), One))
                            {
                                If (LEqual (ST12, Zero))
                                {
                                    Store (0x8D50, Index (RETP, Zero))
                                    Return (RETP)
                                }
                                Else
                                {
                                    Store (Zero, Index (RETP, Zero))
                                    Store (EVCS, Index (RETP, 0x02))
                                    Store (Zero, ST11)
                                    Return (RETP)
                                }
                            }
                        }
                    }
                    Else
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0xA0)))
                {
                    If (And (ToInteger (Arg2), 0xF4))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg3), Zero))
                    {
                        Store (One, ENLE)
                        Store (Zero, Index (RETP, Zero))
                        Store (ToInteger (Arg2), EVCS)
                        If (LEqual (LCDS, One))
                        {
                            If (And (EVCS, 0x02))
                            {
                                If (^^LID._LID ())
                                {
                                    PUTE (0x19B2)
                                }
                                Else
                                {
                                    PUTE (0x19B3)
                                }
                            }
                        }
                        Else
                        {
                            If (And (EVCS, 0x02))
                            {
                                PUTE (0x19B3)
                            }
                        }

                        If (And (EVCS, One))
                        {
                            If (LEqual (LCDS, One))
                            {
                                PUTE (0x19B0)
                            }
                            Else
                            {
                                PUTE (0x19B1)
                            }
                        }

                        If (And (EVCS, 0x08))
                        {
                            ^^PCI0.LPC0.EC.WRAM (0x07C5, 0x80)
                        }
                        Else
                        {
                            ^^PCI0.LPC0.EC.WRAM (0x07C5, Zero)
                        }

                        Return (RETP)
                    }
                    Else
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xA8)))
                {
                    If (LAnd (LEqual (ToInteger (Arg3), Zero), LEqual (ToInteger (Arg4
                        ), 0x9D)))
                    {
                        If (LEqual (ToInteger (Arg5), Zero))
                        {
                            Store (Zero, Index (RETP, Zero))
                        }

                        If (LEqual (ToInteger (Arg5), One))
                        {
                            Store (Zero, Index (RETP, Zero))
                            Store (HPCS, Index (RETP, 0x02))
                        }

                        Return (RETP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0x9D)))
                {
                    If (LNotEqual (ToInteger (Arg3), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LOr (LEqual (ToInteger (Arg2), Zero), LEqual (ToInteger (Arg2
                        ), One)))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (ToInteger (Arg2), HPCS)
                    }
                    Else
                    {
                        Store (0x8300, Index (RETP, Zero))
                    }

                    Return (RETP)
                }

                If (LAnd (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (
                    Arg1), 0xA8)), LEqual (ToInteger (Arg4), 0xA9)))
                {
                    If (LOr (LEqual (ToInteger (Arg2), 0x02), LEqual (ToInteger (Arg2
                        ), 0x8002)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LAnd (LNotEqual (ToInteger (Arg5), Zero), LNotEqual (
                        ToInteger (Arg5), One)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), Zero))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (One, ST16)
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg5), One))
                    {
                        If (LEqual (ST16, Zero))
                        {
                            Store (0x8D50, Index (RETP, Zero))
                            Return (RETP)
                        }
                        Else
                        {
                            If (LEqual (ToInteger (Arg2), One))
                            {
                                Store (Zero, Index (RETP, Zero))
                                If (DCPF)
                                {
                                    Store (^^PCI0.LPC0.EC.BD28, Local0)
                                    Store (^^PCI0.LPC0.EC.BD27, Local1)
                                    ShiftLeft (Local0, 0x08, Local0)
                                    Add (Local1, Local0, Local1)
                                    ShiftLeft (Local1, 0x10, Local1)
                                    And (GBS1, 0xFFFF, GBS1)
                                    Add (GBS1, Local1, GBS1)
                                }
                                Else
                                {
                                    Store (0xFFFF, GBS1)
                                }

                                Store (GBS1, Index (RETP, 0x02))
                                Store (GBS2, Index (RETP, 0x03))
                                Store (GBS3, Index (RETP, 0x04))
                                Store (GBS4, Index (RETP, 0x05))
                                Store (Zero, ST16)
                                Return (RETP)
                            }

                            If (LEqual (ToInteger (Arg2), 0x8001))
                            {
                                Store (Zero, Index (RETP, Zero))
                                Store (GBS5, Index (RETP, 0x02))
                                Store (Zero, ST16)
                                Return (RETP)
                            }
                        }
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xAA)))
                {
                    Store (Zero, Index (RETP, Zero))
                    Store (^^PCI0.LPC0.EC.RRAM (0x07B8), Local0)
                    Store (^^PCI0.LPC0.EC.RRAM (0x07B7), Local1)
                    Store (Local0, CTOV)
                    Store (Local1, CTO1)
                    Store (CTOV, Index (RETP, 0x02))
                    Store (CTO1, Index (RETP, 0x03))
                    Return (RETP)
                }

                If (LEqual (ToInteger (Arg0), 0xF000))
                {
                    If (LEqual (USCF, One))
                    {
                        Store (0x8100, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (0x44, Index (RETP, Zero))
                    Store (0x02, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, 0x54, Local0)
                    Store (Local0, Index (RETP, 0x03))
                    Return (RETP)
                }

                If (LEqual (ToInteger (Arg0), 0xF100))
                {
                    If (LEqual (USCF, Zero))
                    {
                        Store (One, USCF)
                        Store (0x44, Index (RETP, Zero))
                    }
                    Else
                    {
                        Store (0x8100, Index (RETP, Zero))
                    }

                    Return (RETP)
                }

                If (LEqual (ToInteger (Arg0), 0xF200))
                {
                    If (LEqual (USCF, Zero))
                    {
                        Store (0x8200, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (USCF, One))
                    {
                        Store (Zero, USCF)
                        Store (0x44, Index (RETP, Zero))
                    }
                    Else
                    {
                        Store (0x8200, Index (RETP, Zero))
                    }

                    Return (RETP)
                }

                If (LEqual (ToInteger (Arg0), 0xF300))
                {
                    If (LEqual (USCF, Zero))
                    {
                        Store (0x8200, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg1), 0x0150))
                    {
                        Store (ToInteger (Arg5), Local0)
                        While (One)
                        {
                            Store (Local0, _T_0)
                            If (LEqual (_T_0, Zero))
                            {
                                Store (Zero, Index (RETP, Zero))
                                Store (0x800C, Index (RETP, One))
                                While (One)
                                {
                                    Store (USCM, _T_1)
                                    If (LEqual (_T_1, 0x03))
                                    {
                                        Store (0x09, Local2)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_1, 0x05))
                                        {
                                            Store (0x21, Local2)
                                        }
                                        Else
                                        {
                                            Store (Zero, Local2)
                                        }
                                    }

                                    Break
                                }

                                Store (0x0800, Local1)
                                ShiftLeft (Local1, 0x10, Local1)
                                Add (Local1, Local2, Local1)
                                Store (Local1, Index (RETP, 0x02))
                                Store (0x0800, Local1)
                                ShiftLeft (Local1, 0x10, Local1)
                                Or (Local1, 0x09, Local1)
                                Or (Local1, 0x21, Local1)
                                Store (Local1, Index (RETP, 0x03))
                                And (Local1, 0xFFFFFF00, Local1)
                                Store (Local1, Index (RETP, 0x04))
                                Return (RETP)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x0100))
                                {
                                    Store (Zero, Index (RETP, Zero))
                                    Store (0x8001, Index (RETP, One))
                                    Store (One, Index (RETP, 0x02))
                                    Return (RETP)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x0200))
                                    {
                                        Store (Zero, Index (RETP, Zero))
                                        Store (0x800D, Index (RETP, One))
                                        Store (^^PCI0.LPC0.EC.RRAM (0x07C2), Local1)
                                        And (Local1, 0xE0, Local1)
                                        If (LAnd (And (Local1, 0x20), And (Local1, 0x40)))
                                        {
                                            Store (0x04, Local2)
                                        }
                                        Else
                                        {
                                            If (And (Local1, 0x20))
                                            {
                                                Store (One, Local2)
                                            }
                                            Else
                                            {
                                                If (And (Local1, 0x40))
                                                {
                                                    Store (0x02, Local2)
                                                }
                                                Else
                                                {
                                                    Store (Zero, Local2)
                                                }
                                            }
                                        }

                                        Store (^^PCI0.LPC0.EC.RRAM (0x07C3), Local1)
                                        ShiftLeft (Local1, 0x10, Local1)
                                        Add (Local1, Local2, Local1)
                                        Store (Local1, Index (RETP, 0x02))
                                        Store (0x64, Local1)
                                        ShiftLeft (Local1, 0x10, Local1)
                                        Or (Local1, One, Local1)
                                        Or (Local1, 0x04, Local1)
                                        Store (0x00640005, Index (RETP, 0x03))
                                        Store (0x0A, Local1)
                                        ShiftLeft (Local1, 0x10, Local1)
                                        Or (Local1, One, Local1)
                                        Or (Local1, 0x04, Local1)
                                        Store (0x000A0004, Index (RETP, 0x04))
                                        Return (RETP)
                                    }
                                }
                            }

                            Break
                        }

                        If (LEqual (And (Local0, 0xFF00), 0x0100))
                        {
                            If (And (Local0, 0xFF, Local0))
                            {
                                If (LGreater (Local0, One))
                                {
                                    Store (0x8300, Index (RETP, Zero))
                                    Return (RETP)
                                }

                                Store (Zero, Index (RETP, Zero))
                                Store (0x800C, Index (RETP, One))
                                If (LEqual (Local0, One))
                                {
                                    Store (0x0800, Local1)
                                    ShiftLeft (Local1, 0x10, Local1)
                                    Or (Local1, 0x09, Local1)
                                    Or (Local1, 0x21, Local1)
                                    Store (Local1, Index (RETP, 0x02))
                                }

                                Return (RETP)
                            }
                        }
                    }
                }

                If (LEqual (ToInteger (Arg0), 0xF400))
                {
                    If (LEqual (USCF, Zero))
                    {
                        Store (0x8200, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg1), 0x0150))
                    {
                        Store (ToInteger (Arg5), Local0)
                        While (One)
                        {
                            Store (Local0, _T_2)
                            If (LEqual (_T_2, Zero))
                            {
                                Store (ToInteger (Arg2), Local1)
                                Store (Zero, Local2)
                                Or (Local2, 0x09, Local2)
                                Or (Local2, 0x21, Local2)
                                If (And (And (Local1, 0xFF), Not (Local2)))
                                {
                                    Store (0x8300, Index (RETP, Zero))
                                    Return (RETP)
                                }

                                And (Local1, Local2, Local2)
                                ShiftRight (Local1, 0x10, Local1)
                                And (Local1, 0x3FFF, Local1)
                                If (LNotEqual (Local1, 0x0800))
                                {
                                    Store (0x8300, Index (RETP, Zero))
                                    Return (RETP)
                                }

                                While (One)
                                {
                                    Store (Local2, _T_3)
                                    If (LEqual (_T_3, Zero))
                                    {
                                        Store (Zero, USCM)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_3, 0x09))
                                        {
                                            Store (0x03, USCM)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_3, 0x21))
                                            {
                                                Store (0x05, USCM)
                                            }
                                            Else
                                            {
                                                Store (0x8300, Index (RETP, Zero))
                                                Return (RETP)
                                            }
                                        }
                                    }

                                    Break
                                }

                                Store (0xF400, SWMF)
                                Store (0x0150, SWSF)
                                Store (USCM, DAX0)
                                BSMI (0xD5)
                                Store (^^PCI0.LPC0.EC.RRAM (0x07C2), Local3)
                                And (Local3, 0x78, Local3)
                                While (One)
                                {
                                    Store (USCM, _T_4)
                                    If (LEqual (_T_4, Zero))
                                    {
                                        Or (Local3, Zero, Local3)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_4, 0x03))
                                        {
                                            Or (Local3, 0x02, Local3)
                                            Or (Local3, 0x80, Local3)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_4, 0x05))
                                            {
                                                Or (Local3, 0x04, Local3)
                                                Or (Local3, 0x80, Local3)
                                            }
                                            Else
                                            {
                                                Or (Local3, Zero, Local3)
                                            }
                                        }
                                    }

                                    Break
                                }

                                ^^PCI0.LPC0.EC.WRAM (0x07C2, Local3)
                                Store (Zero, Index (RETP, Zero))
                                Return (RETP)
                            }
                            Else
                            {
                                If (LEqual (_T_2, 0x0200))
                                {
                                    Store (ToInteger (Arg2), Local1)
                                    If (And (Local1, 0xFFF8))
                                    {
                                        Store (0x8300, Index (RETP, Zero))
                                        Return (RETP)
                                    }

                                    If (And (Local1, 0x02))
                                    {
                                        Store (0x8300, Index (RETP, Zero))
                                        Return (RETP)
                                    }

                                    If (LEqual (Local1, Zero))
                                    {
                                        Store (0x8300, Index (RETP, Zero))
                                        Return (RETP)
                                    }

                                    Store (^^PCI0.LPC0.EC.RRAM (0x07C2), Local2)
                                    And (Local2, 0x9F, Local2)
                                    And (Local1, 0x07, Local1)
                                    While (One)
                                    {
                                        Store (Local1, _T_5)
                                        If (LEqual (_T_5, One))
                                        {
                                            Or (Local2, 0x20, Local2)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_5, 0x04))
                                            {
                                                Or (Local2, 0x20, Local2)
                                                Or (Local2, 0x40, Local2)
                                            }
                                            Else
                                            {
                                                Or (Local2, 0x20, Local2)
                                                Or (Local2, 0x40, Local2)
                                                Store (0x04, Local1)
                                            }
                                        }

                                        Break
                                    }

                                    ShiftRight (ToInteger (Arg2), 0x10, Local1)
                                    If (LGreater (Local1, 0x64))
                                    {
                                        Store (0x8300, Index (RETP, Zero))
                                        Return (RETP)
                                    }

                                    ShiftRight (ToInteger (Arg2), 0x10, Local1)
                                    ^^PCI0.LPC0.EC.WRAM (0x07C2, Local2)
                                    ^^PCI0.LPC0.EC.WRAM (0x07C3, Local1)
                                    Store (Zero, Index (RETP, Zero))
                                    Return (RETP)
                                }
                                Else
                                {
                                    Store (0x8300, Index (RETP, Zero))
                                    Return (RETP)
                                }
                            }

                            Break
                        }
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x56))
                {
                    If (LEqual (ToInteger (Arg0), 0xFE00))
                    {
                        If (LEqual (ToInteger (Arg3), One))
                        {
                            Store (Zero, Local0)
                            Or (Local0, One, Local0)
                            If (RGPL (0xD3, One))
                            {
                                Or (Local0, 0x0200, Local0)
                            }

                            Store (Zero, Index (RETP, Zero))
                            Store (Local0, Index (RETP, 0x02))
                            Return (RETP)
                        }
                        Else
                        {
                            If (LEqual (ToInteger (Arg3), 0x03))
                            {
                                Store (0x8300, Index (RETP, Zero))
                                Store (Zero, Index (RETP, 0x02))
                                Return (RETP)
                            }
                        }
                    }

                    If (LEqual (ToInteger (Arg0), 0xFF00))
                    {
                        If (LEqual (ToInteger (Arg3), 0x0200))
                        {
                            If (LEqual (ToInteger (Arg2), One))
                            {
                                If (WLDP)
                                {
                                    SGPL (0xD3, One, One)
                                }

                                Store (One, WRST)
                            }
                            Else
                            {
                                If (WLDP)
                                {
                                    SGPL (0xD3, One, Zero)
                                }

                                Store (Zero, WRST)
                            }

                            MLED ()
                            Return (NULP)
                        }

                        If (LEqual (ToInteger (Arg3), 0x2000))
                        {
                            Store (0x8000, Index (RETP, Zero))
                            Return (RETP)
                            If (LEqual (ToInteger (Arg2), One))
                            {
                                If (W3DP) {}
                                Store (One, WRPS)
                            }
                            Else
                            {
                                If (W3DP) {}
                                Store (Zero, WRPS)
                            }

                            MLED ()
                            Return (NULP)
                        }

                        If (LEqual (ToInteger (Arg3), 0x4000))
                        {
                            Store (0x8000, Index (RETP, Zero))
                            Return (RETP)
                            If (LEqual (ToInteger (Arg2), One))
                            {
                                If (W3DP) {}
                                Store (One, WRPS)
                            }
                            Else
                            {
                                If (W3DP) {}
                                Store (Zero, WRPS)
                            }

                            MLED ()
                            Return (NULP)
                        }

                        If (LEqual (ToInteger (Arg3), 0x0800))
                        {
                            Store (0x8000, Index (RETP, Zero))
                            Return (RETP)
                            If (LEqual (ToInteger (Arg2), One))
                            {
                                If (WUDP) {}
                                Store (One, BRPS)
                            }
                            Else
                            {
                                If (WUDP) {}
                                Store (Zero, BRPS)
                            }

                            MLED ()
                            Return (NULP)
                        }
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xF300), LEqual (ToInteger (Arg1
                    ), 0x050E)))
                {
                    Store (^^PCI0.LPC0.EC.RRAM (0x07C7), Local0)
                    Store (Zero, Index (RETP, Zero))
                    Store (Zero, Index (RETP, One))
                    If (And (Local0, One))
                    {
                        Store (Zero, Index (RETP, 0x02))
                    }
                    Else
                    {
                        Store (One, Index (RETP, 0x02))
                    }

                    Store (One, Index (RETP, 0x04))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xF400), LEqual (ToInteger (Arg1
                    ), 0x050E)))
                {
                    Store (ToInteger (Arg2), Local0)
                    ^^PCI0.LPC0.EC.ECXT (0xB5, Zero, Zero, Zero, Zero, Zero)
                    If (LNotEqual (Local0, Zero))
                    {
                        ^^PCI0.LPC0.EC.ECXT (0xB5, Zero, Zero, Zero, Zero, Zero)
                        Store (One, TPON)
                    }
                    Else
                    {
                        ^^PCI0.LPC0.EC.ECXT (0xB5, One, Zero, Zero, Zero, Zero)
                        Store (Zero, TPON)
                    }

                    Return (NULP)
                }

                If (KBTY)
                {
                    If (LEqual (ToInteger (Arg1), 0x0522))
                    {
                        If (LNotEqual (ToInteger (Arg3), Zero))
                        {
                            Store (0x8300, Index (RETP, Zero))
                            Return (RETP)
                        }

                        If (LOr (LNotEqual (ToInteger (Arg4), Zero), LNotEqual (
                            ToInteger (Arg5), Zero)))
                        {
                            Store (0x8300, Index (RETP, Zero))
                            Return (RETP)
                        }

                        If (LEqual (ToInteger (Arg0), 0xF300))
                        {
                            If (LNotEqual (ToInteger (Arg2), Zero))
                            {
                                Store (0x8300, Index (RETP, Zero))
                                Return (RETP)
                            }

                            Store (0xF300, SWMF)
                            Store (0x0522, SWSF)
                            BSMI (0xD5)
                            Store (One, Index (RETP, Zero))
                            Store (Zero, Index (RETP, One))
                            Store (DAX0, Index (RETP, 0x02))
                            Store (DAX1, Index (RETP, 0x04))
                            Store (DAX0, FNKS)
                            Return (RETP)
                        }

                        If (LEqual (ToInteger (Arg0), 0xF400))
                        {
                            Store (0xF400, SWMF)
                            Store (0x0522, SWSF)
                            Store (ToInteger (Arg2), DAX0)
                            BSMI (0xD5)
                            Store (ToInteger (Arg2), FNKS)
                            Store (One, Index (RETP, Zero))
                            If (LEqual (KBTY, Zero))
                            {
                                ^^PCI0.LPC0.EC.ECXT (0xC0, 0x10, Zero, Zero, Zero, Zero)
                            }
                            Else
                            {
                                If (LEqual (FNKS, One))
                                {
                                    FKMC (One)
                                }
                                Else
                                {
                                    FKMC (Zero)
                                }
                            }

                            Return (RETP)
                        }
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xC3)))
                {
                    If (LOr (LNotEqual (ToInteger (Arg2), Zero), LNotEqual (
                        ToInteger (Arg3), Zero)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LOr (LNotEqual (ToInteger (Arg4), Zero), LNotEqual (
                        ToInteger (Arg5), Zero)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (Zero, Index (RETP, Zero))
                    Store (HISD, Index (RETP, 0x02))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0xC3)))
                {
                    If (LOr (LNotEqual (ToInteger (Arg4), Zero), LNotEqual (
                        ToInteger (Arg5), Zero)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (ToInteger (Arg2), HISD)
                    If (LEqual (ToInteger (Arg3), One))
                    {
                        ^^PCI0.LPC0.EC.WRAM (0x0470, 0xE0)
                        ^^PCI0.LPC0.EC.WRAM (0x0471, 0x5A)
                        ^^PCI0.LPC0.EC.ECXT (0xC1, 0x02, Zero, Zero, Zero, Zero)
                        ^^PCI0.LPC0.EC.WRAM (0x0470, 0xE0)
                        ^^PCI0.LPC0.EC.WRAM (0x0471, 0xF0)
                        ^^PCI0.LPC0.EC.WRAM (0x0472, 0x5A)
                        ^^PCI0.LPC0.EC.ECXT (0xC1, 0x03, Zero, Zero, Zero, Zero)
                    }

                    If (LEqual (ToInteger (Arg3), 0x02))
                    {
                        ^^PCI0.LPC0.EC.WRAM (0x0470, 0x76)
                        ^^PCI0.LPC0.EC.ECXT (0xC1, One, Zero, Zero, Zero, Zero)
                        ^^PCI0.LPC0.EC.WRAM (0x0470, 0xF0)
                        ^^PCI0.LPC0.EC.WRAM (0x0471, 0x76)
                        ^^PCI0.LPC0.EC.ECXT (0xC1, 0x02, Zero, Zero, Zero, Zero)
                    }

                    Store (Zero, Index (RETP, Zero))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xC000)))
                {
                    If (LOr (LNotEqual (ToInteger (Arg2), 0x03), LNotEqual (
                        ToInteger (Arg3), Zero)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LOr (LNotEqual (ToInteger (Arg4), Zero), LNotEqual (
                        ToInteger (Arg5), Zero)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (RGPL (One, One))
                    {
                        Store (Zero, Index (RETP, 0x02))
                    }
                    Else
                    {
                        Store (0x10, Index (RETP, 0x02))
                    }

                    If (LEqual (^^PCI0.LPC0.EC.RPIN (0x03, 0x05), One))
                    {
                        Store (0x10, Index (RETP, 0x03))
                    }
                    Else
                    {
                        Store (Zero, Index (RETP, 0x03))
                    }

                    Store (Zero, Index (RETP, Zero))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0xC000)))
                {
                    If (LNotEqual (ToInteger (Arg2), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LOr (LNotEqual (ToInteger (Arg4), Zero), LNotEqual (
                        ToInteger (Arg5), Zero)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LAnd (LNotEqual (ToInteger (Arg3), Zero), LNotEqual (
                        ToInteger (Arg3), One)))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (Zero, Index (RETP, Zero))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0x5A)))
                {
                    If (LEqual (ToInteger (Arg2), Zero))
                    {
                        ^^PCI0.LPC0.EC.ECXT (0xAF, Zero, Zero, Zero, Zero, Zero)
                        Store (^^PCI0.LPC0.EC.RRAM (0x07B0), IO80)
                        Sleep (0x01F4)
                        Return (NULP)
                    }
                    Else
                    {
                        ^^PCI0.LPC0.EC.ECXT (0xAF, 0x02, Zero, Zero, Zero, Zero)
                        Store (^^PCI0.LPC0.EC.RRAM (0x07B0), IO80)
                        Sleep (0x01F4)
                    }

                    If (LEqual (ToInteger (Arg2), One))
                    {
                        Store (One, STMD)
                        Store (^^PCI0.LPC0.EC.RRAM (0x07B0), Local0)
                        ^^PCI0.LPC0.EC.WRAM (0x07B0, And (Local0, 0xEF))
                        Store (^^PCI0.LPC0.EC.RRAM (0x07B0), IO80)
                        Return (NULP)
                    }

                    If (LEqual (ToInteger (Arg2), 0x02))
                    {
                        Store (0x02, STMD)
                        Store (^^PCI0.LPC0.EC.RRAM (0x07B0), Local0)
                        ^^PCI0.LPC0.EC.WRAM (0x07B0, Or (Local0, 0x10))
                        Store (^^PCI0.LPC0.EC.RRAM (0x07B0), IO80)
                        Return (NULP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0x7F)))
                {
                    Store (Zero, Index (RETP, Zero))
                    Store (CMMD, Index (RETP, 0x02))
                    Store (One, Index (RETP, 0x03))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0x7F)))
                {
                    Store (Zero, Index (RETP, Zero))
                    If (LEqual (ToInteger (Arg2), Zero))
                    {
                        \_TZ.THZ0._SCP (Zero)
                        Store (Zero, CMMD)
                    }

                    If (LEqual (ToInteger (Arg2), One))
                    {
                        \_TZ.THZ0._SCP (One)
                        Store (One, CMMD)
                    }

                    Return (RETP)
                }

                If (LEqual (ToInteger (Arg1), 0x62))
                {
                    If (LEqual (ToInteger (Arg0), 0xFE00))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Store (Zero, Index (RETP, 0x02))
                        Store (0x21, Index (RETP, 0x03))
                        Return (RETP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0x11)))
                {
                    If (LNotEqual (ToInteger (Arg2), Zero))
                    {
                        Store (One, Local0)
                    }

                    If (LNotEqual (ToInteger (Arg3), Zero))
                    {
                        Store (One, Local0)
                    }

                    If (LNotEqual (ToInteger (Arg4), Zero))
                    {
                        Store (One, Local0)
                    }

                    If (LNotEqual (ToInteger (Arg5), Zero))
                    {
                        Store (One, Local0)
                    }

                    If (LEqual (Local0, One))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (GLPS (), PSMD)
                    Store (Zero, Index (RETP, Zero))
                    Store (PSMD, Index (RETP, 0x02))
                    Return (RETP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0xC000)))
                {
                    If (LAnd (LEqual (ToInteger (Arg2), Zero), LEqual (ToInteger (Arg3
                        ), Zero)))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0xC000)))
                {
                    If (LAnd (LEqual (ToInteger (Arg2), Zero), LEqual (ToInteger (Arg3
                        ), One)))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg1
                    ), 0x1E)))
                {
                    If (LNotEqual (ToInteger (Arg3), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LNotEqual (ToInteger (Arg4), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LNotEqual (ToInteger (Arg5), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (ToInteger (Arg2), HKEV)
                    If (LAnd (KBTY, FNKS))
                    {
                        If (And (HKEV, 0x10))
                        {
                            FKMC (One)
                        }
                        Else
                        {
                            FKMC (Zero)
                        }
                    }

                    Return (NULP)
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0x1E)))
                {
                    If (LNotEqual (ToInteger (Arg2), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LNotEqual (ToInteger (Arg3), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LNotEqual (ToInteger (Arg4), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    If (LNotEqual (ToInteger (Arg5), Zero))
                    {
                        Store (0x8300, Index (RETP, Zero))
                        Return (RETP)
                    }

                    Store (Zero, Index (RETP, Zero))
                    Store (HKEV, Index (RETP, 0x02))
                    Return (RETP)
                }

                If (LEqual (ToInteger (Arg0), 0xF300))
                {
                    If (LEqual (ToInteger (Arg1), 0x010E))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8005, Index (RETP, One))
                        Store (0xF300, SWMF)
                        Store (0x010E, SWSF)
                        BSMI (0xD5)
                        Store (DAX0, Index (RETP, 0x02))
                        Store (0xFFFE, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg1), 0x010F))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8004, Index (RETP, One))
                        Store (0xF300, SWMF)
                        Store (0x010F, SWSF)
                        BSMI (0xD5)
                        Store (DAX0, Index (RETP, 0x02))
                        Store (0x0FFF, Index (RETP, 0x03))
                        Store (One, Index (RETP, 0x04))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg0), 0xF400))
                {
                    If (LEqual (ToInteger (Arg1), 0x010E))
                    {
                        Store (0xF400, SWMF)
                        Store (0x010E, SWSF)
                        Store (ToInteger (Arg2), DAX0)
                        BSMI (0xD5)
                        Return (NULP)
                    }

                    If (LEqual (ToInteger (Arg1), 0x010F))
                    {
                        Store (0xF400, SWMF)
                        Store (0x010F, SWSF)
                        Store (ToInteger (Arg2), DAX0)
                        BSMI (0xD5)
                        Store (One, RTCE)
                        Return (NULP)
                    }
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0x75)))
                {
                    Return (NULP)
                }

                If (LEqual (ToInteger (Arg1), 0x8C))
                {
                    If (LAnd (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (
                        Arg2), Zero)), LEqual (ToInteger (Arg3), Zero)))
                    {
                        Return (NULP)
                    }

                    If (LAnd (LEqual (ToInteger (Arg0), 0xFF00), LEqual (ToInteger (Arg3
                        ), Zero)))
                    {
                        If (LEqual (And (ToInteger (Arg2), One), Zero)) {}
                        Else
                        {
                        }

                        If (LEqual (And (ToInteger (Arg2), 0x02), Zero)) {}
                        Else
                        {
                        }

                        Return (NULP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x014E))
                {
                    If (LAnd (LAnd (LEqual (ToInteger (Arg0), 0xF300), LEqual (ToInteger (
                        Arg2), Zero)), LEqual (ToInteger (Arg3), Zero))) {}
                    If (LAnd (LEqual (ToInteger (Arg0), 0xF400), LEqual (ToInteger (Arg3
                        ), Zero))) {}
                }

                If (LAnd (LEqual (ToInteger (Arg0), 0xFE00), LEqual (ToInteger (Arg1
                    ), 0xC000)))
                {
                    If (LEqual (ToInteger (Arg2), 0x03))
                    {
                        Store (^^PCI0.LPC0.EC.ISHE, Local0)
                        ShiftLeft (Local0, 0x04, Local0)
                        Store (Zero, Index (RETP, Zero))
                        Store (Local0, Index (RETP, 0x03))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg0), 0xFE00))
                {
                    If (LEqual (ToInteger (Arg1), 0x96))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0xFF40, Index (RETP, 0x02))
                        Store (GMID (), Index (RETP, 0x03))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x011D))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8001, Index (RETP, One))
                        Store (0x05, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Return (NULP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0126))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8502, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Return (NULP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0129))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0130))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0132))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (0x8001, Index (RETP, One))
                        Store (0x02, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0136))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0137))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (0x800A, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0138))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x013A))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0142))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8001, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0144))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0145))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8001, Index (RETP, One))
                        Store (0x03, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0146))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8001, Index (RETP, One))
                        Store (One, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x014F))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (0x8001, Index (RETP, One))
                        Store (0x03, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0157))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8503, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x015B))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Store (0x8504, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x015D))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Store (0xF300, SWMF)
                        Store (0x015D, SWSF)
                        BSMI (0xD5)
                        Store (DAX0, Index (RETP, 0x02))
                        Store (DAX1, Index (RETP, 0x04))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (0xF400, SWMF)
                        Store (0x015D, SWSF)
                        Store (ToInteger (Arg2), DAX0)
                        BSMI (0xD5)
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0300))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (0x8200, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0405))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (0x8001, Index (RETP, One))
                        Store (0x05, Index (RETP, 0x03))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0501))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (0x8101, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0502))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (0x8300, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x050C))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x050D))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0511))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (One, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x0700))
                {
                    If (LEqual (ToInteger (Arg0), 0xF300))
                    {
                        Store (One, Index (RETP, Zero))
                        Store (Zero, Index (RETP, One))
                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xF400))
                    {
                        Store (Zero, Index (RETP, Zero))
                        Return (RETP)
                    }
                }

                If (LEqual (ToInteger (Arg1), 0x67))
                {
                    If (LEqual (ToInteger (Arg0), 0xFE00))
                    {
                        Store (0x8000, Index (RETP, Zero))
                        If (LEqual (ToInteger (Arg4), Zero))
                        {
                            If (LEqual (ToInteger (Arg3), Zero))
                            {
                                And (PKFG, 0xFF7F, PKFG)
                                If (^^PCI0.LPC0.EC.ACAP ())
                                {
                                    Or (PKFG, 0x80, PKFG)
                                }

                                Store (PKFG, Index (RETP, 0x02))
                                Store (Zero, Index (RETP, Zero))
                            }
                            Else
                            {
                                If (LEqual (ToInteger (Arg3), One))
                                {
                                    Store (^^PCI0.LPC0.EC.ECXT (0xC5, Zero, Zero, Zero, Zero, Zero), Local0)
                                    Store (Package (0x0D)
                                        {
                                            0xC6, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero, 
                                            Zero
                                        }, Local1)
                                    Store (^^PCI0.LPC0.EC.ECX1 (Local1), Local1)
                                    Store (T2SC (DerefOf (Index (Local0, 0x02)), DerefOf (Index (Local0, 
                                        0x03)), DerefOf (Index (Local0, 0x04))), Local2)
                                    Store (T2SC (DerefOf (Index (Local1, 0x04)), DerefOf (Index (Local1, 
                                        0x05)), DerefOf (Index (Local1, 0x06))), Local3)
                                    Store (T2SC (DerefOf (Index (Local1, 0x08)), DerefOf (Index (Local1, 
                                        0x09)), DerefOf (Index (Local1, 0x0A))), Local4)
                                    If (LLess (STRT, STPT))
                                    {
                                        If (LEqual (DerefOf (Index (Local1, 0x03)), DerefOf (Index (Local1, 
                                            0x07))))
                                        {
                                            If (STRT)
                                            {
                                                If (LGreaterEqual (Local2, Local3))
                                                {
                                                    Store (Zero, STRT)
                                                }
                                            }

                                            If (STPT)
                                            {
                                                If (LEqual (STRT, Zero))
                                                {
                                                    If (LGreaterEqual (Local2, Local4))
                                                    {
                                                        Store (Zero, STPT)
                                                    }
                                                }
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (DerefOf (Index (Local0, One)), One))
                                            {
                                                If (STRT)
                                                {
                                                    If (LGreaterEqual (Local2, Local3))
                                                    {
                                                        Store (Zero, STRT)
                                                    }
                                                }
                                            }
                                            Else
                                            {
                                                If (LEqual (DerefOf (Index (Local0, One)), 0x02))
                                                {
                                                    Store (Zero, STRT)
                                                    If (STPT)
                                                    {
                                                        If (LGreaterEqual (Local2, Local4))
                                                        {
                                                            Store (Zero, STPT)
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    Store (STRT, Local0)
                                    ShiftLeft (Local0, 0x10, Local0)
                                    Or (Local0, STPT, Local0)
                                    Store (Local0, Index (RETP, 0x02))
                                    Store (One, Index (RETP, 0x04))
                                    Store (Zero, Index (RETP, Zero))
                                }
                            }
                        }

                        Return (RETP)
                    }

                    If (LEqual (ToInteger (Arg0), 0xFF00))
                    {
                        Store (0x8000, Index (RETP, Zero))
                        If (LEqual (ToInteger (Arg3), Zero))
                        {
                            Store (Zero, Index (RETP, Zero))
                            While (One)
                            {
                                Store (Arg2, _T_6)
                                If (LEqual (_T_6, Zero))
                                {
                                    And (PKFG, 0xFF80, PKFG)
                                    Store (Zero, STRT)
                                    Store (Zero, STPT)
                                }
                                Else
                                {
                                    If (LEqual (_T_6, 0x10))
                                    {
                                        Or (PKFG, One, PKFG)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_6, 0x11))
                                        {
                                            And (PKFG, 0xFFFE, PKFG)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_6, 0x20))
                                            {
                                                Or (PKFG, 0x02, PKFG)
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_6, 0x21))
                                                {
                                                    And (PKFG, 0xFFFD, PKFG)
                                                }
                                                Else
                                                {
                                                    If (LEqual (_T_6, 0x40))
                                                    {
                                                        Or (PKFG, 0x04, PKFG)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (_T_6, 0x41))
                                                        {
                                                            And (PKFG, 0xFFFB, PKFG)
                                                        }
                                                        Else
                                                        {
                                                            Store (0x8000, Index (RETP, Zero))
                                                            Return (RETP)
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                Break
                            }

                            If (And (PKFG, One))
                            {
                                ^^PCI0.LPC0.EC.WRAM (0x062A, 0x03)
                                ^^PCI0.LPC0.EC.ECXT (0xC4, 0x03, Zero, Zero, Zero, Zero)
                            }
                            Else
                            {
                                If (And (PKFG, 0x02))
                                {
                                    ^^PCI0.LPC0.EC.ECXT (0xC4, 0x04, Zero, Zero, Zero, Zero)
                                }
                                Else
                                {
                                    ^^PCI0.LPC0.EC.ECXT (0xC4, Zero, Zero, Zero, Zero, Zero)
                                    ^^PCI0.LPC0.EC.ECXT (0xC7, Zero, Zero, Zero, Zero, Zero)
                                }
                            }
                        }
                        Else
                        {
                            If (LEqual (ToInteger (Arg3), One))
                            {
                                Store (ToInteger (Arg2), Local0)
                                And (Local0, 0xFFFF, Local1)
                                ShiftRight (Local0, 0x10, Local0)
                                If (LOr (LOr (LGreater (Local0, Local1), LGreater (Local0, 0x05A0)), LGreater (
                                    Local1, 0x05A0)))
                                {
                                    Store (0x8003, Index (RETP, Zero))
                                }
                                Else
                                {
                                    If (LOr (LOr (LNotEqual (Local0, Zero), LNotEqual (Local1, 
                                        Zero)), LAnd (And (PKFG, 0x04), LAnd (LEqual (Local0, Zero), LEqual (
                                        Local1, Zero)))))
                                    {
                                        Store (Local0, STRT)
                                        Store (Local1, STPT)
                                        Store (0xFF00, SWMF)
                                        Store (0x67, SWSF)
                                        BSMI (0xD5)
                                        Store (One, RTCD)
                                        ^^PCI0.LPC0.EC.ECXT (0xC2, RTCD, RTCH, RTCM, RTSS, Zero)
                                        Multiply (Local0, 0x3C, Local0)
                                        Multiply (Local1, 0x3C, Local1)
                                        If (Local0)
                                        {
                                            PCAR (Local0)
                                            PCAP (Local1)
                                        }
                                        Else
                                        {
                                            Store (0x03, Local0)
                                            If (LEqual (Local1, Zero))
                                            {
                                                Subtract (0x3C, RTSS, Local1)
                                                If (LLessEqual (Local1, Add (Local0, 0x03)))
                                                {
                                                    Store (0x06, Local1)
                                                }
                                            }

                                            PCAR (Local0)
                                            PCAP (Local1)
                                        }

                                        ^^PCI0.LPC0.EC.ECXT (0xC4, Zero, Zero, Zero, Zero, Zero)
                                        Store (Package (0x0D)
                                            {
                                                0xC3, 
                                                Zero, 
                                                0x04, 
                                                Zero, 
                                                Zero, 
                                                Zero, 
                                                Zero, 
                                                Zero, 
                                                Zero, 
                                                Zero, 
                                                Zero, 
                                                Zero, 
                                                Zero
                                            }, Local2)
                                        Store (STTD, Index (Local2, 0x04))
                                        Store (STTH, Index (Local2, 0x05))
                                        Store (STTM, Index (Local2, 0x06))
                                        Store (STTS, Index (Local2, 0x07))
                                        Store (STPD, Index (Local2, 0x08))
                                        Store (STPH, Index (Local2, 0x09))
                                        Store (STPM, Index (Local2, 0x0A))
                                        Store (STPS, Index (Local2, 0x0B))
                                        ^^PCI0.LPC0.EC.ECX1 (Local2)
                                        ^^PCI0.LPC0.EC.ECXT (0xC7, 0x80, Zero, Zero, Zero, Zero)
                                        Store (Zero, Index (RETP, Zero))
                                    }
                                }
                            }
                        }

                        Return (RETP)
                    }
                }

                Return (USFN)
            }

            Method (TIMR, 0, Serialized)
            {
            }

            Method (PUTE, 1, Serialized)
            {
                If (LEqual (ENFG, Zero))
                {
                    Return (Zero)
                }

                If (LNotEqual (Acquire (MUEV, 0xFFFF), Zero))
                {
                    Return (Zero)
                }

                If (LLess (EVCT, 0x64))
                {
                    Store (Arg0, Index (EVCD, EVCT))
                    Increment (EVCT)
                }

                Release (MUEV)
                And (HKEV, 0x02, Local0)
                If (LEqual (Local0, 0x02))
                {
                    Return (Zero)
                }

                Notify (VALZ, 0x80)
                Sleep (0x64)
                Return (Zero)
            }

            Method (GETE, 0, Serialized)
            {
                If (LEqual (ENFG, Zero))
                {
                    Return (Zero)
                }

                If (LNotEqual (Acquire (MUEV, 0xFFFF), Zero))
                {
                    Return (Zero)
                }

                If (LEqual (EVCT, Zero))
                {
                    Release (MUEV)
                    Return (Zero)
                }

                Store (DerefOf (Index (EVCD, Zero)), Local0)
                Store (Zero, Local1)
                While (LLess (Local1, 0x63))
                {
                    Store (DerefOf (Index (EVCD, Add (Local1, One))), Index (
                        EVCD, Local1))
                    Increment (Local1)
                }

                Decrement (EVCT)
                Release (MUEV)
                If (LNotEqual (EVCT, Zero))
                {
                    And (HKEV, 0x02, Local0)
                    If (LAnd (Local0, 0x02))
                    {
                        Return (Zero)
                    }

                    Notify (VALZ, 0x80)
                    Sleep (0x64)
                }

                Return (Local0)
            }

            Method (INFO, 0, Serialized)
            {
                Store (GETE (), Local0)
                Return (Local0)
            }

            Name (MSEN, Zero)
            Method (CMST, 6, NotSerialized)
            {
                If (LEqual (MSEN, Zero))
                {
                    If (LEqual (^^PCI0.LPC0.EC.RPIN (0x02, 0x03), Zero))
                    {
                        Store (0x02, MSEN)
                    }
                    Else
                    {
                        Store (One, MSEN)
                    }
                }

                If (LEqual (MSEN, One))
                {
                    Return (Ones)
                }
                Else
                {
                    If (LAnd (LEqual (ToInteger (Arg0), 0xF300), LEqual (ToInteger (Arg1
                        ), 0x0150)))
                    {
                        Return (Zero)
                    }

                    If (LAnd (LEqual (ToInteger (Arg0), 0xF400), LEqual (ToInteger (Arg1
                        ), 0x0150)))
                    {
                        Return (Zero)
                    }
                }

                Return (Ones)
            }

            Method (GBIF, 0, NotSerialized)
            {
                If (DCPF)
                {
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (Zero, Local2)
                    Store (^^PCI0.LPC0.EC.BD28, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD27, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local1, 0x10, Local2)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (^^PCI0.LPC0.EC.BD2E, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD2D, Local0)
                    Or (Local0, Local1, Local1)
                    Or (Local1, Local2, Local2)
                    Store (Local2, GBS1)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (Zero, Local2)
                    Store (^^PCI0.LPC0.EC.BD38, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD37, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local1, 0x10, Local2)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (^^PCI0.LPC0.EC.BD3A, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD39, Local0)
                    Or (Local0, Local1, Local1)
                    And (0xFFFF0000, Local2, Local2)
                    Store (Local2, GBS2)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (Zero, Local2)
                    Store (^^PCI0.LPC0.EC.BD3C, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD3B, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local1, 0x10, Local2)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (^^PCI0.LPC0.EC.BD2A, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD29, Local0)
                    Or (Local0, Local1, Local1)
                    Or (Local1, Local2, Local2)
                    Store (Local2, GBS3)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (Zero, Local2)
                    Store (^^PCI0.LPC0.EC.BD34, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD33, Local0)
                    Or (Local0, Local1, Local1)
                    If (LEqual (And (Local1, 0xFFFF), Zero))
                    {
                        Store (Zero, Local0)
                        Store (Zero, Local1)
                        Store (^^PCI0.LPC0.EC.BD3A, Local0)
                        ShiftLeft (Local0, 0x08, Local0)
                        Or (Local0, Local1, Local1)
                        Store (^^PCI0.LPC0.EC.BD39, Local0)
                        Or (Local0, Local1, Local1)
                    }

                    ShiftLeft (Local1, 0x10, Local2)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (^^PCI0.LPC0.EC.BD36, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD35, Local0)
                    Or (Local0, Local1, Local1)
                    Or (Local1, Local2, Local2)
                    Store (Local2, GBS4)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (^^PCI0.LPC0.EC.BD3E, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.BD3D, Local0)
                    Or (Local0, Local1, Local1)
                    Store (Local1, GBS5)
                }
                Else
                {
                    Store (0xFFFF, GBS1)
                    Store (0xFFFF, GBS2)
                    Store (0xFFFF, GBS3)
                    Store (0xFFFF, GBS4)
                    Store (0xFFFF, GBS5)
                }
            }

            Method (GSMB, 0, NotSerialized)
            {
                If (DCPF)
                {
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDWD, ^^PCI0.LPC0.EC.BADR, 0x1C), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, 0x1A))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, 0x1B))
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDWD, ^^PCI0.LPC0.EC.BADR, 0x1B), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, 0x18))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, 0x19))
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDBL, ^^PCI0.LPC0.EC.BADR, 0x20), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, 0x0C))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, 0x0D))
                    Store (DerefOf (Index (HMTP, 0x02)), Index (HMBB, 0x0E))
                    Store (DerefOf (Index (HMTP, 0x03)), Index (HMBB, 0x0F))
                    Store (DerefOf (Index (HMTP, 0x04)), Index (HMBB, 0x10))
                    Store (DerefOf (Index (HMTP, 0x05)), Index (HMBB, 0x11))
                    Store (DerefOf (Index (HMTP, 0x06)), Index (HMBB, 0x12))
                    Store (DerefOf (Index (HMTP, 0x07)), Index (HMBB, 0x13))
                    Store (DerefOf (Index (HMTP, 0x08)), Index (HMBB, 0x14))
                    Store (DerefOf (Index (HMTP, 0x09)), Index (HMBB, 0x15))
                    Store (DerefOf (Index (HMTP, 0x0A)), Index (HMBB, 0x16))
                    Store (DerefOf (Index (HMTP, 0x0B)), Index (HMBB, 0x17))
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDBL, ^^PCI0.LPC0.EC.BADR, 0x30), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, Zero))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, One))
                    Store (DerefOf (Index (HMTP, 0x02)), Index (HMBB, 0x02))
                    Store (DerefOf (Index (HMTP, 0x03)), Index (HMBB, 0x03))
                    Store (DerefOf (Index (HMTP, 0x04)), Index (HMBB, 0x04))
                    Store (DerefOf (Index (HMTP, 0x05)), Index (HMBB, 0x05))
                    Store (DerefOf (Index (HMTP, 0x06)), Index (HMBB, 0x06))
                    Store (DerefOf (Index (HMTP, 0x07)), Index (HMBB, 0x07))
                    Store (DerefOf (Index (HMTP, 0x08)), Index (HMBB, 0x08))
                    Store (DerefOf (Index (HMTP, 0x09)), Index (HMBB, 0x09))
                    Store (DerefOf (Index (HMTP, 0x0A)), Index (HMBB, 0x0A))
                    Store (DerefOf (Index (HMTP, 0x0B)), Index (HMBB, 0x0B))
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDWD, ^^PCI0.LPC0.EC.BADR, 0x17), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), CYCT)
                }
            }

            Method (PINT, 0, NotSerialized)
            {
                If (^^PCI0.LPC0.EC.DCPS (Zero))
                {
                    Store (One, ISDC)
                }
                Else
                {
                    Store (Zero, ISDC)
                }

                If (^^PCI0.LPC0.EC.ACPS ())
                {
                    Store (One, ISAC)
                }
                Else
                {
                    Store (Zero, ISAC)
                }

                GBIF ()
                GSMB ()
                PTET ()
            }

            Method (GBNL, 0, NotSerialized)
            {
                Store (BRTL, Local1)
                ShiftLeft (Local1, 0x0D, BRIL)
            }

            Method (GPCT, 1, NotSerialized)
            {
                If (LEqual (ToInteger (Arg0), Zero))
                {
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (Local1, CNT1)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (^^PCI0.LPC0.EC.RRAM (0x07C8), Local0)
                    ShiftLeft (Local0, 0x18, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.RRAM (0x07C9), Local0)
                    ShiftLeft (Local0, 0x10, Local0)
                    Or (Local0, Local1, Local1)
                    Store (PBT4, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.RRAM (0x07CB), Local0)
                    ShiftLeft (Local0, Zero, Local0)
                    Or (Local0, Local1, Local1)
                    Store (Local1, CNT2)
                }

                If (LEqual (ToInteger (Arg0), One))
                {
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    Store (^^PCI0.LPC0.EC.RRAM (0x07CC), Local0)
                    ShiftLeft (Local0, Zero, Local0)
                    Or (Local0, Local1, Local1)
                    Store (Local1, CNT3)
                }

                If (LEqual (ToInteger (Arg0), 0x02))
                {
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    ShiftLeft (Local0, 0x18, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local0, 0x10, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local0, Zero, Local0)
                    Or (Local0, Local1, Local1)
                    Store (Local1, CNT4)
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    ShiftLeft (Local0, 0x18, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local0, 0x10, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local0, 0x08, Local0)
                    Or (Local0, Local1, Local1)
                    ShiftLeft (Local0, Zero, Local0)
                    Or (Local0, Local1, Local1)
                    Store (Local1, CNT5)
                }
            }

            Method (CPCT, 1, NotSerialized)
            {
                If (LEqual (ToInteger (Arg0), Zero))
                {
                    Store (Zero, EXPC)
                    ^^PCI0.LPC0.EC.WRAM (0x07C8, Zero)
                    ^^PCI0.LPC0.EC.WRAM (0x07C9, Zero)
                    Store (Zero, PBT4)
                    ^^PCI0.LPC0.EC.WRAM (0x07CB, Zero)
                }

                If (LEqual (ToInteger (Arg0), One))
                {
                    ^^PCI0.LPC0.EC.WRAM (0x07CC, Zero)
                }

                If (LEqual (ToInteger (Arg0), 0x02)) {}
            }

            Method (MLED, 0, Serialized)
            {
                If (RGPL (0xD3, One))
                {
                    SGPL (0xAB, One, One)
                }
                Else
                {
                    If (RGPL (0xD2, One))
                    {
                        SGPL (0xAB, One, One)
                    }
                    Else
                    {
                        SGPL (0xAB, One, Zero)
                    }
                }
            }

            Method (HMB1, 0, NotSerialized)
            {
                If (DCPF)
                {
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDWD, ^^PCI0.LPC0.EC.BADR, 0x1C), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, 0x1A))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, 0x1B))
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDWD, ^^PCI0.LPC0.EC.BADR, 0x1B), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, 0x18))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, 0x19))
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDBL, ^^PCI0.LPC0.EC.BADR, 0x20), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, 0x0C))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, 0x0D))
                    Store (DerefOf (Index (HMTP, 0x02)), Index (HMBB, 0x0E))
                    Store (DerefOf (Index (HMTP, 0x03)), Index (HMBB, 0x0F))
                    Store (DerefOf (Index (HMTP, 0x04)), Index (HMBB, 0x10))
                    Store (DerefOf (Index (HMTP, 0x05)), Index (HMBB, 0x11))
                    Store (DerefOf (Index (HMTP, 0x06)), Index (HMBB, 0x12))
                    Store (DerefOf (Index (HMTP, 0x07)), Index (HMBB, 0x13))
                    Store (DerefOf (Index (HMTP, 0x08)), Index (HMBB, 0x14))
                    Store (DerefOf (Index (HMTP, 0x09)), Index (HMBB, 0x15))
                    Store (DerefOf (Index (HMTP, 0x0A)), Index (HMBB, 0x16))
                    Store (DerefOf (Index (HMTP, 0x0B)), Index (HMBB, 0x17))
                    Store (Zero, Local0)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDBL, ^^PCI0.LPC0.EC.BADR, 0x30), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), HMTP)
                    Store (DerefOf (Index (HMTP, Zero)), Index (HMBB, Zero))
                    Store (DerefOf (Index (HMTP, One)), Index (HMBB, One))
                    Store (DerefOf (Index (HMTP, 0x02)), Index (HMBB, 0x02))
                    Store (DerefOf (Index (HMTP, 0x03)), Index (HMBB, 0x03))
                    Store (DerefOf (Index (HMTP, 0x04)), Index (HMBB, 0x04))
                    Store (DerefOf (Index (HMTP, 0x05)), Index (HMBB, 0x05))
                    Store (DerefOf (Index (HMTP, 0x06)), Index (HMBB, 0x06))
                    Store (DerefOf (Index (HMTP, 0x07)), Index (HMBB, 0x07))
                    Store (DerefOf (Index (HMTP, 0x08)), Index (HMBB, 0x08))
                    Store (DerefOf (Index (HMTP, 0x09)), Index (HMBB, 0x09))
                    Store (DerefOf (Index (HMTP, 0x0A)), Index (HMBB, 0x0A))
                    Store (DerefOf (Index (HMTP, 0x0B)), Index (HMBB, 0x0B))
                    Store (Zero, Local0)
                    Store (Zero, Local1)
                    Store (^^PCI0.LPC0.EC.SMBR (^^PCI0.LPC0.EC.RDWD, ^^PCI0.LPC0.EC.BADR, 0x17), Local0)
                    Store (DerefOf (Index (Local0, 0x02)), CYCT)
                    ShiftRight (CYCT, 0x08, Local0)
                    ShiftLeft (CYCT, 0x08, Local1)
                    Or (Local0, Local1, Local0)
                    And (Local0, 0xFFFF, Local0)
                    Store (Local0, CYCT)
                    Store (HMBB, Index (TST1, Zero))
                    Store (ToBCD (CYCT), Index (TST1, One))
                    Return (TST1)
                }
                Else
                {
                    Return (TST0)
                }
            }

            Method (HMB2, 0, NotSerialized)
            {
                Return (TST0)
            }

            Method (GLPS, 0, Serialized)
            {
                Return (LDRS)
            }

            Method (GMID, 0, Serialized)
            {
                And (LDSZ, One, Local0)
                If (Local0)
                {
                    Return (0x0615)
                }
                Else
                {
                    Return (0x0606)
                }
            }

            Method (HST1, 0, Serialized)
            {
                If (LEqual (CELT, One))
                {
                    If (LLess (OSTB, 0x40))
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (HST2, 0, Serialized)
            {
                If (LEqual (CELT, One))
                {
                    If (LLess (OSTB, 0x40))
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (HST3, 0, Serialized)
            {
                If (LEqual (CELT, One))
                {
                    If (LLess (OSTB, 0x40))
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (HST4, 0, Serialized)
            {
                If (LEqual (CELT, One))
                {
                    If (LLess (OSTB, 0x40))
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
                Else
                {
                    Return (Zero)
                }
            }
        }

        Scope (\)
        {
            Method (SGPL, 3, Serialized)
            {
                Store (Arg0, Local0)
                Store (Arg1, Local1)
                Store (Arg2, Local3)
                Store (Zero, Local4)
                While (Local1)
                {
                    Store (ShiftLeft (One, Local4), Local2)
                    If (And (Local2, Local3))
                    {
                        SGLV (Local0, One)
                    }
                    Else
                    {
                        SGLV (Local0, Zero)
                    }

                    Increment (Local0)
                    Decrement (Local1)
                    Increment (Local4)
                }
            }

            Method (RGPL, 2, Serialized)
            {
                Store (Arg0, Local0)
                Store (Arg1, Local1)
                Store (Zero, Local3)
                Store (Zero, Local4)
                While (Local1)
                {
                    If (RGLV (Local0))
                    {
                        Or (ShiftLeft (One, Local4), Local3, Local3)
                    }

                    Increment (Local0)
                    Decrement (Local1)
                    Increment (Local4)
                }

                Return (Local3)
            }

            Method (PTET, 0, NotSerialized)
            {
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0532), Local0)
                \_SB.PCI0.LPC0.EC.WRAM (0x07B8, Local0)
                Store (\_SB.PCI0.LPC0.EC.RRAM (0x0534), Local0)
                \_SB.PCI0.LPC0.EC.WRAM (0x07B7, Local0)
            }

            Method (RGLV, 1, Serialized)
            {
                Add (Arg0, 0xFED80100, Local0)
                OperationRegion (GLVX, SystemMemory, Local0, 0x08)
                Field (GLVX, ByteAcc, Lock, Preserve)
                {
                    GPXX,   8
                }

                If (And (GPXX, 0x80))
                {
                    Return (One)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (SGLV, 2, Serialized)
            {
                Add (Arg0, 0xFED80100, Local0)
                OperationRegion (GLVX, SystemMemory, Local0, 0x08)
                Field (GLVX, ByteAcc, Lock, Preserve)
                {
                    GPXX,   8
                }

                If (Arg1)
                {
                    Or (GPXX, 0x40, GPXX)
                }
                Else
                {
                    And (GPXX, 0xBF, GPXX)
                }
            }

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

            Method (OWLD, 1, Serialized)
            {
                Store (Arg0, WRST)
                SGPL (0xD3, One, Arg0)
                \_SB.PCI0.LPC0.EC.RPIN (0x08, 0x07)
                SGPL (0xAB, One, Arg0)
            }

            Method (OBTD, 1, Serialized)
            {
                Store (Arg0, BRST)
                SGPL (0xD2, One, Arg0)
            }

            Method (OHWR, 0, Serialized)
            {
                Store (Zero, Local0)
                If (BTDP)
                {
                    Or (Local0, 0x0100, Local0)
                }

                If (WLDP)
                {
                    Or (Local0, 0x80, Local0)
                }

                Return (Local0)
            }
        }

        Scope (\_SB)
        {
        }
    }
}