← Back to team overview

sony-vaio-z-series team mailing list archive

Re: Call to provide DSDT tables

 

On Sa, 21 Mär 2009, Albert Vilella wrote:
> sudo acpidump > acpidump.txt
> sudo acpixtract acpidump.txt
> iasl -d DSDT.dat
> 
> This will create a DSDT.dsl file that you can attach to your reply email.

Sony VGN-Z11VN

kernel 2.6.29-rc8
sony-acpi module kernel+patch from matthew + my patch

Best wishes

Norbert

-------------------------------------------------------------------------------
Dr. Norbert Preining <preining@xxxxxxxx>        Vienna University of Technology
Debian Developer <preining@xxxxxxxxxx>                         Debian TeX Group
gpg DSA: 0x09C5B094      fp: 14DF 2E6C 0307 BE6D AD76  A9C0 D2BF 4AA3 09C5 B094
-------------------------------------------------------------------------------
LOWTHER (vb.)
(Of a large group of people who have been to the cinema together.) To
stand aimlessly about on the pavement and argue about whatever to go
and eat either a Chinese meal nearby or an Indian meal at a restaurant
which somebody says is very good but isn't certain where it is, or
have a drink and think about it, or just go home, or have a Chinese
meal nearby - until by the time agreement is reached everything is
shut.
			--- Douglas Adams, The Meaning of Liff
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20061109
 *
 * Disassembly of DSDT.dat, Sun Mar 22 21:16:11 2009
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x0000B012 (45074)
 *     Revision         0x01
 *     OEM ID           "Sony"
 *     OEM Table ID     "VAIO"
 *     OEM Revision     0x20081218 (537399832)
 *     Creator ID       "MSFT"
 *     Creator Revision 0x01000013 (16777235)
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "Sony", "VAIO", 0x20081218)
{
    External (PDC1)
    External (PDC0)

    Name (SP2O, 0x4E)
    Name (SP1O, 0x164E)
    Name (IO1B, 0x0600)
    Name (IO1L, 0x70)
    Name (IO2B, 0x0680)
    Name (IO2L, 0x20)
    Name (IO3B, 0x0290)
    Name (IO3L, 0x10)
    Name (MCHB, 0xFED10000)
    Name (MCHL, 0x4000)
    Name (EGPB, 0xFED19000)
    Name (EGPL, 0x1000)
    Name (DMIB, 0xFED18000)
    Name (DMIL, 0x1000)
    Name (IFPB, 0xFED14000)
    Name (IFPL, 0x1000)
    Name (PEBS, 0xE0000000)
    Name (PELN, 0x10000000)
    Name (TTTB, 0xFED20000)
    Name (TTTL, 0x00020000)
    Name (SMBS, 0xEFA0)
    Name (PBLK, 0x0410)
    Name (PMBS, 0x0400)
    Name (PMLN, 0x80)
    Name (LVL2, 0x0414)
    Name (LVL3, 0x0415)
    Name (LVL4, 0x0416)
    Name (SMIP, 0xB2)
    Name (GPBS, 0x0500)
    Name (GPLN, 0x40)
    Name (APCB, 0xFEC00000)
    Name (APCL, 0x1000)
    Name (PM30, 0x0430)
    Name (SRCB, 0xFED1C000)
    Name (SRCL, 0x4000)
    Name (SUSW, 0xFF)
    Name (ACPH, 0xDE)
    Name (ASSB, Zero)
    Name (AOTB, Zero)
    Name (AAXB, Zero)
    Name (PEHP, One)
    Name (SHPC, One)
    Name (PEPM, One)
    Name (PEER, One)
    Name (PECS, One)
    Name (ITKE, Zero)
    Name (TRTP, One)
    Name (TRTD, 0x02)
    Name (TRTI, 0x03)
    Name (TRTA, 0x04)
    Name (GCDD, One)
    Name (DSTA, 0x0A)
    Name (DSLO, 0x0C)
    Name (DSLC, 0x0E)
    Name (PITS, 0x10)
    Name (SBCS, 0x12)
    Name (SALS, 0x13)
    Name (LSSS, 0x2A)
    Name (PSSS, 0x2B)
    Name (SOOT, 0x35)
    Name (ESCS, 0x48)
    Name (PDBR, 0x4D)
    Name (SMBL, 0x10)
    Name (STRP, 0xF0)
    Mutex (LSTP, 0x00)
    Name (ECOK, Zero)
    OperationRegion (GPIO, SystemIO, 0x0500, 0x40)
    Field (GPIO, ByteAcc, NoLock, Preserve)
    {
                Offset (0x0C), 
            ,   9, 
        GPO9,   1, 
                Offset (0x38), 
            ,   1, 
            ,   1, 
        CPEN,   1
    }

    OperationRegion (PMBA, SystemIO, 0x0400, 0x80)
    Field (PMBA, ByteAcc, NoLock, Preserve)
    {
                Offset (0x28), 
            ,   2, 
        SPST,   1, 
                Offset (0x42), 
            ,   1, 
        GPEC,   1, 
                Offset (0x64), 
            ,   9, 
        SCIS,   1, 
                Offset (0x66)
    }

    OperationRegion (RCRB, SystemMemory, 0xFED1C000, 0x4000)
    Field (RCRB, DWordAcc, Lock, Preserve)
    {
                Offset (0x1000), 
                Offset (0x3000), 
                Offset (0x3404), 
        HPAS,   2, 
            ,   5, 
        HPAE,   1, 
                Offset (0x3418), 
            ,   1, 
        PATD,   1, 
        SATD,   1, 
        SMBD,   1, 
        HDAD,   1, 
                Offset (0x341A), 
        RP1D,   1, 
        RP2D,   1, 
        RP3D,   1, 
        RP4D,   1, 
        RP5D,   1, 
        RP6D,   1
    }

    OperationRegion (MBOX, SystemMemory, 0xBBBBEC18, 0x000002BC)
    Field (MBOX, AnyAcc, NoLock, Preserve)
    {
        PCI1,   8, 
        PCI2,   8, 
        PCI3,   8, 
        PCI4,   8, 
        PCI5,   8, 
        PCI6,   8, 
        PCI7,   8, 
        PCI8,   8, 
        NLCK,   8, 
        ZIPE,   8, 
        COMA,   8, 
        CAIO,   8, 
        CAIP,   8, 
        CAMD,   8, 
        CADA,   8, 
        COMB,   8, 
        CBIO,   8, 
        CBIP,   8, 
        CBMD,   8, 
        CBDA,   8, 
        FHSD,   8, 
        COMC,   8, 
        CCIO,   8, 
        CCIP,   8, 
        CCMD,   8, 
        CCDA,   8, 
        COMD,   8, 
        CDIO,   8, 
        CDIP,   8, 
        CDMD,   8, 
        CDDA,   8, 
        LPT1,   8, 
        L1IO,   8, 
        L1IP,   8, 
        L1MD,   8, 
        L1DA,   8, 
        LPT2,   8, 
        L2IO,   8, 
        L2IP,   8, 
        L2MD,   8, 
        L2DA,   8, 
        LPT3,   8, 
        L3IO,   8, 
        L3IP,   8, 
        L3MD,   8, 
        L3DA,   8, 
        FDDC,   8, 
        FDWP,   8, 
        HGMP,   8, 
        LGMP,   8, 
        MIDI,   8, 
        AZLA,   8, 
        AUDO,   8, 
        MODM,   8, 
        IDEC,   8, 
        SSED,   8, 
        PACT,   8, 
        SCFG,   8, 
        AMOD,   8, 
        IMOD,   8, 
        LCFG,   8, 
        IDLY,   8, 
        PMTP,   8, 
        PMIO,   8, 
        PMBM,   8, 
        PMTM,   8, 
        PSTP,   8, 
        PSIO,   8, 
        PSBM,   8, 
        PSTM,   8, 
        IDE0,   8, 
        IDE1,   8, 
        IDE2,   8, 
        IDE3,   8, 
        IDE4,   8, 
        IDE5,   8, 
        IDE6,   8, 
        IDE7,   8, 
        HIUB,   8, 
        LUBS,   8, 
        PLYT,   8, 
        EDCG,   8, 
        SDFY,   8, 
        SDTC,   8, 
        SDRP,   8, 
        SDCL,   8, 
        SDRC,   8, 
        SDRE,   8, 
        FC2L,   8, 
        FC3L,   8, 
        FCS4,   8, 
        APIM,   8, 
        HPTS,   8, 
        HPTA,   8, 
        EMAS,   8, 
        VGAO,   8, 
        SOFF,   8, 
        KBPO,   8, 
        MSPO,   8, 
        USBB,   8, 
        EVTL,   8, 
        SYBE,   8, 
        ETLC,   8, 
        AC30,   8, 
        TPMD,   8, 
        TPMO,   8, 
        TPMC,   8, 
        TPMM,   8, 
        TPCC,   8, 
        TPLC,   8, 
        TPLR,   32, 
        QBOT,   8, 
        BOTQ,   8, 
        PBOT,   8, 
        M256,   8, 
        PEGF,   8, 
        OSYS,   16, 
        BMTP,   8, 
        BNPT,   8, 
        LNMT,   8, 
        NBTO,   8, 
        NABD,   8, 
        NEBD,   8, 
        NLBD,   8, 
        DFBT,   16, 
        NPSP,   16, 
        LANG,   8, 
        UACL,   8, 
        SUPS,   8, 
        DVET,   8, 
        S3RS,   8, 
        DAS1,   8, 
        DAS3,   8, 
        WKPM,   8, 
        WKMD,   8, 
        WKS5,   8, 
        HOUR,   8, 
        MINS,   8, 
        SECS,   8, 
        DOFM,   8, 
        NBTV,   32, 
        BTOD,   32, 
        SPVP,   16, 
        POPW,   8, 
        USPW,   16, 
        HDPW,   16, 
        KRSV,   552, 
        LANE,   8, 
        AORS,   8, 
        P0HP,   8, 
        P1HP,   8, 
        P4HP,   8, 
        P5HP,   8, 
        P0IL,   8, 
        P1IL,   8, 
        P2IL,   8, 
        PEGS,   8, 
        D2F1,   8, 
        IGMT,   8, 
        DTSZ,   8, 
        CLKC,   8, 
        CKSC,   8, 
        BOTT,   8, 
        PANT,   8, 
        TVTP,   8, 
        U201,   8, 
        U202,   8, 
        U111,   8, 
        U112,   8, 
        U113,   8, 
        U114,   8, 
        U115,   8, 
        UPPC,   8, 
        UP00,   8, 
        UP01,   8, 
        UP02,   8, 
        UP03,   8, 
        UP04,   8, 
        UP05,   8, 
        UP06,   8, 
        UP07,   8, 
        UP08,   8, 
        UP09,   8, 
        UP10,   8, 
        UP11,   8, 
        P80R,   8, 
        WDOG,   8, 
        WDTO,   16, 
        WDTB,   16, 
        MASF,   8, 
        MAMT,   8, 
        ABXP,   8, 
        SPIL,   8, 
        PWDW,   8, 
        HETO,   8, 
        AWTR,   16, 
        EOPT,   8, 
        ASFB,   8, 
        MBTX,   8, 
        IDER,   8, 
        SOLE,   8, 
        PRE0,   8, 
        PRE1,   8, 
        PRE2,   8, 
        PRE3,   8, 
        PRE4,   8, 
        PRE5,   8, 
        PRA0,   8, 
        PRA1,   8, 
        PRA2,   8, 
        PRA3,   8, 
        PRA4,   8, 
        PRA5,   8, 
        PRV0,   8, 
        PRV1,   8, 
        PRV2,   8, 
        PRV3,   8, 
        PRV4,   8, 
        PRV5,   8, 
        PAA0,   8, 
        PAA1,   8, 
        PAA2,   8, 
        PAA3,   8, 
        PAA4,   8, 
        PAA5,   8, 
        L0S0,   8, 
        L0S1,   8, 
        L0S2,   8, 
        L0S3,   8, 
        L0S4,   8, 
        L0S5,   8, 
        AL10,   8, 
        AL11,   8, 
        AL12,   8, 
        AL13,   8, 
        AL14,   8, 
        AL15,   8, 
        PES0,   8, 
        PES1,   8, 
        PES2,   8, 
        PES3,   8, 
        PES4,   8, 
        PES5,   8, 
        PRU0,   8, 
        PRU1,   8, 
        PRU2,   8, 
        PRU3,   8, 
        PRU4,   8, 
        PRU5,   8, 
        PRF0,   8, 
        PRF1,   8, 
        PRF2,   8, 
        PRF3,   8, 
        PRF4,   8, 
        PRF5,   8, 
        PRN0,   8, 
        PRN1,   8, 
        PRN2,   8, 
        PRN3,   8, 
        PRN4,   8, 
        PRN5,   8, 
        PRC0,   8, 
        PRC1,   8, 
        PRC2,   8, 
        PRC3,   8, 
        PRC4,   8, 
        PRC5,   8, 
        CTD0,   8, 
        CTD1,   8, 
        CTD2,   8, 
        CTD3,   8, 
        CTD4,   8, 
        CTD5,   8, 
        PIE0,   8, 
        PIE1,   8, 
        PIE2,   8, 
        PIE3,   8, 
        PIE4,   8, 
        PIE5,   8, 
        SFE0,   8, 
        SFE1,   8, 
        SFE2,   8, 
        SFE3,   8, 
        SFE4,   8, 
        SFE5,   8, 
        SNE0,   8, 
        SNE1,   8, 
        SNE2,   8, 
        SNE3,   8, 
        SNE4,   8, 
        SNE5,   8, 
        SCE0,   8, 
        SCE1,   8, 
        SCE2,   8, 
        SCE3,   8, 
        SCE4,   8, 
        SCE5,   8, 
        MCE0,   8, 
        MCE1,   8, 
        MCE2,   8, 
        MCE3,   8, 
        MCE4,   8, 
        MCE5,   8, 
        PCE0,   8, 
        PCE1,   8, 
        PCE2,   8, 
        PCE3,   8, 
        PCE4,   8, 
        PCE5,   8, 
        PTC0,   8, 
        PTC1,   8, 
        PTC2,   8, 
        PTC3,   8, 
        PTC4,   8, 
        PTC5,   8, 
        DAPM,   8, 
        DPMA,   8, 
        DL0S,   8, 
        DAL1,   8, 
        PEGA,   8, 
        PGAA,   8, 
        PGL0,   8, 
        PL0A,   8, 
        PGL1,   8, 
        PGES,   8, 
        PAVP,   8, 
        ISTC,   8, 
        TRML,   8, 
        FNON,   8, 
        TRON,   8, 
        NXMD,   8, 
        PCRR,   8, 
        C4EN,   8, 
        C43D,   8, 
        EMTT,   8, 
        PROH,   8, 
        DFSB,   8, 
        TUBM,   8, 
        TSTE,   8, 
        BPST,   8, 
        QKS4,   8, 
        POPU,   8, 
        POPD,   8, 
        C4ET,   8, 
        NXFE,   8, 
        VTST,   8, 
        VTFE,   8, 
        S5FG,   8, 
        CSTS,   8, 
        ENCS,   8, 
        DEC4,   8, 
        HC4E,   8, 
        ENC6,   8, 
        CSTR,   8, 
        CMPE,   8, 
        CSMD,   8, 
        DTSE,   8, 
        DTSC,   8, 
        RAID,   8, 
        PSHM,   8, 
        PEXC,   8, 
        DTST,   8, 
        TXTS,   8, 
        VTDE,   8, 
        SMRR,   8, 
        CART,   8, 
        CATT,   8, 
        ITPM,   8, 
        STBE,   8, 
        PEBE,   8, 
        PCBE,   8, 
        EHBE,   8, 
        UHBE,   8, 
        HABE,   8, 
        MTME,   8, 
        MTSD,   8, 
        MTML,   8, 
        ERS2,   8, 
        GLPM,   8, 
        CRSV,   520, 
                Offset (0x23C), 
        ORSV,   224, 
        DRSV,   800
    }

    OperationRegion (IO_T, SystemIO, 0x0800, 0x10)
    Field (IO_T, ByteAcc, NoLock, Preserve)
    {
                Offset (0x02), 
                Offset (0x04), 
                Offset (0x06), 
                Offset (0x08), 
        TRP0,   8, 
                Offset (0x0A), 
                Offset (0x0B), 
                Offset (0x0C), 
                Offset (0x0D), 
                Offset (0x0E), 
                Offset (0x0F), 
                Offset (0x10)
    }

    OperationRegion (IO_D, SystemIO, 0x0810, 0x08)
    Field (IO_D, ByteAcc, NoLock, Preserve)
    {
        TRPD,   8
    }

    OperationRegion (IO_H, SystemIO, 0x0820, 0x04)
    Field (IO_H, ByteAcc, NoLock, Preserve)
    {
        TRPH,   8
    }

    OperationRegion (NVST, SystemMemory, 0xBBBBEED4, 0x000000D8)
    Field (NVST, AnyAcc, Lock, Preserve)
    {
        SMIF,   8, 
        PRM0,   8, 
        PRM1,   8, 
        SCIF,   8, 
        PRM2,   8, 
        PRM3,   8, 
        LCKF,   8, 
        PRM4,   8, 
        PRM5,   8, 
        P80D,   32, 
        LIDS,   8, 
        PWRS,   8, 
        DBGS,   8, 
        THOF,   8, 
        ACT1,   8, 
        ACTT,   8, 
        CRTT,   8, 
                Offset (0x15), 
        DTS1,   8, 
        DTS2,   8, 
        DTSF,   8, 
        BNUM,   8, 
        APIC,   8, 
        PCP0,   8, 
        PCP1,   8, 
        PPCM,   8, 
        PPMF,   32, 
        IGDS,   8, 
        TLST,   8, 
        CADL,   8, 
        PADL,   8, 
        CSTE,   16, 
        NSTE,   16, 
        SSTE,   16, 
        NDID,   8, 
        DID1,   32, 
        DID2,   32, 
        DID3,   32, 
        DID4,   32, 
        DID5,   32, 
        BDSP,   8, 
        PTY1,   8, 
        PTY2,   8, 
        PSCL,   8, 
        TVF1,   8, 
        TVF2,   8, 
        GETM,   8, 
        BLCS,   8, 
        BRTL,   8, 
        ALSE,   8, 
        ALAF,   8, 
        LLOW,   8, 
        LHIH,   8, 
        EMAE,   8, 
        EMAP,   16, 
        EMAL,   16, 
        MEFE,   8, 
        DSTS,   8, 
        TPMP,   8, 
        TPME,   8, 
        GTF0,   56, 
        GTF2,   56, 
        IDEM,   8, 
        GTF1,   56, 
        BID,    8, 
        ASLB,   32, 
        IBTT,   8, 
        IPAT,   8, 
        ITVF,   8, 
        ITVM,   8, 
        IPSC,   8, 
        IBLC,   8, 
        IBIA,   8, 
        ISSC,   8, 
        I409,   8, 
        I509,   8, 
        I609,   8, 
        I709,   8, 
        IDMM,   8, 
        IDMS,   8, 
        IF1E,   8, 
        HVCO,   8, 
        NXD1,   32, 
        NXD2,   32, 
        NXD3,   32, 
        NXD4,   32, 
        NXD5,   32, 
        NXD6,   32, 
        NXD7,   32, 
        NXD8,   32, 
        GSMI,   8, 
        DSEN,   8, 
        ECON,   8, 
        GPIC,   8, 
        CTYP,   8, 
        L01C,   8, 
        VFN0,   8, 
        VFN1,   8, 
        LCDA,   16, 
        BVAL,   32, 
        KSV0,   32, 
        KSV1,   8, 
        STSF,   8, 
        STP0,   32, 
        STP1,   32, 
        LCDB,   8, 
        EDPT,   32, 
        VBPT,   32, 
        HPI0,   32, 
        HPI1,   32, 
        HPO0,   32, 
        HPO1,   32, 
        SMIO,   16
    }

    Scope (_PR)
    {
        Processor (CPU0, 0x01, 0x00000410, 0x06) {}
        Processor (CPU1, 0x02, 0x00000410, 0x06) {}
        Processor (CPU2, 0x03, 0x00000410, 0x06) {}
        Processor (CPU3, 0x04, 0x00000410, 0x06) {}
    }

    OperationRegion (PRT0, SystemIO, 0x80, 0x04)
    Field (PRT0, DWordAcc, Lock, Preserve)
    {
        P80H,   32
    }

    Method (P8XH, 2, Serialized)
    {
        If (LEqual (Arg0, Zero))
        {
            Store (Or (And (P80D, 0xFFFFFF00), Arg1), P80D)
        }

        If (LEqual (Arg0, One))
        {
            Store (Or (And (P80D, 0xFFFF00FF), ShiftLeft (Arg1, 0x08)
                ), P80D)
        }

        If (LEqual (Arg0, 0x02))
        {
            Store (Or (And (P80D, 0xFF00FFFF), ShiftLeft (Arg1, 0x10)
                ), P80D)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (Or (And (P80D, 0x00FFFFFF), ShiftLeft (Arg1, 0x18)
                ), P80D)
        }

        Store (P80D, P80H)
    }

    OperationRegion (SPRT, SystemIO, 0xB2, 0x02)
    Field (SPRT, ByteAcc, Lock, Preserve)
    {
        SSMP,   8
    }

    Method (TRAP, 2, Serialized)
    {
        Store (Arg1, SMIF)
        If (LEqual (Arg0, TRTP))
        {
            Store (Zero, TRP0)
        }

        If (LEqual (Arg0, TRTD))
        {
            Store (Arg1, DTSF)
            Store (Zero, TRPD)
            Return (DTSF)
        }

        If (LEqual (Arg0, TRTA))
        {
            Store (Zero, TRPH)
        }

        Return (SMIF)
    }

    OperationRegion (CMS1, SystemIO, 0x72, 0x02)
    Field (CMS1, ByteAcc, NoLock, Preserve)
    {
        CMSI,   8, 
        CMSD,   8
    }

    Method (CMSW, 2, NotSerialized)
    {
        Store (Arg0, CMSI)
        Store (Arg1, CMSD)
    }

    Method (PNOT, 0, Serialized)
    {
        If (CMPE)
        {
            If (And (PDC0, 0x08))
            {
                Notify (\_PR.CPU0, 0x80)
                If (And (PDC0, 0x10))
                {
                    Sleep (0x64)
                    Notify (\_PR.CPU0, 0x81)
                }
            }

            If (And (PDC1, 0x08))
            {
                Notify (\_PR.CPU1, 0x80)
                If (And (PDC1, 0x10))
                {
                    Sleep (0x64)
                    Notify (\_PR.CPU1, 0x81)
                }
            }
        }
        Else
        {
            Notify (\_PR.CPU0, 0x80)
            Sleep (0x64)
            Notify (\_PR.CPU0, 0x81)
        }
    }

    Method (ISTP, 2, Serialized)
    {
        Acquire (LSTP, 0xFFFF)
        Store (Arg0, STSF)
        Store (Arg1, STP0)
        TRAP (TRTA, STRP)
        Store (STP0, Local0)
        Release (LSTP)
        Return (Local0)
    }

    OperationRegion (SHEC, SystemIO, 0x2000, 0x08)
    Field (SHEC, ByteAcc, Lock, Preserve)
    {
        SHDP,   8, 
                Offset (0x04), 
        SHCP,   8, 
                Offset (0x08)
    }

    Method (SHSC, 1, Serialized)
    {
        While (And (SHCP, 0x02))
        {
            Noop
        }

        Store (Arg0, SHCP)
        While (And (SHCP, 0x02))
        {
            Noop
        }
    }

    Method (SHSD, 1, Serialized)
    {
        While (And (SHCP, 0x02))
        {
            Noop
        }

        Store (Arg0, SHDP)
        While (And (SHCP, 0x02))
        {
            Noop
        }
    }

    Method (SHRD, 0, Serialized)
    {
        While (LNot (And (SHCP, One)))
        {
            Noop
        }

        Return (SHDP)
    }

    Mutex (LSHE, 0x00)
    Method (RECS, 1, Serialized)
    {
        Acquire (LSHE, 0xFFFF)
        SHSC (0x92)
        SHSD (Arg0)
        Store (SHRD (), Local0)
        Release (LSHE)
        Return (Local0)
    }

    Method (CIUL, 1, Serialized)
    {
        Acquire (LSHE, 0xFFFF)
        SHSC (0x93)
        SHSD (Arg0)
        Release (LSHE)
    }

    Method (SPIR, 2, Serialized)
    {
        Acquire (LSHE, 0xFFFF)
        SHSC (0x94)
        SHSD (Arg0)
        SHSC (0x95)
        SHSD (Arg1)
        Release (LSHE)
    }

    Method (_PTS, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x03))
        {
            Store (0x53, P80H)
            \_SB.PCI0.LPC.SPIC.SAVE ()
        }

        If (LEqual (Arg0, 0x04))
        {
            CMSW (0x3F, 0x3F)
            \_SB.PCI0.LPC.SPIC.SAVE ()
        }

        If (ECON)
        {
            Store (\_SB.PCI0.LPC.H8EC.DCKS, \_SB.DOCK.BDKS)
        }
        Else
        {
            And (RECS (0x04), 0x10, \_SB.DOCK.BDKS)
        }

        Store (Zero, \_SB.PCI0.LPC.H8EC.DWKC)
        If (LEqual (Arg0, 0x03))
        {
            Store (\_SB.PCI0.LANC.WOLS, GPO9)
        }
        Else
        {
            Store (Zero, GPO9)
        }

        HGSH (Arg0)
        Return (Zero)
    }

    Method (_WAK, 1, NotSerialized)
    {
        If (LEqual (RP1D, Zero))
        {
            Notify (\_SB.PCI0.EXP1, Zero)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (0xE3, P80H)
            \_SB.PCI0.LPC.SPIC.RSTR ()
            If (ECON)
            {
                Store (\_SB.PCI0.LPC.H8EC.SWUR, Local0)
            }
            Else
            {
                Store (RECS (0x22), Local0)
            }

            If (LNotEqual (Local0, 0x02))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0xE4, P80H)
            \_SB.PCI0.LPC.SPIC.RSTR ()
            Notify (\_SB.PWRB, 0x02)
        }

        \_SB.DOCK.DWAK (Arg0)
        Store (One, GPO9)
        Store (Zero, \_SB.PCI0.LPC.SNC.ENCR)
        Store (Zero, \_SB.PCI0.LPC.SNC.ESR)
        Store (Zero, \_SB.PCI0.LPC.SNC.ECR)
        Store (Zero, \_SB.PCI0.LPC.H8EC.HKEV)
        HGWH (Arg0)
        If (LAnd (DTSE, CMPE))
        {
            Store (0x14, DTSF)
            Store (Zero, TRPD)
        }

        Return (Zero)
    }

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

    Name (_S4, Package (0x04)
    {
        0x06, 
        0x06, 
        Zero, 
        Zero
    })
    Name (_S5, Package (0x04)
    {
        0x07, 
        0x07, 
        Zero, 
        Zero
    })
    Scope (_GPE)
    {
        Method (_L01, 0, NotSerialized)
        {
            Add (L01C, One, L01C)
            P8XH (Zero, One)
            P8XH (One, L01C)
            If (LNotEqual (\_SB.PCI0.EXP1.VDID, 0xFFFF))
            {
                If (LAnd (LEqual (RP1D, Zero), \_SB.PCI0.EXP1.HPSX))
                {
                    Sleep (0x64)
                    If (\_SB.PCI0.EXP1.PDCX)
                    {
                        Store (One, \_SB.PCI0.EXP1.PDCX)
                        Store (One, \_SB.PCI0.EXP1.HPSX)
                        Notify (\_SB.PCI0.EXP1, Zero)
                    }
                    Else
                    {
                        Store (One, \_SB.PCI0.EXP1.HPSX)
                    }
                }
            }

            If (LNotEqual (\_SB.PCI0.EXP2.VDID, 0xFFFF))
            {
                If (LAnd (LEqual (RP2D, Zero), \_SB.PCI0.EXP2.HPSX))
                {
                    Sleep (0x64)
                    If (\_SB.PCI0.EXP2.PDCX)
                    {
                        Store (One, \_SB.PCI0.EXP2.PDCX)
                        Store (One, \_SB.PCI0.EXP2.HPSX)
                        Notify (\_SB.PCI0.EXP2, Zero)
                    }
                    Else
                    {
                        Store (One, \_SB.PCI0.EXP2.HPSX)
                    }
                }
            }

            If (LNotEqual (\_SB.PCI0.EXP3.VDID, 0xFFFF))
            {
                If (LAnd (LEqual (RP3D, Zero), \_SB.PCI0.EXP3.HPSX))
                {
                    Sleep (0x64)
                    If (\_SB.PCI0.EXP3.PDCX)
                    {
                        Store (One, \_SB.PCI0.EXP3.PDCX)
                        Store (One, \_SB.PCI0.EXP3.HPSX)
                        Notify (\_SB.PCI0.EXP3, Zero)
                    }
                    Else
                    {
                        Store (One, \_SB.PCI0.EXP3.HPSX)
                    }
                }
            }

            If (LNotEqual (\_SB.PCI0.EXP4.VDID, 0xFFFF))
            {
                If (LAnd (LEqual (RP4D, Zero), \_SB.PCI0.EXP4.HPSX))
                {
                    Sleep (0x64)
                    If (\_SB.PCI0.EXP4.PDCX)
                    {
                        Store (One, \_SB.PCI0.EXP4.PDCX)
                        Store (One, \_SB.PCI0.EXP4.HPSX)
                    }
                    Else
                    {
                        Store (One, \_SB.PCI0.EXP4.HPSX)
                    }
                }
            }

            If (LNotEqual (\_SB.PCI0.EXP5.VDID, 0xFFFF))
            {
                If (LAnd (LEqual (RP5D, Zero), \_SB.PCI0.EXP5.HPSX))
                {
                    Sleep (0x64)
                    If (\_SB.PCI0.EXP5.PDCX)
                    {
                        Store (One, \_SB.PCI0.EXP5.PDCX)
                        Store (One, \_SB.PCI0.EXP5.HPSX)
                        Notify (\_SB.PCI0.EXP5, Zero)
                    }
                    Else
                    {
                        Store (One, \_SB.PCI0.EXP5.HPSX)
                    }
                }
            }

            If (LNotEqual (\_SB.PCI0.EXP6.VDID, 0xFFFF))
            {
                If (LAnd (LEqual (RP6D, Zero), \_SB.PCI0.EXP6.HPSX))
                {
                    Sleep (0x64)
                    If (\_SB.PCI0.EXP6.PDCX)
                    {
                        Store (One, \_SB.PCI0.EXP6.PDCX)
                        Store (One, \_SB.PCI0.EXP6.HPSX)
                        Notify (\_SB.PCI0.EXP6, Zero)
                    }
                    Else
                    {
                        Store (One, \_SB.PCI0.EXP6.HPSX)
                    }
                }
            }
        }

        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.UHC0, 0x02)
        }

        Method (_L04, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.UHC1, 0x02)
            Notify (\_SB.PCI0.UHC5, 0x02)
        }

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

        Method (_L06, 0, NotSerialized)
        {
            If (\_SB.PCI0.OVGA.GSSE)
            {
                \_SB.PCI0.OVGA.GSCI ()
            }
            Else
            {
                Store (One, SCIS)
            }
        }

        Method (_L09, 0, NotSerialized)
        {
            If (\_SB.PCI0.EXP1.PSPX)
            {
                Store (One, \_SB.PCI0.EXP1.PSPX)
                Store (One, \_SB.PCI0.EXP1.PMSX)
                Notify (\_SB.PCI0.EXP1, 0x02)
            }

            If (\_SB.PCI0.EXP2.PSPX)
            {
                Store (One, \_SB.PCI0.EXP2.PSPX)
                Store (One, \_SB.PCI0.EXP2.PMSX)
                Notify (\_SB.PCI0.EXP2, 0x02)
            }

            If (\_SB.PCI0.EXP3.PSPX)
            {
                Store (One, \_SB.PCI0.EXP3.PSPX)
                Store (One, \_SB.PCI0.EXP3.PMSX)
                Notify (\_SB.PCI0.EXP3, 0x02)
            }

            If (\_SB.PCI0.EXP4.PSPX)
            {
                Store (One, \_SB.PCI0.EXP4.PSPX)
                Store (One, \_SB.PCI0.EXP4.PMSX)
                Notify (\_SB.PCI0.EXP4, 0x02)
            }

            If (\_SB.PCI0.EXP5.PSPX)
            {
                Store (One, \_SB.PCI0.EXP5.PSPX)
                Store (One, \_SB.PCI0.EXP5.PMSX)
                Notify (\_SB.PCI0.EXP5, 0x02)
            }

            If (\_SB.PCI0.EXP6.PSPX)
            {
                Store (One, \_SB.PCI0.EXP6.PSPX)
                Store (One, \_SB.PCI0.EXP6.PMSX)
                Notify (\_SB.PCI0.EXP6, 0x02)
            }
        }

        Method (_L0B, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.P32, 0x02)
        }

        Method (_L0C, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.UHC2, 0x02)
        }

        Method (_L0D, 0, NotSerialized)
        {
            If (\_SB.PCI0.EHC1.PMES)
            {
                Store (One, \_SB.PCI0.EHC1.PMES)
                Notify (\_SB.PCI0.EHC1, 0x02)
            }

            If (\_SB.PCI0.EHC2.PMES)
            {
                Store (One, \_SB.PCI0.EHC2.PMES)
                Notify (\_SB.PCI0.EHC2, 0x02)
            }

            If (\_SB.PCI0.LANC.PMES)
            {
                Store (One, \_SB.PCI0.LANC.PMES)
                Notify (\_SB.PCI0.LANC, 0x02)
            }
        }

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

        Method (_L18, 0, NotSerialized)
        {
        }

        Method (_L20, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.UHCR, 0x02)
        }
    }

    Method (_PIC, 1, NotSerialized)
    {
        Store (Arg0, GPIC)
    }

    Scope (_TZ)
    {
        ThermalZone (ATF0)
        {
            Method (_TMP, 0, Serialized)
            {
                If (ECON)
                {
                    Return (Add (0x0AAC, Multiply (\_SB.PCI0.LPC.H8EC.RTMP, 0x0A)))
                }
                Else
                {
                    Return (Add (0x0AAC, Multiply (RECS (Zero), 0x0A)))
                }
            }

            Method (_PSV, 0, Serialized)
            {
                If (ECON)
                {
                    Return (Add (0x0AAC, Multiply (\_SB.PCI0.LPC.H8EC.PSV, 0x0A)))
                }
                Else
                {
                    Return (Add (0x0AAC, Multiply (RECS (0x06), 0x0A)))
                }
            }

            Method (_CRT, 0, Serialized)
            {
                If (ECON)
                {
                    Return (Add (0x0AAC, Multiply (\_SB.PCI0.LPC.H8EC.CRT, 0x0A)))
                }
                Else
                {
                    Return (Add (0x0AAC, Multiply (RECS (0x05), 0x0A)))
                }
            }

            Method (_SCP, 1, Serialized)
            {
                Store (Arg0, CTYP)
            }

            Method (_PSL, 0, Serialized)
            {
                If (CMPE)
                {
                    Return (Package (0x02)
                    {
                        \_PR.CPU0, 
                        \_PR.CPU1
                    })
                }

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

            Name (_TC1, One)
            Name (_TC2, 0x02)
            Name (_TSP, 0x32)
        }
    }

    Method (GETP, 1, Serialized)
    {
        If (LEqual (And (Arg0, 0x09), Zero))
        {
            Return (Ones)
        }

        If (LEqual (And (Arg0, 0x09), 0x08))
        {
            Return (0x0384)
        }

        ShiftRight (And (Arg0, 0x0300), 0x08, Local0)
        ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)
        Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))
            ))
    }

    Method (GDMA, 5, Serialized)
    {
        If (Arg0)
        {
            If (Arg1)
            {
                Return (0x14)
            }

            If (Arg2)
            {
                Return (Multiply (Subtract (0x04, Arg3), 0x0F))
            }

            Return (Multiply (Subtract (0x04, Arg3), 0x1E))
        }

        Return (Ones)
    }

    Method (GETT, 1, Serialized)
    {
        Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02
            ), 0x03), And (Arg0, 0x03)))))
    }

    Method (GETF, 3, Serialized)
    {
        Name (TMPF, Zero)
        If (Arg0)
        {
            Or (TMPF, One, TMPF)
        }

        If (And (Arg2, 0x02))
        {
            Or (TMPF, 0x02, TMPF)
        }

        If (Arg1)
        {
            Or (TMPF, 0x04, TMPF)
        }

        If (And (Arg2, 0x20))
        {
            Or (TMPF, 0x08, TMPF)
        }

        If (And (Arg2, 0x4000))
        {
            Or (TMPF, 0x10, TMPF)
        }

        Return (TMPF)
    }

    Method (SETP, 3, Serialized)
    {
        If (LGreater (Arg0, 0xF0))
        {
            Return (0x08)
        }
        Else
        {
            If (And (Arg1, 0x02))
            {
                If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))
                {
                    Return (0x2301)
                }

                If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, One)))
                {
                    Return (0x2101)
                }
            }

            Return (0x1001)
        }
    }

    Method (SDMA, 1, Serialized)
    {
        If (LLessEqual (Arg0, 0x14))
        {
            Return (One)
        }

        If (LLessEqual (Arg0, 0x1E))
        {
            Return (0x02)
        }

        If (LLessEqual (Arg0, 0x2D))
        {
            Return (One)
        }

        If (LLessEqual (Arg0, 0x3C))
        {
            Return (0x02)
        }

        If (LLessEqual (Arg0, 0x5A))
        {
            Return (One)
        }

        Return (Zero)
    }

    Method (SETT, 3, Serialized)
    {
        If (And (Arg1, 0x02))
        {
            If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))
            {
                Return (0x0B)
            }

            If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, One)))
            {
                Return (0x09)
            }
        }

        Return (0x04)
    }

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

        Device (LID0)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                If (ECON)
                {
                    Store (^^PCI0.LPC.H8EC.LIDS, Local0)
                }
                Else
                {
                    Store (And (RECS (0x04), 0x02), Local0)
                }

                If (Local0)
                {
                    Store (Zero, LIDS)
                }
                Else
                {
                    Store (One, LIDS)
                }

                Return (LIDS)
            }
        }

        Name (SBIF, Package (0x0D)
        {
            Zero, 
            Ones, 
            Ones, 
            One, 
            Ones, 
            Ones, 
            0x78, 
            Zero, 
            One, 
            "", 
            "", 
            "Lion", 
            "Sony Corporation"
        })
        Name (SBST, Package (0x04)
        {
            One, 
            Ones, 
            Ones, 
            Ones
        })
        Device (BAT0)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, Zero)
            Name (_PCL, Package (0x01)
            {
                _SB
            })
            Method (_STA, 0, NotSerialized)
            {
                If (ECON)
                {
                    And (^^PCI0.LPC.H8EC.B0ST, One, Local0)
                }
                Else
                {
                    And (RECS (0x07), One, Local0)
                }

                If (Local0)
                {
                    Return (0x1F)
                }

                Return (0x0F)
            }

            Method (_BIF, 0, NotSerialized)
            {
                If (ECON)
                {
                    Store (^^PCI0.LPC.H8EC.SM18, Local0)
                    And (Local0, 0xFF, Local1)
                    ShiftLeft (Local1, 0x08, Local1)
                    And (Local0, 0xFF00, Local2)
                    ShiftRight (Local2, 0x08, Local2)
                    Add (Local1, Local2, Local1)
                    If (LEqual (Local1, 0xFFFF))
                    {
                        Store (Ones, Local1)
                    }
                    Else
                    {
                        Multiply (Local1, 0x0A, Local1)
                    }

                    Store (Local1, Index (SBIF, One))
                    Store (^^PCI0.LPC.H8EC.SM10, Local0)
                    And (Local0, 0xFF, Local2)
                    ShiftLeft (Local2, 0x08, Local2)
                    And (Local0, 0xFF00, Local3)
                    ShiftRight (Local3, 0x08, Local3)
                    Add (Local2, Local3, Local2)
                    If (LEqual (Local2, 0xFFFF))
                    {
                        Store (Ones, Local2)
                    }
                    Else
                    {
                        Multiply (Local2, 0x0A, Local2)
                    }

                    Store (Local2, Index (SBIF, 0x02))
                    Store (^^PCI0.LPC.H8EC.SM19, Local0)
                    And (Local0, 0xFF, Local3)
                    ShiftLeft (Local3, 0x08, Local3)
                    And (Local0, 0xFF00, Local4)
                    ShiftRight (Local4, 0x08, Local4)
                    Add (Local3, Local4, Local3)
                    If (LEqual (Local3, 0xFFFF))
                    {
                        Store (Ones, Local3)
                    }

                    Store (Local3, Index (SBIF, 0x04))
                    Store (^^PCI0.LPC.H8EC.SM01, Local0)
                    And (Local0, 0xFF, Local4)
                    ShiftLeft (Local4, 0x08, Local4)
                    And (Local0, 0xFF00, Local5)
                    ShiftRight (Local5, 0x08, Local5)
                    Add (Local4, Local5, Local4)
                    Multiply (Local4, 0x0A, Local4)
                    Store (Local4, Index (SBIF, 0x05))
                }
                Else
                {
                    And (RECS (0x0C), 0xFF, Local0)
                    And (RECS (0x0D), 0xFF, Local1)
                    Add (ShiftLeft (Local0, 0x08), Local1, Local0)
                    If (LEqual (Local0, 0xFFFF))
                    {
                        Store (Ones, Local0)
                    }
                    Else
                    {
                        Multiply (Local0, 0x0A, Local0)
                    }

                    Store (Local0, Index (SBIF, One))
                    And (RECS (0x0A), 0xFF, Local0)
                    And (RECS (0x0B), 0xFF, Local1)
                    Add (ShiftLeft (Local0, 0x08), Local1, Local0)
                    If (LEqual (Local0, 0xFFFF))
                    {
                        Store (Ones, Local0)
                    }
                    Else
                    {
                        Multiply (Local0, 0x0A, Local0)
                    }

                    Store (Local0, Index (SBIF, 0x02))
                    And (RECS (0x0E), 0xFF, Local0)
                    And (RECS (0x0F), 0xFF, Local1)
                    Add (ShiftLeft (Local0, 0x08), Local1, Local0)
                    If (LEqual (Local0, 0xFFFF))
                    {
                        Store (Ones, Local0)
                    }

                    Store (Local0, Index (SBIF, 0x04))
                    And (RECS (0x08), 0xFF, Local0)
                    And (RECS (0x09), 0xFF, Local1)
                    Add (ShiftLeft (Local0, 0x08), Local1, Local0)
                    Multiply (Local0, 0x0A, Local0)
                    Store (Local0, Index (SBIF, 0x05))
                }

                Return (SBIF)
            }

            Method (_BST, 0, NotSerialized)
            {
                If (ECON)
                {
                    Store (^^PCI0.LPC.H8EC.B0ST, Local0)
                    And (Local0, 0x0C, Local0)
                    ShiftRight (Local0, 0x02, Local0)
                    Store (Local0, Index (SBST, Zero))
                    Store (^^PCI0.LPC.H8EC.SM0F, Local1)
                    And (Local1, 0xFF, Local2)
                    ShiftLeft (Local2, 0x08, Local2)
                    And (Local1, 0xFF00, Local3)
                    ShiftRight (Local3, 0x08, Local3)
                    Add (Local2, Local3, Local2)
                    If (LEqual (Local2, 0xFFFF))
                    {
                        Store (Ones, Local2)
                    }
                    Else
                    {
                        Multiply (Local2, 0x0A, Local2)
                    }

                    Store (Local2, Index (SBST, 0x02))
                    Store (^^PCI0.LPC.H8EC.SM09, Local4)
                    And (Local4, 0xFF, Local5)
                    ShiftLeft (Local5, 0x08, Local5)
                    And (Local4, 0xFF00, Local6)
                    ShiftRight (Local6, 0x08, Local6)
                    Add (Local5, Local6, Local5)
                    If (LEqual (Local5, 0xFFFF))
                    {
                        Store (Ones, Local5)
                    }

                    Store (Local5, Index (SBST, 0x03))
                    Store (^^PCI0.LPC.H8EC.SM0B, Local0)
                    ShiftLeft (And (Local0, 0xFF), 0x08, Local1)
                    ShiftRight (And (Local0, 0xFF00), 0x08, Local0)
                    Add (Local0, Local1, Local0)
                    If (LEqual (Local0, 0xFFFF))
                    {
                        Store (Ones, Local0)
                    }
                    Else
                    {
                        If (LGreaterEqual (Local0, 0x8000))
                        {
                            XOr (Local0, 0xFFFF, Local0)
                            Increment (Local0)
                        }

                        Multiply (Local0, Local5, Local0)
                        Divide (Local0, 0x03E8, , Local0)
                    }

                    Store (Local0, Index (SBST, One))
                }
                Else
                {
                    And (RECS (0x07), 0xFF, Local0)
                    ShiftRight (And (Local0, 0x0C), 0x02, Index (SBST, Zero))
                    And (RECS (0x12), 0xFF, Local0)
                    And (RECS (0x13), 0xFF, Local1)
                    Add (ShiftLeft (Local0, 0x08), Local1, Local0)
                    If (LEqual (Local0, 0xFFFF))
                    {
                        Store (Ones, Local0)
                    }
                    Else
                    {
                        Multiply (Local0, 0x0A, Local0)
                    }

                    Store (Local0, Index (SBST, 0x02))
                    And (RECS (0x14), 0xFF, Local0)
                    And (RECS (0x15), 0xFF, Local1)
                    Add (ShiftLeft (Local0, 0x08), Local1, Local0)
                    If (LEqual (Local0, 0xFFFF))
                    {
                        Store (Ones, Local0)
                    }

                    Store (Local0, Index (SBST, 0x03))
                    And (RECS (0x16), 0xFF, Local1)
                    And (RECS (0x17), 0xFF, Local2)
                    ShiftLeft (Local1, 0x08, Local1)
                    Add (Local1, Local2, Local1)
                    If (LEqual (Local1, 0xFFFF))
                    {
                        Store (Ones, Local1)
                    }
                    Else
                    {
                        If (LGreaterEqual (Local1, 0x8000))
                        {
                            XOr (Local1, 0xFFFF, Local1)
                            Increment (Local1)
                        }

                        Multiply (Local1, Local0, Local1)
                        Divide (Local1, 0x03E8, , Local1)
                    }

                    Store (Local1, Index (SBST, One))
                }

                Return (SBST)
            }
        }

        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x01)
            {
                _SB
            })
            Method (_PSR, 0, NotSerialized)
            {
                If (ECON)
                {
                    Store (^^PCI0.LPC.H8EC.ACPW, PWRS)
                }
                Else
                {
                    And (RECS (0x04), One, PWRS)
                }

                Return (PWRS)
            }
        }

        Device (DOCK)
        {
            Name (_HID, EisaId ("PNP0C15"))
            Name (_UID, One)
            Name (_BDN, Ones)
            Name (BDKS, Zero)
            Name (UDKR, Zero)
            Event (UDKE)
            Method (_STA, 0, NotSerialized)
            {
                If (ECON)
                {
                    Store (^^PCI0.LPC.H8EC.UDR, Local0)
                }
                Else
                {
                    Store (And (RECS (0x04), 0x08), Local0)
                }

                If (Local0)
                {
                    Return (0x0F)
                }

                Return (Zero)
            }

            Method (_DCK, 1, NotSerialized)
            {
                If (ECON)
                {
                    Store (Arg0, ^^PCI0.LPC.H8EC.UDR)
                }
                Else
                {
                    CIUL (Arg0)
                }

                Return (One)
            }

            Method (_EJ0, 1, NotSerialized)
            {
                Store (One, UDKR)
                Wait (UDKE, 0xFFFF)
                Reset (UDKE)
                Notify (^^PCI0.EXP4, Zero)
            }

            Method (DWAK, 1, NotSerialized)
            {
                Store (Zero, UDKR)
                If (ECON)
                {
                    Store (^^PCI0.LPC.H8EC.DCKS, Local0)
                    Store (^^PCI0.LPC.H8EC.DWKC, Local1)
                }
                Else
                {
                    Store (RECS (0x04), Local1)
                    And (Local1, 0x10, Local0)
                    And (Local1, 0x80, Local1)
                }

                If (BDKS)
                {
                    If (Local0)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            If (ECON)
                            {
                                Store (One, ^^PCI0.LPC.H8EC.UDR)
                            }
                            Else
                            {
                                CIUL (One)
                            }
                        }

                        If (Local1)
                        {
                            Store (One, UDKR)
                            Notify (DOCK, 0x03)
                        }
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            If (ECON)
                            {
                                Store (Zero, ^^PCI0.LPC.H8EC.UDR)
                            }
                            Else
                            {
                                CIUL (Zero)
                            }
                        }

                        Notify (DOCK, Zero)
                        Notify (^^PCI0.EXP4, Zero)
                        Notify (PCI0, One)
                    }
                }
                Else
                {
                    If (Local0)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            If (ECON)
                            {
                                Store (One, ^^PCI0.LPC.H8EC.UDR)
                            }
                            Else
                            {
                                CIUL (One)
                            }
                        }

                        If (LNot (Local1))
                        {
                            Notify (DOCK, Zero)
                        }
                    }
                }

                Store (Zero, ^^PCI0.LPC.H8EC.DWKC)
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, 0x030AD041)
            Name (_ADR, Zero)
            Method (_INI, 0, NotSerialized)
            {
                Store (One, GPO9)
                Store (0x07D0, OSYS)
                If (CondRefOf (_OSI, Local0))
                {
                    If (_OSI ("Linux"))
                    {
                        Store (0x03E8, OSYS)
                    }

                    If (_OSI ("Windows 2001"))
                    {
                        Store (0x07D1, OSYS)
                    }

                    If (_OSI ("Windows 2001 SP1"))
                    {
                        Store (0x07D1, OSYS)
                    }

                    If (_OSI ("Windows 2001 SP2"))
                    {
                        Store (0x07D2, OSYS)
                    }

                    If (_OSI ("Windows 2006"))
                    {
                        Store (0x07D6, OSYS)
                    }
                }

                HGWH (0x05)
            }

            Name (SUPP, Zero)
            Name (CTRL, Zero)
            Method (_OSC, 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)
                    Store (Zero, CTRL)
                    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)
                }
            }

            Name (_BBN, Zero)
            OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
            Field (HBUS, DWordAcc, NoLock, Preserve)
            {
                EPEN,   1, 
                    ,   11, 
                EPBR,   20, 
                        Offset (0x08), 
                MHEN,   1, 
                    ,   13, 
                MHBR,   18, 
                        Offset (0x20), 
                PXEN,   1, 
                PXSZ,   2, 
                    ,   23, 
                PXBR,   6, 
                        Offset (0x28), 
                DIEN,   1, 
                    ,   11, 
                DIBR,   20, 
                        Offset (0x30), 
                IPEN,   1, 
                    ,   11, 
                IPBR,   20, 
                        Offset (0x50), 
                    ,   4, 
                PM0H,   2, 
                        Offset (0x51), 
                PM1L,   2, 
                    ,   2, 
                PM1H,   2, 
                        Offset (0x52), 
                PM2L,   2, 
                    ,   2, 
                PM2H,   2, 
                        Offset (0x53), 
                PM3L,   2, 
                    ,   2, 
                PM3H,   2, 
                        Offset (0x54), 
                PM4L,   2, 
                    ,   2, 
                PM4H,   2, 
                        Offset (0x55), 
                PM5L,   2, 
                    ,   2, 
                PM5H,   2, 
                        Offset (0x56), 
                PM6L,   2, 
                    ,   2, 
                PM6H,   2, 
                        Offset (0x57), 
                    ,   7, 
                HENA,   1, 
                        Offset (0x62), 
                TUUD,   16, 
                        Offset (0x70), 
                    ,   4, 
                TLUD,   12, 
                        Offset (0x89), 
                    ,   3, 
                GTSE,   1, 
                        Offset (0x8A)
            }

            OperationRegion (MCHT, SystemMemory, 0xFED11000, 0xFF)
            Field (MCHT, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x1E), 
                T0IS,   16, 
                        Offset (0x5E), 
                T1IS,   16, 
                        Offset (0xEF), 
                ESCS,   8
            }

            Name (BUF0, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x00FF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0100,             // Length
                    ,, )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0x00000CF7,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000CF8,         // Length
                    ,, , TypeStatic)
                IO (Decode16,
                    0x0CF8,             // Range Minimum
                    0x0CF8,             // Range Maximum
                    0x01,               // Alignment
                    0x08,               // Length
                    )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000D00,         // Range Minimum
                    0x0000FFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x0000F300,         // Length
                    ,, , TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000A0000,         // Range Minimum
                    0x000BFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00020000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C0000,         // Range Minimum
                    0x000C3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y00, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C4000,         // Range Minimum
                    0x000C7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y01, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C8000,         // Range Minimum
                    0x000CBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y02, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000CC000,         // Range Minimum
                    0x000CFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y03, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D0000,         // Range Minimum
                    0x000D3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y04, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D4000,         // Range Minimum
                    0x000D7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y05, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D8000,         // Range Minimum
                    0x000DBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y06, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000DC000,         // Range Minimum
                    0x000DFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y07, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E0000,         // Range Minimum
                    0x000E3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y08, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E4000,         // Range Minimum
                    0x000E7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y09, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E8000,         // Range Minimum
                    0x000EBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y0A, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000EC000,         // Range Minimum
                    0x000EFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, _Y0B, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000F0000,         // Range Minimum
                    0x000FFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00010000,         // Length
                    ,, _Y0C, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0xFEBFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    ,, _Y0E, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xFED40000,         // Range Minimum
                    0xFED44FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    ,, _Y0D, AddressRangeMemory, TypeStatic)
            })
            Method (_CRS, 0, Serialized)
            {
                If (PM1L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y00._LEN, C0LN)
                    Store (Zero, C0LN)
                }

                If (LEqual (PM1L, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y00._RW, C0RW)
                    Store (Zero, C0RW)
                }

                If (PM1H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y01._LEN, C4LN)
                    Store (Zero, C4LN)
                }

                If (LEqual (PM1H, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y01._RW, C4RW)
                    Store (Zero, C4RW)
                }

                If (PM2L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y02._LEN, C8LN)
                    Store (Zero, C8LN)
                }

                If (LEqual (PM2L, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y02._RW, C8RW)
                    Store (Zero, C8RW)
                }

                If (PM2H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y03._LEN, CCLN)
                    Store (Zero, CCLN)
                }

                If (LEqual (PM2H, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y03._RW, CCRW)
                    Store (Zero, CCRW)
                }

                If (PM3L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y04._LEN, D0LN)
                    Store (Zero, D0LN)
                }

                If (LEqual (PM3L, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y04._RW, D0RW)
                    Store (Zero, D0RW)
                }

                If (PM3H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y05._LEN, D4LN)
                    Store (Zero, D4LN)
                }

                If (LEqual (PM3H, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y05._RW, D4RW)
                    Store (Zero, D4RW)
                }

                If (PM4L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y06._LEN, D8LN)
                    Store (Zero, D8LN)
                }

                If (LEqual (PM4L, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y06._RW, D8RW)
                    Store (Zero, D8RW)
                }

                If (PM4H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y07._LEN, DCLN)
                    Store (Zero, DCLN)
                }

                If (LEqual (PM4H, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y07._RW, DCRW)
                    Store (Zero, DCRW)
                }

                If (PM5L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y08._LEN, E0LN)
                    Store (Zero, E0LN)
                }

                If (LEqual (PM5L, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y08._RW, E0RW)
                    Store (Zero, E0RW)
                }

                If (PM5H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y09._LEN, E4LN)
                    Store (Zero, E4LN)
                }

                If (LEqual (PM5H, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y09._RW, E4RW)
                    Store (Zero, E4RW)
                }

                If (PM6L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0A._LEN, E8LN)
                    Store (Zero, E8LN)
                }

                If (LEqual (PM6L, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0A._RW, E8RW)
                    Store (Zero, E8RW)
                }

                If (PM6H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0B._LEN, ECLN)
                    Store (Zero, ECLN)
                }

                If (LEqual (PM6H, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0B._RW, ECRW)
                    Store (Zero, ECRW)
                }

                If (PM0H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0C._LEN, F0LN)
                    Store (Zero, F0LN)
                }

                If (LEqual (PM0H, One))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0C._RW, F0RW)
                    Store (Zero, F0RW)
                }

                If (LNotEqual (^LPC.TPM.ACCS, 0xFF))
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0D._LEN, TPML)
                    Store (0x5000, TPML)
                }

                CreateDWordField (BUF0, \_SB.PCI0._Y0E._MIN, M1MN)
                CreateDWordField (BUF0, \_SB.PCI0._Y0E._MAX, M1MX)
                CreateDWordField (BUF0, \_SB.PCI0._Y0E._LEN, M1LN)
                ShiftLeft (TLUD, 0x14, M1MN)
                Add (Subtract (M1MX, M1MN), One, M1LN)
                Return (BUF0)
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (LEqual (GPIC, Zero))
                {
                    Return (Package (0x15)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            Zero, 
                            ^LPC.LNKA, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x0002FFFF, 
                            Zero, 
                            ^LPC.LNKA, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x0003FFFF, 
                            Zero, 
                            ^LPC.LNKA, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x0003FFFF, 
                            One, 
                            ^LPC.LNKB, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x0003FFFF, 
                            0x02, 
                            ^LPC.LNKC, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x0003FFFF, 
                            0x03, 
                            ^LPC.LNKD, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x0019FFFF, 
                            Zero, 
                            ^LPC.LNKC, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001AFFFF, 
                            Zero, 
                            ^LPC.LNKH, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001AFFFF, 
                            One, 
                            ^LPC.LNKH, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001AFFFF, 
                            0x02, 
                            ^LPC.LNKH, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001BFFFF, 
                            Zero, 
                            ^LPC.LNKF, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            Zero, 
                            ^LPC.LNKA, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            One, 
                            ^LPC.LNKB, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x02, 
                            ^LPC.LNKC, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x03, 
                            ^LPC.LNKD, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            Zero, 
                            ^LPC.LNKE, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            One, 
                            ^LPC.LNKE, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x02, 
                            ^LPC.LNKE, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            One, 
                            ^LPC.LNKG, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x02, 
                            ^LPC.LNKG, 
                            Zero
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x03, 
                            ^LPC.LNKG, 
                            Zero
                        }
                    })
                }
                Else
                {
                    Return (Package (0x15)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            Zero, 
                            Zero, 
                            0x10
                        }, 

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

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

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

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

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

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

                        Package (0x04)
                        {
                            0x001AFFFF, 
                            Zero, 
                            Zero, 
                            0x17
                        }, 

                        Package (0x04)
                        {
                            0x001AFFFF, 
                            One, 
                            Zero, 
                            0x17
                        }, 

                        Package (0x04)
                        {
                            0x001AFFFF, 
                            0x02, 
                            Zero, 
                            0x17
                        }, 

                        Package (0x04)
                        {
                            0x001BFFFF, 
                            Zero, 
                            Zero, 
                            0x15
                        }, 

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

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

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

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

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            Zero, 
                            Zero, 
                            0x14
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            One, 
                            Zero, 
                            0x14
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x02, 
                            Zero, 
                            0x14
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            One, 
                            Zero, 
                            0x16
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x02, 
                            Zero, 
                            0x16
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x03, 
                            Zero, 
                            0x16
                        }
                    })
                }
            }

            Device (OVGA)
            {
                Name (_ADR, 0x00020000)
                Scope (^^PCI0)
                {
                    OperationRegion (MCHP, PCI_Config, 0x40, 0xC0)
                    Field (MCHP, AnyAcc, NoLock, Preserve)
                    {
                                Offset (0x60), 
                        TASM,   10, 
                                Offset (0x62)
                    }
                }

                OperationRegion (IGDP, PCI_Config, 0x40, 0xC0)
                Field (IGDP, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x12), 
                        ,   1, 
                    GIVD,   1, 
                        ,   2, 
                    GUMA,   3, 
                            Offset (0x14), 
                        ,   4, 
                    GMFN,   1, 
                            Offset (0x18), 
                            Offset (0xA4), 
                    ASLE,   8, 
                            Offset (0xA8), 
                    GSSE,   1, 
                    GSSB,   14, 
                    GSES,   1, 
                            Offset (0xB0), 
                        ,   12, 
                    CDVL,   1, 
                            Offset (0xB2), 
                            Offset (0xB5), 
                    LBPC,   8, 
                            Offset (0xBC), 
                    ASLS,   32
                }

                OperationRegion (IGDM, SystemMemory, ASLB, 0x2000)
                Field (IGDM, AnyAcc, NoLock, Preserve)
                {
                    SIGN,   128, 
                    SIZE,   32, 
                    OVER,   32, 
                    SVER,   256, 
                    VVER,   128, 
                    GVER,   128, 
                    MBOX,   32, 
                    DMOD,   32, 
                            Offset (0x100), 
                    DRDY,   32, 
                    CSTS,   32, 
                    CEVT,   32, 
                            Offset (0x120), 
                    DIDL,   32, 
                    DDL2,   32, 
                    DDL3,   32, 
                    DDL4,   32, 
                    DDL5,   32, 
                    DDL6,   32, 
                    DDL7,   32, 
                    DDL8,   32, 
                    CPDL,   32, 
                    CPL2,   32, 
                    CPL3,   32, 
                    CPL4,   32, 
                    CPL5,   32, 
                    CPL6,   32, 
                    CPL7,   32, 
                    CPL8,   32, 
                    CADL,   32, 
                    CAL2,   32, 
                    CAL3,   32, 
                    CAL4,   32, 
                    CAL5,   32, 
                    CAL6,   32, 
                    CAL7,   32, 
                    CAL8,   32, 
                    NADL,   32, 
                    NDL2,   32, 
                    NDL3,   32, 
                    NDL4,   32, 
                    NDL5,   32, 
                    NDL6,   32, 
                    NDL7,   32, 
                    NDL8,   32, 
                    ASLP,   32, 
                    TIDX,   32, 
                    CHPD,   32, 
                    CLID,   32, 
                    CDCK,   32, 
                    SXSW,   32, 
                    EVTS,   32, 
                    CNOT,   32, 
                    NRDY,   32, 
                            Offset (0x200), 
                    SCIE,   1, 
                    GEFC,   4, 
                    GXFC,   3, 
                    GESF,   8, 
                            Offset (0x204), 
                    PARM,   32, 
                    DSLP,   32, 
                            Offset (0x300), 
                    ARDY,   32, 
                    ASLC,   32, 
                    TCHE,   32, 
                    ALSI,   32, 
                    BCLP,   32, 
                    PFIT,   32, 
                    CBLV,   32, 
                    BCLM,   320, 
                    CPFM,   32, 
                    EPFM,   32, 
                    PLUT,   592, 
                    PFMB,   32, 
                    CCDV,   32, 
                    PCFT,   32, 
                            Offset (0x400), 
                    GVD1,   49152, 
                    PHED,   32, 
                    BDDC,   2048
                }

                Name (DBTB, Package (0x15)
                {
                    Zero, 
                    0x07, 
                    0x38, 
                    0x01C0, 
                    0x0E00, 
                    0x3F, 
                    0x01C7, 
                    0x0E07, 
                    0x01F8, 
                    0x0E38, 
                    0x0FC0, 
                    Zero, 
                    Zero, 
                    Zero, 
                    Zero, 
                    Zero, 
                    0x7000, 
                    0x7007, 
                    0x7038, 
                    0x71C0, 
                    0x7E00
                })
                Name (CDCT, Package (0x05)
                {
                    Package (0x02)
                    {
                        0xE4, 
                        0x0140
                    }, 

                    Package (0x02)
                    {
                        0xDE, 
                        0x014D
                    }, 

                    Package (0x02)
                    {
                        0xDE, 
                        0x014D
                    }, 

                    Package (0x02)
                    {
                        Zero, 
                        Zero
                    }, 

                    Package (0x02)
                    {
                        0xDE, 
                        0x014D
                    }
                })
                Name (SUCC, One)
                Name (NVLD, 0x02)
                Name (CRIT, 0x04)
                Name (NCRT, 0x06)
                Method (GSCI, 0, Serialized)
                {
                    Method (GBDA, 0, Serialized)
                    {
                        If (LEqual (GESF, Zero))
                        {
                            Store (0x0679, PARM)
                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, One))
                        {
                            Store (0x0240, PARM)
                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x04))
                        {
                            And (PARM, 0xEFFF0000, PARM)
                            And (PARM, ShiftLeft (DerefOf (Index (DBTB, IBTT)), 0x10), 
                                PARM)
                            Or (IBTT, PARM, PARM)
                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x05))
                        {
                            Store (IPSC, PARM)
                            Or (PARM, ShiftLeft (IPAT, 0x08), PARM)
                            Or (PARM, ShiftLeft (LIDS, 0x10), PARM)
                            Add (PARM, 0x00010000, PARM)
                            Or (PARM, ShiftLeft (IBIA, 0x14), PARM)
                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x06))
                        {
                            Store (ITVF, PARM)
                            Or (PARM, ShiftLeft (ITVM, 0x04), PARM)
                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x07))
                        {
                            Store (GIVD, PARM)
                            XOr (PARM, One, PARM)
                            Or (PARM, ShiftLeft (GMFN, One), PARM)
                            Or (PARM, 0x1800, PARM)
                            Or (PARM, ShiftLeft (IDMS, 0x11), PARM)
                            Or (ShiftLeft (DerefOf (Index (DerefOf (Index (CDCT, HVCO)), CDVL
                                )), 0x15), PARM, PARM)
                            Store (One, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x0A))
                        {
                            Store (Zero, PARM)
                            If (ISSC)
                            {
                                Or (PARM, 0x03, PARM)
                            }

                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x0B))
                        {
                            Store (KSV0, PARM)
                            Store (KSV1, GESF)
                            Return (SUCC)
                        }

                        Store (Zero, GESF)
                        Return (CRIT)
                    }

                    Method (SBCB, 0, Serialized)
                    {
                        If (LEqual (GESF, Zero))
                        {
                            Store (Zero, PARM)
                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, One))
                        {
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x03))
                        {
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x04))
                        {
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x05))
                        {
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x06))
                        {
                            Store (And (PARM, 0x0F), ITVF)
                            Store (ShiftRight (And (PARM, 0xF0), 0x04), ITVM)
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x07))
                        {
                            If (LEqual (PARM, Zero))
                            {
                                Store (CLID, Local0)
                                If (And (0x80000000, Local0))
                                {
                                    And (CLID, 0x0F, CLID)
                                    GLID (CLID)
                                }
                            }

                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x08))
                        {
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x09))
                        {
                            And (PARM, 0xFF, IBTT)
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x0A))
                        {
                            And (PARM, 0xFF, IPSC)
                            If (And (ShiftRight (PARM, 0x08), 0xFF))
                            {
                                And (ShiftRight (PARM, 0x08), 0xFF, IPAT)
                                Decrement (IPAT)
                            }

                            And (ShiftRight (PARM, 0x14), 0x07, IBIA)
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x0B))
                        {
                            And (ShiftRight (PARM, One), One, IF1E)
                            If (And (PARM, 0x0001E000))
                            {
                                And (ShiftRight (PARM, 0x0D), 0x0F, IDMS)
                            }
                            Else
                            {
                                And (ShiftRight (PARM, 0x11), 0x0F, IDMS)
                            }

                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x10))
                        {
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x11))
                        {
                            Store (ShiftLeft (LIDS, 0x08), PARM)
                            Add (PARM, 0x0100, PARM)
                            Store (Zero, GESF)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x12))
                        {
                            If (And (PARM, One))
                            {
                                If (LEqual (ShiftRight (PARM, One), One))
                                {
                                    Store (One, ISSC)
                                }
                                Else
                                {
                                    Store (Zero, GESF)
                                    Return (CRIT)
                                }
                            }
                            Else
                            {
                                Store (Zero, ISSC)
                            }

                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x13))
                        {
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        If (LEqual (GESF, 0x14))
                        {
                            And (PARM, 0x0F, PAVP)
                            Store (Zero, GESF)
                            Store (Zero, PARM)
                            Return (SUCC)
                        }

                        Store (Zero, GESF)
                        Return (SUCC)
                    }

                    If (LEqual (GEFC, 0x04))
                    {
                        Store (GBDA (), GXFC)
                    }

                    If (LEqual (GEFC, 0x06))
                    {
                        Store (SBCB (), GXFC)
                    }

                    Store (Zero, GEFC)
                    Store (One, SCIS)
                    Store (Zero, GSSE)
                    Store (Zero, SCIE)
                    Return (Zero)
                }

                Method (PDRD, 0, NotSerialized)
                {
                    If (LNot (DRDY))
                    {
                        Sleep (ASLP)
                    }

                    Return (LNot (DRDY))
                }

                Method (PSTS, 0, NotSerialized)
                {
                    If (LGreater (CSTS, 0x02))
                    {
                        Sleep (ASLP)
                    }

                    Return (LEqual (CSTS, 0x03))
                }

                Method (GNOT, 2, NotSerialized)
                {
                    If (PDRD ())
                    {
                        Return (One)
                    }

                    Store (Arg0, CEVT)
                    Store (0x03, CSTS)
                    If (LAnd (LEqual (CHPD, Zero), LEqual (Arg1, Zero)))
                    {
                        If (LOr (LGreater (OSYS, 0x07D0), LLess (OSYS, 0x07D6)))
                        {
                            Notify (PCI0, Arg1)
                        }
                        Else
                        {
                            Notify (OVGA, Arg1)
                        }
                    }

                    Notify (OVGA, 0x80)
                    Return (Zero)
                }

                Method (GHDS, 1, NotSerialized)
                {
                    Store (Arg0, TIDX)
                    Return (GNOT (One, Zero))
                }

                Method (GLID, 1, NotSerialized)
                {
                    Store (Arg0, CLID)
                    Return (GNOT (0x02, Zero))
                }

                Method (GDCK, 1, NotSerialized)
                {
                    Store (Arg0, CDCK)
                    Return (GNOT (0x04, Zero))
                }

                Method (PARD, 0, NotSerialized)
                {
                    If (LNot (ARDY))
                    {
                        Sleep (ASLP)
                    }

                    Return (LNot (ARDY))
                }

                Method (AINT, 2, NotSerialized)
                {
                    If (LNot (And (TCHE, ShiftLeft (One, Arg0))))
                    {
                        Return (One)
                    }

                    If (PARD ())
                    {
                        Return (One)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        If (CPFM)
                        {
                            And (CPFM, 0x0F, Local0)
                            And (EPFM, 0x0F, Local1)
                            If (LEqual (Local0, One))
                            {
                                If (And (Local1, 0x06))
                                {
                                    Store (0x06, PFIT)
                                }
                                Else
                                {
                                    If (And (Local1, 0x08))
                                    {
                                        Store (0x08, PFIT)
                                    }
                                    Else
                                    {
                                        Store (One, PFIT)
                                    }
                                }
                            }

                            If (LEqual (Local0, 0x06))
                            {
                                If (And (Local1, 0x08))
                                {
                                    Store (0x08, PFIT)
                                }
                                Else
                                {
                                    If (And (Local1, One))
                                    {
                                        Store (One, PFIT)
                                    }
                                    Else
                                    {
                                        Store (0x06, PFIT)
                                    }
                                }
                            }

                            If (LEqual (Local0, 0x08))
                            {
                                If (And (Local1, One))
                                {
                                    Store (One, PFIT)
                                }
                                Else
                                {
                                    If (And (Local1, 0x06))
                                    {
                                        Store (0x06, PFIT)
                                    }
                                    Else
                                    {
                                        Store (0x08, PFIT)
                                    }
                                }
                            }
                        }
                        Else
                        {
                            XOr (PFIT, 0x07, PFIT)
                        }

                        Or (PFIT, 0x80000000, PFIT)
                        Store (0x04, ASLC)
                    }
                    Else
                    {
                        If (LEqual (Arg0, One))
                        {
                            Store (Arg1, BCLP)
                            Or (BCLP, 0x80000000, BCLP)
                            Store (0x02, ASLC)
                        }
                        Else
                        {
                            If (LEqual (Arg0, Zero))
                            {
                                Store (Arg1, ALSI)
                                Store (One, ASLC)
                            }
                            Else
                            {
                                Return (One)
                            }
                        }
                    }

                    Store (Zero, LBPC)
                    Return (Zero)
                }

                Method (SCIP, 0, NotSerialized)
                {
                    If (LNotEqual (OVER, Zero))
                    {
                        Return (LNot (GSMI))
                    }

                    Return (Zero)
                }
            }

            Device (LANC)
            {
                Name (_ADR, 0x00190000)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
                Name (WOLS, Zero)
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (One, WOLS)
                    }
                    Else
                    {
                        Store (Zero, WOLS)
                    }
                }

                OperationRegion (LANR, PCI_Config, 0xCC, 0x04)
                Field (LANR, AnyAcc, NoLock, Preserve)
                {
                        ,   15, 
                    PMES,   1
                }
            }

            Device (PEGP)
            {
                Name (_ADR, 0x00010000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                ^^LPC.LNKA, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                Zero, 
                                0x10
                            }
                        })
                    }
                }
            }

            Device (P32)
            {
                Name (_ADR, 0x001E0000)
                Method (_PRW, 0, NotSerialized)
                {
                    If (LEqual (WKPM, One))
                    {
                        Return (Package (0x02)
                        {
                            0x0B, 
                            0x04
                        })
                    }
                    Else
                    {
                        Return (Package (0x02)
                        {
                            0x0B, 
                            Zero
                        })
                    }
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x03)
                        {
                            Package (0x04)
                            {
                                0x0004FFFF, 
                                Zero, 
                                ^^LPC.LNKE, 
                                Zero
                            }, 

                            Package (0x04)
                            {
                                0x0004FFFF, 
                                One, 
                                ^^LPC.LNKF, 
                                Zero
                            }, 

                            Package (0x04)
                            {
                                0x0004FFFF, 
                                0x02, 
                                ^^LPC.LNKG, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x03)
                        {
                            Package (0x04)
                            {
                                0x0004FFFF, 
                                Zero, 
                                Zero, 
                                0x14
                            }, 

                            Package (0x04)
                            {
                                0x0004FFFF, 
                                One, 
                                Zero, 
                                0x15
                            }, 

                            Package (0x04)
                            {
                                0x0004FFFF, 
                                0x02, 
                                Zero, 
                                0x16
                            }
                        })
                    }
                }

                Device (CBC0)
                {
                    Name (_ADR, 0x00040000)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x09)
                    }
                }
            }

            Device (LPC)
            {
                Name (_ADR, 0x001F0000)
                OperationRegion (PRR0, PCI_Config, 0x60, 0x04)
                Field (PRR0, AnyAcc, NoLock, Preserve)
                {
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8
                }

                OperationRegion (PRR1, PCI_Config, 0x68, 0x04)
                Field (PRR1, AnyAcc, NoLock, Preserve)
                {
                    PIRE,   8, 
                    PIRF,   8, 
                    PIRG,   8, 
                    PIRH,   8
                }

                OperationRegion (PRR2, PCI_Config, 0x80, 0x02)
                Field (PRR2, AnyAcc, NoLock, Preserve)
                {
                    IODL,   8, 
                    IODH,   8
                }

                OperationRegion (GEN2, PCI_Config, 0x88, 0x04)
                Field (GEN2, AnyAcc, NoLock, Preserve)
                {
                    G2DA,   32
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, One)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRA, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRA, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRA, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRA)
                    }
                }

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRB, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRB, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRB)
                    }
                }

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRC, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRC, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRC)
                    }
                }

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRD, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRD, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRD)
                    }
                }

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRE, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRE, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRE)
                    }
                }

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRF, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRF, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRF)
                    }
                }

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRG, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRG, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRG)
                    }
                }

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

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

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {0}
                        })
                        CreateWordField (BUF0, One, IRQW)
                        If (And (PIRH, 0x80))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            Store (One, Local0)
                        }

                        ShiftLeft (Local0, And (PIRH, 0x0F), IRQW)
                        Return (BUF0)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,7,9,10,11,12}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, One, IRQW)
                        FindSetRightBit (IRQW, Local0)
                        If (LNotEqual (IRQW, Zero))
                        {
                            And (Local0, 0x7F, Local0)
                            Decrement (Local0)
                        }
                        Else
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Store (Local0, PIRH)
                    }
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Method (_CRS, 0, Serialized)
                    {
                        If (LEqual (^^TPM.ACCS, 0xFF))
                        {
                            Return (ResourceTemplate ()
                            {
                                IO (Decode16,
                                    0x002E,             // Range Minimum
                                    0x002E,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x004E,             // Range Minimum
                                    0x004E,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x164E,             // Range Minimum
                                    0x164E,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x0061,             // Range Minimum
                                    0x0061,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0070,             // Range Minimum
                                    0x0070,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0080,             // Range Minimum
                                    0x0080,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0092,             // Range Minimum
                                    0x0092,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x00B2,             // Range Minimum
                                    0x00B2,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x0063,             // Range Minimum
                                    0x0063,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0065,             // Range Minimum
                                    0x0065,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0067,             // Range Minimum
                                    0x0067,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0600,             // Range Minimum
                                    0x0600,             // Range Maximum
                                    0x01,               // Alignment
                                    0x10,               // Length
                                    )
                                IO (Decode16,
                                    0x0610,             // Range Minimum
                                    0x0610,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0800,             // Range Minimum
                                    0x0800,             // Range Maximum
                                    0x01,               // Alignment
                                    0x10,               // Length
                                    )
                                IO (Decode16,
                                    0x0810,             // Range Minimum
                                    0x0810,             // Range Maximum
                                    0x01,               // Alignment
                                    0x08,               // Length
                                    )
                                IO (Decode16,
                                    0x0820,             // Range Minimum
                                    0x0820,             // Range Maximum
                                    0x01,               // Alignment
                                    0x04,               // Length
                                    )
                                IO (Decode16,
                                    0x0400,             // Range Minimum
                                    0x0400,             // Range Maximum
                                    0x01,               // Alignment
                                    0x80,               // Length
                                    )
                                IO (Decode16,
                                    0x0500,             // Range Minimum
                                    0x0500,             // Range Maximum
                                    0x01,               // Alignment
                                    0x40,               // Length
                                    )
                                IO (Decode16,
                                    0x2000,             // Range Minimum
                                    0x2000,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x2004,             // Range Minimum
                                    0x2004,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xF8000000,         // Address Base
                                    0x04000000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED1C000,         // Address Base
                                    0x00004000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED10000,         // Address Base
                                    0x00004000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED18000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED19000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFEC00000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED20000,         // Address Base
                                    0x00070000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFEE00000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IO (Decode16,
                                    0x002E,             // Range Minimum
                                    0x002E,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x004E,             // Range Minimum
                                    0x004E,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x164E,             // Range Minimum
                                    0x164E,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x0061,             // Range Minimum
                                    0x0061,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0070,             // Range Minimum
                                    0x0070,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0080,             // Range Minimum
                                    0x0080,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0092,             // Range Minimum
                                    0x0092,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x00B2,             // Range Minimum
                                    0x00B2,             // Range Maximum
                                    0x01,               // Alignment
                                    0x02,               // Length
                                    )
                                IO (Decode16,
                                    0x0063,             // Range Minimum
                                    0x0063,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0065,             // Range Minimum
                                    0x0065,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0067,             // Range Minimum
                                    0x0067,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0600,             // Range Minimum
                                    0x0600,             // Range Maximum
                                    0x01,               // Alignment
                                    0x10,               // Length
                                    )
                                IO (Decode16,
                                    0x0610,             // Range Minimum
                                    0x0610,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x0800,             // Range Minimum
                                    0x0800,             // Range Maximum
                                    0x01,               // Alignment
                                    0x10,               // Length
                                    )
                                IO (Decode16,
                                    0x0810,             // Range Minimum
                                    0x0810,             // Range Maximum
                                    0x01,               // Alignment
                                    0x08,               // Length
                                    )
                                IO (Decode16,
                                    0x0820,             // Range Minimum
                                    0x0820,             // Range Maximum
                                    0x01,               // Alignment
                                    0x04,               // Length
                                    )
                                IO (Decode16,
                                    0x0400,             // Range Minimum
                                    0x0400,             // Range Maximum
                                    0x01,               // Alignment
                                    0x80,               // Length
                                    )
                                IO (Decode16,
                                    0x0500,             // Range Minimum
                                    0x0500,             // Range Maximum
                                    0x01,               // Alignment
                                    0x40,               // Length
                                    )
                                IO (Decode16,
                                    0x2000,             // Range Minimum
                                    0x2000,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                IO (Decode16,
                                    0x2004,             // Range Minimum
                                    0x2004,             // Range Maximum
                                    0x01,               // Alignment
                                    0x01,               // Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xF8000000,         // Address Base
                                    0x04000000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED1C000,         // Address Base
                                    0x00004000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED10000,         // Address Base
                                    0x00004000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED18000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED19000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFEC00000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED20000,         // Address Base
                                    0x00020000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFED45000,         // Address Base
                                    0x0004B000,         // Address Length
                                    )
                                Memory32Fixed (ReadWrite,
                                    0xFEE00000,         // Address Base
                                    0x00001000,         // Address Length
                                    )
                            })
                        }
                    }
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        IO (Decode16,
                            0x0081,             // Range Minimum
                            0x0081,             // Range Maximum
                            0x01,               // Alignment
                            0x11,               // Length
                            )
                        IO (Decode16,
                            0x0093,             // Range Minimum
                            0x0093,             // Range Maximum
                            0x01,               // Alignment
                            0x0D,               // Length
                            )
                        IO (Decode16,
                            0x00C0,             // Range Minimum
                            0x00C0,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        DMA (Compatibility, NotBusMaster, Transfer8_16, )
                            {4}
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0070,             // Range Minimum
                            0x0070,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {8}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Return (BUF1)
                    }
                }

                Device (HPET)
                {
                    Name (_HID, EisaId ("PNP0103"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0xFED00000,         // Address Base
                            0x00000400,         // Address Length
                            _Y0F)
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LGreaterEqual (OSYS, 0x07D1))
                        {
                            If (LEqual (HPTS, One))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }
                        Else
                        {
                            If (HPTS)
                            {
                                Return (0x0B)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }
                    }

                    Method (_CRS, 0, Serialized)
                    {
                        If (LEqual (HPTS, One))
                        {
                            CreateDWordField (BUF0, \_SB.PCI0.LPC.HPET._Y0F._BAS, HPT0)
                            If (LEqual (HPTA, One))
                            {
                                Store (0xFED01000, HPT0)
                            }

                            If (LEqual (HPTA, 0x02))
                            {
                                Store (0xFED02000, HPT0)
                            }

                            If (LEqual (HPTA, 0x03))
                            {
                                Store (0xFED03000, HPT0)
                            }
                        }

                        Return (BUF0)
                    }
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0020,             // Range Minimum
                            0x0020,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0024,             // Range Minimum
                            0x0024,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0028,             // Range Minimum
                            0x0028,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x002C,             // Range Minimum
                            0x002C,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0030,             // Range Minimum
                            0x0030,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0034,             // Range Minimum
                            0x0034,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0038,             // Range Minimum
                            0x0038,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x003C,             // Range Minimum
                            0x003C,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A0,             // Range Minimum
                            0x00A0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A4,             // Range Minimum
                            0x00A4,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A8,             // Range Minimum
                            0x00A8,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00AC,             // Range Minimum
                            0x00AC,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00B0,             // Range Minimum
                            0x00B0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00B4,             // Range Minimum
                            0x00B4,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00B8,             // Range Minimum
                            0x00B8,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00BC,             // Range Minimum
                            0x00BC,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x04D0,             // Range Minimum
                            0x04D0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {2}
                    })
                }

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

                Device (TIMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0040,             // Range Minimum
                            0x0040,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x0050,             // Range Minimum
                            0x0050,             // Range Maximum
                            0x10,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {0}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Return (BUF1)
                    }
                }

                Device (FWHD)
                {
                    Name (_HID, EisaId ("INT0800"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0xFF800000,         // Address Base
                            0x00800000,         // Address Length
                            )
                    })
                }

                Device (KBC)
                {
                    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
                            )
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {1}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (MOUE)
                {
                    Name (_HID, EisaId ("SNY9001"))
                    Name (_CID, 0x130FD041)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive, )
                            {12}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (H8EC)
                {
                    Name (WONF, Zero)
                    Name (WOFF, Zero)
                    Name (SONF, Zero)
                    Name (SOFF, Zero)
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_UID, One)
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BFFR, 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
                                )
                        })
                        Return (BFFR)
                    }

                    OperationRegion (ECF2, EmbeddedControl, Zero, 0xFF)
                    Field (ECF2, ByteAcc, Lock, Preserve)
                    {
                        RTMP,   8, 
                        LTMP,   8, 
                        MTMP,   8, 
                        GTMP,   8, 
                        ACPW,   1, 
                        LIDS,   1, 
                        CRTS,   1, 
                        UDR,    1, 
                        DCKS,   1, 
                        FANS,   1, 
                            ,   1, 
                        DWKC,   1, 
                        CRT,    8, 
                        PSV,    8, 
                        B0ST,   8, 
                        SM01,   16, 
                        SM10,   16, 
                        SM18,   16, 
                        SM19,   16, 
                        SM0D,   16, 
                        SM0F,   16, 
                        SM09,   16, 
                        SM0B,   16, 
                        SM08,   16, 
                        AVRT,   16, 
                        CHCU,   16, 
                        HKEV,   1, 
                        EBCF,   1, 
                        LBHA,   1, 
                            ,   1, 
                        BCHA,   1, 
                                Offset (0x1F), 
                        HKCD,   8, 
                        WLSL,   1, 
                        BTSL,   1, 
                        WWSL,   1, 
                        WLPW,   1, 
                        BTPW,   1, 
                        WWPW,   1, 
                        WWRF,   1, 
                                Offset (0x21), 
                        EVDO,   1, 
                        HSDP,   1, 
                        EDG,    1, 
                                Offset (0x22), 
                        SWUR,   8, 
                                Offset (0x24), 
                        ACPC,   1, 
                        ENTP,   1, 
                        USBO,   1, 
                                Offset (0x25), 
                        ACPS,   1, 
                                Offset (0x26), 
                        ENPS,   1, 
                                Offset (0x27), 
                        USBP,   1, 
                                Offset (0x28), 
                        S5LR,   1, 
                        S4LR,   1, 
                        S3LR,   1, 
                                Offset (0x29), 
                            ,   1, 
                                Offset (0x2A), 
                        MODF,   8, 
                                Offset (0x2C), 
                        SIOP,   8, 
                        SIRQ,   8, 
                        SFN0,   8, 
                        SFN1,   8, 
                        SFN2,   8, 
                        SFN3,   8, 
                        SFN4,   8, 
                        SFN5,   8, 
                        SFN6,   8, 
                        SFN7,   8, 
                        SIMS,   1, 
                        WLRF,   1, 
                                Offset (0x37), 
                        PNDC,   8, 
                                Offset (0x39), 
                                Offset (0x3A), 
                                Offset (0x3B), 
                                Offset (0x3D), 
                                Offset (0x3F), 
                                Offset (0x41), 
                                Offset (0x43), 
                                Offset (0x45), 
                                Offset (0x47), 
                                Offset (0x49), 
                                Offset (0x4B), 
                                Offset (0x4D), 
                                Offset (0x4F), 
                                Offset (0x51), 
                                Offset (0x53), 
                                Offset (0x62), 
                        THMP,   2, 
                                Offset (0x63), 
                                Offset (0x64), 
                        SOPS,   1, 
                        UOPS,   1, 
                                Offset (0x65), 
                        SOPP,   1, 
                            ,   1, 
                        BTPS,   1, 
                                Offset (0x66), 
                                Offset (0xA0), 
                        PDST,   1, 
                                Offset (0xA1), 
                                Offset (0xE0), 
                        BCCS,   8, 
                                Offset (0xE2), 
                                Offset (0xE3), 
                                Offset (0xE4), 
                                Offset (0xE5), 
                                Offset (0xE6), 
                                Offset (0xE7), 
                                Offset (0xE8), 
                                Offset (0xEA), 
                                Offset (0xEC)
                    }

                    Method (_REG, 2, NotSerialized)
                    {
                        If (LAnd (LEqual (Arg0, 0x03), LEqual (Arg1, One)))
                        {
                            Store (One, ECOK)
                            PNOT ()
                        }
                    }

                    Name (_GPE, 0x17)
                    Method (_Q01, 0, NotSerialized)
                    {
                        Store (0x11, P80H)
                        Sleep (0x14)
                        Notify (BAT0, 0x81)
                        Notify (BAT0, 0x80)
                    }

                    Method (_Q02, 0, NotSerialized)
                    {
                        Store (0x22, P80H)
                        Sleep (0x14)
                        Notify (BAT0, 0x81)
                        Notify (BAT0, 0x80)
                    }

                    Method (_Q03, 0, NotSerialized)
                    {
                        Store (0x33, P80H)
                    }

                    Method (_Q04, 0, NotSerialized)
                    {
                        Store (0x44, P80H)
                        Notify (AC, 0x80)
                        PNOT ()
                        Sleep (0x14)
                        Notify (BAT0, 0x80)
                    }

                    Method (_Q05, 0, NotSerialized)
                    {
                        Store (0x55, P80H)
                        Notify (AC, 0x80)
                        PNOT ()
                        Sleep (0x14)
                        Notify (BAT0, 0x80)
                    }

                    Method (_Q06, 0, NotSerialized)
                    {
                        Store (0x66, P80H)
                        Notify (DOCK, Zero)
                    }

                    Method (_Q07, 0, NotSerialized)
                    {
                        Store (0x77, P80H)
                        If (^^^^DOCK.UDKR)
                        {
                            Store (Zero, ^^^^DOCK.UDKR)
                            Signal (^^^^DOCK.UDKE)
                        }
                        Else
                        {
                            If (ECON)
                            {
                                Store (Zero, UDR)
                            }
                            Else
                            {
                                CIUL (Zero)
                            }

                            Notify (DOCK, Zero)
                            Notify (EXP4, Zero)
                            Notify (PCI0, One)
                        }
                    }

                    Method (_Q08, 0, NotSerialized)
                    {
                        Store (0x88, P80H)
                        Notify (LID0, 0x80)
                        Store (0x02, HDAE)
                        Store (0x00010110, HDHE)
                        Notify (OVGA, 0x81)
                        Notify (WMI1, 0x81)
                    }

                    Method (_Q09, 0, NotSerialized)
                    {
                        Store (0x99, P80H)
                        Notify (LID0, 0x80)
                        Store (0x02, HDAE)
                        Store (0x00010110, HDHE)
                        Notify (OVGA, 0x81)
                        Notify (WMI1, 0x81)
                    }

                    Method (_Q0A, 0, NotSerialized)
                    {
                        Store (0xAA, P80H)
                        If (ECON)
                        {
                            Store (HKEV, Local0)
                        }
                        Else
                        {
                            And (RECS (0x1E), One, Local0)
                        }

                        If (Local0)
                        {
                            If (ECON)
                            {
                                Store (HKCD, ^^SNC.ECR)
                            }
                            Else
                            {
                                Store (RECS (0x1F), ^^SNC.ECR)
                            }

                            ^^SNC.SNNE (0x0100)
                        }
                    }

                    Method (_Q0B, 0, NotSerialized)
                    {
                        Store (0xBB, P80H)
                        If (ECON)
                        {
                            Store (HKEV, Local0)
                        }
                        Else
                        {
                            And (RECS (0x1E), One, Local0)
                        }

                        If (Local0)
                        {
                            If (ECON)
                            {
                                Store (HKCD, ^^SNC.ECR)
                            }
                            Else
                            {
                                Store (RECS (0x1F), ^^SNC.ECR)
                            }

                            ^^SNC.SNNE (0x0100)
                        }
                    }

                    Method (_Q0C, 0, NotSerialized)
                    {
                        Store (0xCC, P80H)
                        If (LGreaterEqual (OSYS, 0x07D6))
                        {
                            Store (0x02, HDAE)
                            Store (0x80010100, HDHE)
                            Notify (OVGA, 0x81)
                            Notify (WMI1, 0x81)
                        }
                    }

                    Method (_Q0D, 0, NotSerialized)
                    {
                        Store (0xDD, P80H)
                        Notify (PWRB, 0x80)
                    }

                    Method (_Q0E, 0, NotSerialized)
                    {
                        Store (0xEE, P80H)
                        Notify (\_TZ.ATF0, 0x81)
                    }

                    Method (_Q10, 0, NotSerialized)
                    {
                        Store (0x10, P80H)
                        ^^SNC.SNNE (0x0101)
                    }

                    Method (_Q12, 0, NotSerialized)
                    {
                        Store (0x12, P80H)
                        Notify (\_TZ.ATF0, 0x80)
                    }

                    Method (_Q11, 0, NotSerialized)
                    {
                        Store (0x11, P80H)
                        If (ECON)
                        {
                            Store (DCKS, Local0)
                        }
                        Else
                        {
                            And (RECS (0x04), 0x10, Local0)
                        }

                        If (Local0)
                        {
                            Notify (DOCK, 0x03)
                        }
                    }

                    Method (_Q13, 0, NotSerialized)
                    {
                        Store (0x13, P80H)
                        If (ECON)
                        {
                            Store (WLRF, Local0)
                        }
                        Else
                        {
                            And (RECS (0x36), 0x02, Local0)
                            ShiftRight (Local0, One, Local0)
                        }

                        If (LNot (Local0))
                        {
                            Store (One, WONF)
                            Store (Zero, WOFF)
                            Store (Zero, SONF)
                            Store (Zero, SOFF)
                            ^^SNC.SNNE (0x0124)
                        }
                    }

                    Method (_Q14, 0, NotSerialized)
                    {
                        Store (0x14, P80H)
                        If (ECON)
                        {
                            Store (WLRF, Local0)
                        }
                        Else
                        {
                            And (RECS (0x36), 0x02, Local0)
                            ShiftRight (Local0, One, Local0)
                        }

                        If (Local0)
                        {
                            Store (Zero, WONF)
                            Store (One, WOFF)
                            Store (Zero, SONF)
                            Store (Zero, SOFF)
                            ^^SNC.SNNE (0x0124)
                        }
                    }

                    Method (_Q15, 0, NotSerialized)
                    {
                        Store (0x15, P80H)
                        If (ECON)
                        {
                            Store (SIMS, Local0)
                        }
                        Else
                        {
                            And (RECS (0x36), One, Local0)
                        }

                        If (LNot (Local0))
                        {
                            Store (Zero, WONF)
                            Store (Zero, WOFF)
                            Store (One, SONF)
                            Store (Zero, SOFF)
                            ^^SNC.SNNE (0x0124)
                        }
                    }

                    Method (_Q16, 0, NotSerialized)
                    {
                        Store (0x16, P80H)
                        If (ECON)
                        {
                            Store (SIMS, Local0)
                        }
                        Else
                        {
                            And (RECS (0x36), One, Local0)
                        }

                        If (Local0)
                        {
                            Store (Zero, WONF)
                            Store (Zero, WOFF)
                            Store (Zero, SONF)
                            Store (One, SOFF)
                            ^^SNC.SNNE (0x0124)
                        }
                    }
                }

                Device (SPIC)
                {
                    Name (_HID, EisaId ("SNY6001"))
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IO (Decode16,
                                0xC000,             // Range Minimum
                                0xC000,             // Range Maximum
                                0x01,               // Alignment
                                0x20,               // Length
                                _Y10)
                            IRQNoFlags (_Y11)
                                {11}
                        })
                        CreateWordField (BUF0, \_SB.PCI0.LPC.SPIC._CRS._Y10._MIN, IO0S)
                        CreateWordField (BUF0, \_SB.PCI0.LPC.SPIC._CRS._Y10._MAX, IO0E)
                        CreateWordField (BUF0, \_SB.PCI0.LPC.SPIC._CRS._Y11._INT, IRQN)
                        Store (0xC000, IO0S)
                        Store (0xC000, IO0E)
                        Store (0x0800, IRQN)
                        If (ECON)
                        {
                            Store (^^H8EC.SIOP, Local0)
                            Store (^^H8EC.SIRQ, Local1)
                        }
                        Else
                        {
                            Store (RECS (0x2C), Local0)
                            Store (RECS (0x2D), Local1)
                        }

                        If (LEqual (Local0, One))
                        {
                            Store (0xC800, IO0S)
                            Store (0xC800, IO0E)
                        }

                        If (LEqual (Local0, 0x02))
                        {
                            Store (0xD000, IO0S)
                            Store (0xD000, IO0E)
                        }

                        If (LEqual (Local0, 0x03))
                        {
                            Store (0xD800, IO0S)
                            Store (0xD800, IO0E)
                        }

                        If (LEqual (Local1, 0x06))
                        {
                            Store (0x40, IRQN)
                        }

                        If (LEqual (Local1, 0x09))
                        {
                            Store (0x0200, IRQN)
                        }

                        If (LEqual (Local1, 0x0A))
                        {
                            Store (0x0400, IRQN)
                        }

                        Return (BUF0)
                    }

                    Method (_PRS, 0, Serialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            StartDependentFn (0x00, 0x02)
                            {
                                IO (Decode16,
                                    0xC000,             // Range Minimum
                                    0xC000,             // Range Maximum
                                    0x01,               // Alignment
                                    0x20,               // Length
                                    )
                                IRQNoFlags ()
                                    {6,9,10,11}
                            }
                            StartDependentFn (0x00, 0x02)
                            {
                                IO (Decode16,
                                    0xC800,             // Range Minimum
                                    0xC800,             // Range Maximum
                                    0x01,               // Alignment
                                    0x20,               // Length
                                    )
                                IRQNoFlags ()
                                    {6,9,10,11}
                            }
                            StartDependentFn (0x00, 0x02)
                            {
                                IO (Decode16,
                                    0xD000,             // Range Minimum
                                    0xD000,             // Range Maximum
                                    0x01,               // Alignment
                                    0x20,               // Length
                                    )
                                IRQNoFlags ()
                                    {6,9,10,11}
                            }
                            StartDependentFn (0x00, 0x02)
                            {
                                IO (Decode16,
                                    0xD800,             // Range Minimum
                                    0xD800,             // Range Maximum
                                    0x01,               // Alignment
                                    0x20,               // Length
                                    )
                                IRQNoFlags ()
                                    {6,9,10,11}
                            }
                            EndDependentFn ()
                        })
                        Return (BUF0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x02, IO0S)
                        CreateWordField (Arg0, 0x04, IO0E)
                        CreateWordField (Arg0, 0x09, IRQN)
                        Store (0x001CC001, Local0)
                        Store (Zero, Local1)
                        Store (0x0B, Local2)
                        If (LEqual (IO0S, 0xC800))
                        {
                            Store (0x001CC801, Local0)
                            Store (One, Local1)
                        }

                        If (LEqual (IO0S, 0xD000))
                        {
                            Store (0x001CD001, Local0)
                            Store (0x02, Local1)
                        }

                        If (LEqual (IO0S, 0xD800))
                        {
                            Store (0x001CD801, Local0)
                            Store (0x03, Local1)
                        }

                        If (LEqual (IRQN, 0x40))
                        {
                            Store (0x06, Local2)
                        }

                        If (LEqual (IRQN, 0x0200))
                        {
                            Store (0x09, Local2)
                        }

                        If (LEqual (IRQN, 0x0400))
                        {
                            Store (0x0A, Local2)
                        }

                        Store (Local0, ^^G2DA)
                        If (ECON)
                        {
                            Store (Local1, ^^H8EC.SIOP)
                            Store (Local2, ^^H8EC.SIRQ)
                        }
                        Else
                        {
                            SPIR (Local1, Local2)
                        }

                        Store (0x0F, _STA)
                    }

                    Name (_STA, 0x0D)
                    Name (SAVF, Zero)
                    Name (SIOP, Zero)
                    Name (SIRQ, Zero)
                    Name (G2DA, Zero)
                    Method (SAVE, 0, NotSerialized)
                    {
                        If (ECON)
                        {
                            Store (^^H8EC.SIOP, SIOP)
                            Store (^^H8EC.SIRQ, SIRQ)
                        }
                        Else
                        {
                            Store (RECS (0x2C), SIOP)
                            Store (RECS (0x2D), SIRQ)
                        }

                        Store (^^G2DA, G2DA)
                        Store (One, SAVF)
                    }

                    Method (RSTR, 0, NotSerialized)
                    {
                        If (LEqual (SAVF, One))
                        {
                            If (ECON)
                            {
                                Store (SIOP, ^^H8EC.SIOP)
                                Store (SIRQ, ^^H8EC.SIRQ)
                            }
                            Else
                            {
                                SPIR (SIOP, SIRQ)
                            }

                            Store (G2DA, ^^G2DA)
                            Store (Zero, SAVF)
                        }
                    }
                }

                Device (TPM)
                {
                    Method (_HID, 0, Serialized)
                    {
                        If (LEqual (TVID, 0x15D1))
                        {
                            Return (0x0201D824)
                        }
                        Else
                        {
                            If (LEqual (TVID, 0x19FA))
                            {
                                Return (0x0435CF4D)
                            }
                            Else
                            {
                                Return (0x310CD041)
                            }
                        }
                    }

                    Name (_CID, 0x310CD041)
                    Name (_STR, Unicode ("TPM 1.2 Device"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0xFED40000,         // Address Base
                            0x00005000,         // Address Length
                            )
                    })
                    OperationRegion (CMOS, SystemIO, 0x70, 0x04)
                    Field (CMOS, ByteAcc, NoLock, Preserve)
                    {
                        IDX0,   7, 
                                Offset (0x01), 
                        DAT0,   8, 
                        IDX1,   7, 
                                Offset (0x03), 
                        DAT1,   8
                    }

                    IndexField (IDX1, DAT1, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x40), 
                        CCMD,   8, 
                        LCMD,   8, 
                        LRET,   32, 
                        EXST,   8
                    }

                    OperationRegion (SSMI, SystemIO, 0xB2, One)
                    Field (SSMI, ByteAcc, NoLock, Preserve)
                    {
                        SMID,   8
                    }

                    OperationRegion (TMMB, SystemMemory, 0xFED40000, 0x1000)
                    Field (TMMB, ByteAcc, Lock, Preserve)
                    {
                        ACCS,   8, 
                                Offset (0x18), 
                        TSTA,   8, 
                        TBCA,   8, 
                                Offset (0xF00), 
                        TVID,   16, 
                        TDID,   16
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        Store (_STA (), EXST)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (ACCS, 0xFF))
                        {
                            Return (Zero)
                        }

                        Return (0x0F)
                    }

                    Method (HINF, 3, NotSerialized)
                    {
                        Name (_T_0, Zero)
                        Store (Arg1, _T_0)
                        If (LEqual (_T_0, Zero))
                        {
                            Return (Buffer (One)
                            {
                                0x01
                            })
                        }
                        Else
                        {
                            If (LEqual (_T_0, One))
                            {
                                If (LEqual (_STA (), Zero))
                                {
                                    Return (Package (0x01)
                                    {
                                        Zero
                                    })
                                }

                                Return (Package (0x02)
                                {
                                    One, 
                                    Package (0x02)
                                    {
                                        One, 
                                        0x20
                                    }
                                })
                            }
                            Else
                            {
                                BreakPoint
                            }
                        }

                        Return (Buffer (Zero) {})
                    }

                    Method (TPPI, 3, NotSerialized)
                    {
                        Name (_T_0, Zero)
                        Store (Arg1, _T_0)
                        If (LEqual (_T_0, Zero))
                        {
                            Return (Buffer (One)
                            {
                                0x3F
                            })
                        }
                        Else
                        {
                            If (LEqual (_T_0, One))
                            {
                                Return ("1.0")
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x02))
                                {
                                    CreateByteField (Arg2, Zero, TPC1)
                                    Or (TPC1, 0x80, TPCC)
                                    Store (0x50, SMID)
                                    Return (Zero)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x03))
                                    {
                                        Name (TCCP, Package (0x02)
                                        {
                                            Zero, 
                                            0xFF
                                        })
                                        Store (TPCC, Index (TCCP, One))
                                        Return (TCCP)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x04))
                                        {
                                            Return (0x02)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x05))
                                            {
                                                Name (TLCR, Package (0x03)
                                                {
                                                    Zero, 
                                                    0xFF, 
                                                    0xFFFF
                                                })
                                                Store (TPLC, Index (TLCR, One))
                                                Store (TPLR, Index (TLCR, 0x02))
                                                Return (TLCR)
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_0, 0x06))
                                                {
                                                    Store (DerefOf (Index (Arg2, 0x04)), Local0)
                                                    Store (DerefOf (Index (Arg2, 0x05)), Local1)
                                                    If (LOr (LEqual (Local0, 0x65), LEqual (Local0, 0x45)))
                                                    {
                                                        If (LOr (LEqual (Local1, 0x6E), LEqual (Local1, 0x4E)))
                                                        {
                                                            Return (Zero)
                                                        }
                                                    }

                                                    Return (One)
                                                }
                                                Else
                                                {
                                                    BreakPoint
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Return (One)
                    }

                    Method (SMOR, 3, NotSerialized)
                    {
                        Store (Index (Arg2, Zero), TPMM)
                        Store (0x48, SMID)
                        Return (Zero)
                    }

                    Method (_DSM, 4, NotSerialized)
                    {
                        If (LEqual (Arg0, Buffer (0x10)
                                {
                                    /* 0000 */    0xA5, 0x16, 0x8E, 0xCF, 0xE8, 0xC1, 0x25, 0x4E, 
                                    /* 0008 */    0xB7, 0x12, 0x4F, 0x54, 0xA9, 0x67, 0x02, 0xC8
                                }))
                        {
                            Return (HINF (Arg1, Arg2, Arg3))
                        }

                        If (LEqual (Arg0, Buffer (0x10)
                                {
                                    /* 0000 */    0xA6, 0xFA, 0xDD, 0x3D, 0x1B, 0x36, 0xB4, 0x4E, 
                                    /* 0008 */    0xA4, 0x24, 0x8D, 0x10, 0x08, 0x9D, 0x16, 0x53
                                }))
                        {
                            Return (TPPI (Arg1, Arg2, Arg3))
                        }

                        If (LEqual (Arg0, Buffer (0x10)
                                {
                                    /* 0000 */    0xED, 0x54, 0x60, 0x37, 0x13, 0xCC, 0x75, 0x46, 
                                    /* 0008 */    0x90, 0x1C, 0x47, 0x56, 0xD7, 0xF2, 0xD4, 0x5D
                                }))
                        {
                            Return (SMOR (Arg1, Arg2, Arg3))
                        }

                        Return (Buffer (Zero) {})
                    }
                }

                Device (SNC)
                {
                    Name (_HID, EisaId ("SNY5001"))
                    Method (_INI, 0, NotSerialized)
                    {
                        SNIN ()
                    }

                    Method (PWAK, 0, NotSerialized)
                    {
                        If (\ECON)
                        {
                            Store (^^H8EC.ACPW, PWRS)
                        }
                        Else
                        {
                            And (RECS (0x04), One, PWRS)
                        }

                        PNOT ()
                        Return (Zero)
                    }

                    Method (ECON, 1, NotSerialized)
                    {
                        And (Arg0, One, \ECON)
                        Return (\ECON)
                    }

                    Method (GBRT, 0, NotSerialized)
                    {
                        Return (LCDB)
                    }

                    Method (SBRT, 1, Serialized)
                    {
                        If (LAnd (LGreaterEqual (Arg0, Zero), LLessEqual (Arg0, 0x08)))
                        {
                            Store (Arg0, LCDB)
                            Store (ISTP (0x07, Zero), Local0)
                            ^^^OVGA.AINT (One, Local0)
                        }
                        Else
                        {
                        }
                    }

                    Method (EAWK, 1, Serialized)
                    {
                        Store (ISTP (0x06, Zero), Local0)
                        If (LEqual (Local0, Ones))
                        {
                            Return (Not (Arg0))
                        }

                        Return (Arg0)
                    }

                    Name (FNL0, Package (0x10)
                    {
                        0x0100, 
                        0x0101, 
                        Zero, 
                        0x0124, 
                        0x0126, 
                        0x0125, 
                        Zero, 
                        0x0121, 
                        0x0105, 
                        0x0114, 
                        0x0119, 
                        0x0122, 
                        Zero, 
                        0x0115, 
                        Zero, 
                        Zero
                    })
                    Name (FNL1, Package (0x10)
                    {
                        0x0100, 
                        0x0101, 
                        0x0113, 
                        0x0124, 
                        0x0126, 
                        0x0125, 
                        0x011D, 
                        0x0121, 
                        0x0105, 
                        0x0114, 
                        0x0119, 
                        0x0122, 
                        0x0128, 
                        0x0115, 
                        Zero, 
                        Zero
                    })
                    Name (CFGI, Package (0x30) {})
                    Name (ENCR, Zero)
                    Name (ESR, Zero)
                    Mutex (LENR, 0x00)
                    Name (BUFF, Buffer (0x0410) {})
                    CreateDWordField (BUFF, Zero, BUFS)
                    CreateByteField (BUFF, Zero, BUF0)
                    CreateByteField (BUFF, One, BUF1)
                    CreateByteField (BUFF, 0x02, BUF2)
                    CreateByteField (BUFF, 0x03, BUF3)
                    Name (ECR, Zero)
                    Method (SN00, 1, NotSerialized)
                    {
                        If (LAnd (LGreaterEqual (Arg0, Zero), LLess (Arg0, 0x30)))
                        {
                            Return (DerefOf (Index (CFGI, Arg0)))
                        }

                        Return (Zero)
                    }

                    Method (SN01, 0, NotSerialized)
                    {
                        Return (ENCR)
                    }

                    Method (SN02, 1, NotSerialized)
                    {
                        And (Arg0, 0xFFFF, Local0)
                        Acquire (LENR, 0xFFFF)
                        Or (ENCR, Local0, ENCR)
                        Release (LENR)
                    }

                    Method (SN03, 1, NotSerialized)
                    {
                        Not (Arg0, Local0)
                        And (Local0, 0xFFFF, Local0)
                        Acquire (LENR, 0xFFFF)
                        And (ENCR, Local0, ENCR)
                        Release (LENR)
                    }

                    Method (SN04, 0, NotSerialized)
                    {
                        Return (ESR)
                    }

                    Method (SN05, 1, NotSerialized)
                    {
                        Not (Arg0, Local0)
                        And (Local0, 0xFFFF, Local0)
                        And (ESR, Local0, ESR)
                    }

                    Method (SN06, 1, NotSerialized)
                    {
                        Return (SNCF (Arg0, One))
                    }

                    Method (SN07, 1, NotSerialized)
                    {
                        Return (SNCF (Arg0, Zero))
                    }

                    Method (SNIN, 0, NotSerialized)
                    {
                        Store (Zero, Local0)
                        While (LLess (Local0, SizeOf (CFGI)))
                        {
                            Store (Zero, Index (CFGI, Local0))
                            Increment (Local0)
                        }

                        Store (0x53636E53, Index (CFGI, Zero))
                        Store (0x6F707075, Index (CFGI, One))
                        Store (0x64657472, Index (CFGI, 0x02))
                        Store (0x0100, Index (CFGI, 0x03))
                        Store (0x334D0000, Index (CFGI, 0x04))
                        If (LEqual (OSYS, 0x07D6))
                        {
                            Store (FNL1, Local0)
                        }
                        Else
                        {
                            Store (FNL0, Local0)
                        }

                        Store (Zero, Local1)
                        While (LLess (Local1, SizeOf (Local0)))
                        {
                            If (DerefOf (Index (Local0, Local1)))
                            {
                                Or (DerefOf (Index (CFGI, 0x10)), ShiftLeft (One, Local1), 
                                    Index (CFGI, 0x10))
                                Store (DerefOf (Index (Local0, Local1)), Index (CFGI, Add (Local1, 
                                    0x20)))
                            }

                            Increment (Local1)
                        }
                    }

                    Method (SNCF, 2, Serialized)
                    {
                        Store (Arg0, BUFF)
                        Store (And (BUF0, 0x0F), Local0)
                        Name (_T_0, Zero)
                        Store (DerefOf (Index (CFGI, Add (Local0, 0x20))), _T_0)
                        If (LEqual (_T_0, Zero)) {}
                        Else
                        {
                            If (LEqual (_T_0, 0x0100))
                            {
                                F100 ()
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x0101))
                                {
                                    F101 ()
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x0113))
                                    {
                                        F113 ()
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x0105))
                                        {
                                            F105 ()
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x0114))
                                            {
                                                F114 ()
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_0, 0x0115))
                                                {
                                                    F115 ()
                                                }
                                                Else
                                                {
                                                    If (LEqual (_T_0, 0x011D))
                                                    {
                                                        F11D ()
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (_T_0, 0x0119))
                                                        {
                                                            F119 ()
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (_T_0, 0x0121))
                                                            {
                                                                F121 ()
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (_T_0, 0x0122))
                                                                {
                                                                    F122 ()
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (_T_0, 0x0124))
                                                                    {
                                                                        F124 ()
                                                                    }
                                                                    Else
                                                                    {
                                                                        If (LEqual (_T_0, 0x0125))
                                                                        {
                                                                            F125 ()
                                                                        }
                                                                        Else
                                                                        {
                                                                            If (LEqual (_T_0, 0x0126))
                                                                            {
                                                                                F126 ()
                                                                            }
                                                                            Else
                                                                            {
                                                                                If (LEqual (_T_0, 0x0128))
                                                                                {
                                                                                    F128 ()
                                                                                }
                                                                                Else
                                                                                {
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        If (Arg1)
                        {
                            Return (BUFF)
                        }
                        Else
                        {
                            Return (BUFS)
                        }
                    }

                    Method (SNNE, 1, Serialized)
                    {
                        Store (Zero, Local0)
                        While (LLess (Local0, 0x10))
                        {
                            If (LEqual (Arg0, DerefOf (Index (CFGI, Add (0x20, Local0)
                                ))))
                            {
                                Or (ESR, ShiftLeft (One, Local0), ESR)
                                If (And (ENCR, ShiftLeft (One, Local0)))
                                {
                                    Notify (SNC, Add (0x90, Local0))
                                }
                            }

                            Increment (Local0)
                        }
                    }

                    Method (F100, 0, NotSerialized)
                    {
                        Name (_T_0, Zero)
                        Store (BUF1, _T_0)
                        If (LEqual (_T_0, Zero))
                        {
                            Store (One, ^^H8EC.HKEV)
                        }
                        Else
                        {
                            If (LEqual (_T_0, One))
                            {
                                Store (Zero, ^^H8EC.HKEV)
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x02))
                                {
                                    Store (ECR, BUF0)
                                }
                            }
                        }
                    }

                    Method (F113, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (One, BUF0)
                        }

                        If (LEqual (BUF1, One))
                        {
                            Store (^^H8EC.DDRG, Local0)
                            Store (And (Local0, One), BUF0)
                        }

                        If (LEqual (BUF1, 0x02))
                        {
                            Store (And (BUF2, One), Local0)
                            Store (Local0, ^^H8EC.DDRG)
                        }
                    }

                    Scope (^H8EC)
                    {
                        Field (ECF2, ByteAcc, Lock, Preserve)
                        {
                                    Offset (0x3A), 
                            DDRG,   8
                        }
                    }

                    Method (F101, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (One, ^^H8EC.BCHA)
                        }
                        Else
                        {
                            If (LEqual (BUF1, One))
                            {
                                Store (Zero, ^^H8EC.BCHA)
                            }
                        }
                    }

                    Method (F105, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (And (^^H8EC.PDST, One), BUF0)
                        }
                        Else
                        {
                            If (LEqual (BUF1, One))
                            {
                                Store (And (BUF2, One), ^^H8EC.PDST)
                                ISTP (0x08, And (BUF2, One))
                            }
                        }
                    }

                    Method (F114, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (^^H8EC.MODF, BUF0)
                        }
                    }

                    Method (F115, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            And (^^H8EC.BCCS, 0xF1, BUF0)
                        }
                        Else
                        {
                            If (LEqual (BUF1, One))
                            {
                                And (BUF2, 0xF3, ^^H8EC.BCCS)
                            }
                        }
                    }

                    Method (F11D, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (Zero, Local0)
                            Store (Zero, Local1)
                            While (LLess (Local0, SizeOf (DCID)))
                            {
                                Store (DerefOf (Index (DerefOf (Index (DCID, Local0)), Zero)), 
                                    Local2)
                                If (LEqual (GPID (), Local2))
                                {
                                    Store (DerefOf (Index (DerefOf (Index (DCID, Local0)), One)), 
                                        Local1)
                                    Break
                                }
                                Else
                                {
                                    Increment (Local0)
                                }
                            }

                            Store (Local1, BUF0)
                        }
                    }

                    Name (DCID, Package (0x05)
                    {
                        Package (0x02)
                        {
                            0x0F, 
                            Zero
                        }, 

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

                        Package (0x02)
                        {
                            0x09, 
                            Zero
                        }, 

                        Package (0x02)
                        {
                            0x0D, 
                            0x02
                        }, 

                        Package (0x02)
                        {
                            0x0C, 
                            One
                        }
                    })
                    Field (GPIO, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x38), 
                            ,   5, 
                        PID0,   1, 
                        PID1,   1, 
                        PID2,   1
                    }

                    Method (GPID, 0, NotSerialized)
                    {
                        Store (0x08, Local0)
                        Or (Local0, ShiftLeft (PID0, Zero), Local0)
                        Or (Local0, ShiftLeft (PID1, One), Local0)
                        Or (Local0, ShiftLeft (PID2, 0x02), Local0)
                        Return (Local0)
                    }

                    Method (F119, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (^^H8EC.S5LR, Local0)
                            Or (Local0, ShiftLeft (^^H8EC.S4LR, One), Local0)
                            Or (Local0, ShiftLeft (^^H8EC.S3LR, 0x02), Local0)
                            Store (Local0, BUF0)
                        }

                        If (LEqual (BUF1, One))
                        {
                            And (BUF2, One, ^^H8EC.S5LR)
                            ShiftRight (And (BUF2, 0x02), One, ^^H8EC.S4LR)
                            ShiftRight (And (BUF2, 0x04), 0x02, ^^H8EC.S3LR)
                        }
                    }

                    Method (F121, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (One, ^^H8EC.LBHA)
                        }
                        Else
                        {
                            If (LEqual (BUF1, One))
                            {
                                Store (Zero, ^^H8EC.LBHA)
                            }
                            Else
                            {
                                If (LEqual (BUF1, 0x02))
                                {
                                    If (LEqual (^^H8EC.SWUR, One))
                                    {
                                        Store (One, BUF0)
                                    }
                                    Else
                                    {
                                        Store (Zero, BUF0)
                                    }
                                }
                            }
                        }
                    }

                    Method (F122, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (0x03, BUF0)
                        }
                        Else
                        {
                            If (LEqual (BUF1, One))
                            {
                                And (^^H8EC.THMP, 0x03, BUF0)
                            }
                            Else
                            {
                                If (LEqual (BUF1, 0x02))
                                {
                                    And (BUF2, 0x03, Local0)
                                    Store (Local0, ^^H8EC.THMP)
                                }
                            }
                        }
                    }

                    Name (WLAP, Zero)
                    Name (BLTH, Zero)
                    Name (WNED, Zero)
                    Name (WNHP, Zero)
                    Name (WNEV, Zero)
                    Name (WMAX, Zero)
                    Method (F124, 0, NotSerialized)
                    {
                        Store (0xF4, P80H)
                        Store (Zero, WLAP)
                        Store (Zero, BLTH)
                        Store (Zero, WNED)
                        Store (Zero, WNHP)
                        Store (Zero, WNEV)
                        Store (Zero, WMAX)
                        Store (^^^EXP2.WLAN.VID, Local1)
                        Store (^^^EXP2.WLAN.DID, Local2)
                        If (LEqual (Local1, 0x8086))
                        {
                            If (LEqual (Local2, 0x4232))
                            {
                                Store (One, WLAP)
                            }
                            Else
                            {
                                If (LEqual (Local2, 0x4235))
                                {
                                    Store (One, WLAP)
                                }
                                Else
                                {
                                    If (LEqual (Local2, 0x423C))
                                    {
                                        Store (One, WLAP)
                                        Store (One, WMAX)
                                    }
                                    Else
                                    {
                                        Store (0xFF, P80H)
                                        Noop
                                    }
                                }
                            }
                        }

                        If (LEqual (Local1, 0x168C))
                        {
                            If (LEqual (Local2, 0x2A))
                            {
                                Store (One, WLAP)
                            }
                            Else
                            {
                                Store (0xFF, P80H)
                                Noop
                            }
                        }

                        Store (^^H8EC.BTPS, Local1)
                        If (Local1)
                        {
                            Store (One, BLTH)
                        }

                        Store (^^H8EC.EDG, Local1)
                        If (Local1)
                        {
                            Store (One, WNED)
                        }

                        Store (^^H8EC.HSDP, Local1)
                        If (Local1)
                        {
                            Store (One, WNHP)
                        }

                        Store (^^H8EC.EVDO, Local1)
                        If (Local1)
                        {
                            Store (One, WNEV)
                        }

                        Store (And (DerefOf (Index (BUFF, One)), 0x0F), Local0)
                        If (LEqual (Local0, Zero))
                        {
                            Store (Zero, P80H)
                            Store (Zero, Local3)
                            If (WLAP)
                            {
                                Store (Zero, Index (BUFF, Local3))
                                Add (Local3, One, Local3)
                            }

                            If (BLTH)
                            {
                                Store (0x10, Index (BUFF, Local3))
                                Add (Local3, One, Local3)
                            }

                            If (WNED)
                            {
                                Store (0x20, Index (BUFF, Local3))
                                Add (Local3, One, Local3)
                            }

                            If (WNHP)
                            {
                                Store (0x21, Index (BUFF, Local3))
                                Add (Local3, One, Local3)
                            }

                            If (WNEV)
                            {
                                Store (0x22, Index (BUFF, Local3))
                                Add (Local3, One, Local3)
                            }

                            If (WMAX)
                            {
                                Store (0x30, Index (BUFF, Local3))
                                Add (Local3, One, Local3)
                            }

                            Store (0xFF, Index (BUFF, Local3))
                        }
                        Else
                        {
                            If (LEqual (Local0, One))
                            {
                                Store (One, P80H)
                                Store (Zero, Index (BUFF, Zero))
                                Store (Zero, Local1)
                                If (LEqual (^^H8EC.WONF, One))
                                {
                                    Or (Local1, One, Local1)
                                }
                                Else
                                {
                                    If (LEqual (^^H8EC.WOFF, One))
                                    {
                                        Or (Local1, One, Local1)
                                    }
                                    Else
                                    {
                                        If (LEqual (^^H8EC.SONF, One))
                                        {
                                            Or (Local1, 0x02, Local1)
                                        }
                                        Else
                                        {
                                            If (LEqual (^^H8EC.SOFF, One))
                                            {
                                                Or (Local1, 0x02, Local1)
                                            }
                                            Else
                                            {
                                                Store (0x11, P80H)
                                                Noop
                                            }
                                        }
                                    }
                                }

                                Store (Zero, ^^H8EC.WONF)
                                Store (Zero, ^^H8EC.WOFF)
                                Store (Zero, ^^H8EC.SONF)
                                Store (Zero, ^^H8EC.SOFF)
                                Store (Local1, Index (BUFF, Zero))
                            }
                            Else
                            {
                                If (LEqual (Local0, 0x02))
                                {
                                    Store (0x02, P80H)
                                    Store (Zero, Index (BUFF, Zero))
                                    If (^^H8EC.SIMS)
                                    {
                                        Store (0x32, P80H)
                                    }
                                    Else
                                    {
                                        Store (DerefOf (Index (BUFF, Zero)), Local2)
                                        Or (Local2, 0x02, Local2)
                                        Store (Local2, Index (BUFF, Zero))
                                        Store (0x12, P80H)
                                    }

                                    If (^^H8EC.WLRF)
                                    {
                                        Store (0x42, P80H)
                                    }
                                    Else
                                    {
                                        Store (DerefOf (Index (BUFF, Zero)), Local2)
                                        Or (Local2, One, Local2)
                                        Store (Local2, Index (BUFF, Zero))
                                        Store (0x52, P80H)
                                    }
                                }
                                Else
                                {
                                    If (LEqual (Local0, 0x03))
                                    {
                                        Store (0x03, P80H)
                                        Store (Zero, Index (BUFF, Zero))
                                        If (WLAP)
                                        {
                                            Store (0x33, P80H)
                                            Store (Zero, Index (BUFF, Zero))
                                            If (^^H8EC.WLSL)
                                            {
                                                Store (DerefOf (Index (BUFF, Zero)), Local2)
                                                Or (Local2, 0x02, Local2)
                                                Store (Local2, Index (BUFF, Zero))
                                                Store (0x13, P80H)
                                            }
                                            Else
                                            {
                                                Store (0x23, P80H)
                                            }

                                            If (^^H8EC.WLPW)
                                            {
                                                Store (DerefOf (Index (BUFF, Zero)), Local2)
                                                Or (Local2, One, Local2)
                                                Store (Local2, Index (BUFF, Zero))
                                                Store (0x33, P80H)
                                            }
                                            Else
                                            {
                                                Store (0x43, P80H)
                                            }
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (Local0, 0x04))
                                        {
                                            Store (0x04, P80H)
                                            If (WLAP)
                                            {
                                                Store (0x44, P80H)
                                                Store (And (DerefOf (Index (BUFF, 0x02)), 0x02), Local1)
                                                If (LEqual (Local1, 0x02))
                                                {
                                                    Store (One, ^^H8EC.WLSL)
                                                }
                                                Else
                                                {
                                                    Store (Zero, ^^H8EC.WLSL)
                                                }

                                                If (^^H8EC.WLRF)
                                                {
                                                    Store (Zero, ^^H8EC.WLPW)
                                                }
                                                Else
                                                {
                                                    Store (And (DerefOf (Index (BUFF, 0x02)), One), Local1)
                                                    If (LEqual (Local1, One))
                                                    {
                                                        Store (One, ^^H8EC.WLPW)
                                                    }
                                                    Else
                                                    {
                                                        Store (Zero, ^^H8EC.WLPW)
                                                    }
                                                }
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (Local0, 0x05))
                                            {
                                                Store (0x05, P80H)
                                                Store (Zero, Index (BUFF, Zero))
                                                If (BLTH)
                                                {
                                                    Store (0x55, P80H)
                                                    Store (Zero, Index (BUFF, Zero))
                                                    If (^^H8EC.BTSL)
                                                    {
                                                        Store (DerefOf (Index (BUFF, Zero)), Local2)
                                                        Or (Local2, 0x02, Local2)
                                                        Store (Local2, Index (BUFF, Zero))
                                                        Store (0x15, P80H)
                                                    }
                                                    Else
                                                    {
                                                        Store (0x25, P80H)
                                                    }

                                                    If (^^H8EC.BTPW)
                                                    {
                                                        Store (DerefOf (Index (BUFF, Zero)), Local2)
                                                        Or (Local2, One, Local2)
                                                        Store (Local2, Index (BUFF, Zero))
                                                        Store (0x35, P80H)
                                                    }
                                                    Else
                                                    {
                                                        Store (0x45, P80H)
                                                    }
                                                }
                                            }
                                            Else
                                            {
                                                If (LEqual (Local0, 0x06))
                                                {
                                                    Store (0x06, P80H)
                                                    If (BLTH)
                                                    {
                                                        Store (0x66, P80H)
                                                        Store (And (DerefOf (Index (BUFF, 0x02)), 0x02), Local1)
                                                        If (LEqual (Local1, 0x02))
                                                        {
                                                            Store (One, ^^H8EC.BTSL)
                                                        }
                                                        Else
                                                        {
                                                            Store (Zero, ^^H8EC.BTSL)
                                                        }

                                                        If (^^H8EC.WLRF)
                                                        {
                                                            Store (Zero, ^^H8EC.BTPW)
                                                        }
                                                        Else
                                                        {
                                                            Store (And (DerefOf (Index (BUFF, 0x02)), One), Local1)
                                                            If (LEqual (Local1, One))
                                                            {
                                                                Store (One, ^^H8EC.BTPW)
                                                            }
                                                            Else
                                                            {
                                                                Store (Zero, ^^H8EC.BTPW)
                                                            }
                                                        }
                                                    }
                                                }
                                                Else
                                                {
                                                    If (LEqual (Local0, 0x07))
                                                    {
                                                        Store (0x07, P80H)
                                                        Store (Zero, Index (BUFF, Zero))
                                                        Store (Zero, Local1)
                                                        Or (Local1, WNED, Local1)
                                                        Or (Local1, WNHP, Local1)
                                                        Or (Local1, WNEV, Local1)
                                                        If (Local1)
                                                        {
                                                            Store (0x77, P80H)
                                                            Store (Zero, Index (BUFF, Zero))
                                                            If (^^H8EC.WWRF)
                                                            {
                                                                Store (DerefOf (Index (BUFF, Zero)), Local3)
                                                                Or (Local3, 0x04, Local3)
                                                                Store (Local3, Index (BUFF, Zero))
                                                            }
                                                            Else
                                                            {
                                                                Store (DerefOf (Index (BUFF, Zero)), Local3)
                                                                And (Local3, 0xFB, Local3)
                                                                Store (Local3, Index (BUFF, Zero))
                                                            }

                                                            If (^^H8EC.WWSL)
                                                            {
                                                                Store (DerefOf (Index (BUFF, Zero)), Local3)
                                                                Or (Local3, 0x02, Local3)
                                                                Store (Local3, Index (BUFF, Zero))
                                                            }
                                                            Else
                                                            {
                                                                Noop
                                                            }

                                                            If (^^H8EC.WWPW)
                                                            {
                                                                Store (DerefOf (Index (BUFF, Zero)), Local3)
                                                                Or (Local3, One, Local3)
                                                                Store (Local3, Index (BUFF, Zero))
                                                            }
                                                        }
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (Local0, 0x08))
                                                        {
                                                            Store (0x08, P80H)
                                                            Store (Zero, Local1)
                                                            Or (Local1, WNED, Local1)
                                                            Or (Local1, WNHP, Local1)
                                                            Or (Local1, WNEV, Local1)
                                                            If (Local1)
                                                            {
                                                                Store (0x88, P80H)
                                                                Store (And (DerefOf (Index (BUFF, 0x02)), 0x07), Local2)
                                                                And (Local2, One, Local3)
                                                                If (LEqual (Local3, One))
                                                                {
                                                                    Store (One, ^^H8EC.WWPW)
                                                                }
                                                                Else
                                                                {
                                                                    Store (Zero, ^^H8EC.WWPW)
                                                                }

                                                                And (Local2, 0x04, Local3)
                                                                If (LEqual (Local3, 0x04))
                                                                {
                                                                    Store (One, ^^H8EC.WWRF)
                                                                }
                                                                Else
                                                                {
                                                                    Store (Zero, ^^H8EC.WWRF)
                                                                }

                                                                And (Local2, 0x02, Local3)
                                                                If (LEqual (Local3, 0x02))
                                                                {
                                                                    Store (One, ^^H8EC.WWSL)
                                                                }
                                                                Else
                                                                {
                                                                    Store (Zero, ^^H8EC.WWSL)
                                                                }

                                                                Store (And (DerefOf (Index (BUFF, 0x03)), 0x9F), Local2)
                                                                And (Local2, 0x80, Local3)
                                                                If (LEqual (Local3, 0x80))
                                                                {
                                                                    And (Local2, 0x1F, Local3)
                                                                    Store (Local3, ^^H8EC.PNDC)
                                                                }
                                                            }
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (Local0, 0x09))
                                                            {
                                                                Store (0x09, P80H)
                                                                Store (Zero, Index (BUFF, Zero))
                                                                If (WMAX)
                                                                {
                                                                    Store (0x99, P80H)
                                                                    Store (Zero, Index (BUFF, Zero))
                                                                    If (^^H8EC.WLSL)
                                                                    {
                                                                        Store (DerefOf (Index (BUFF, Zero)), Local2)
                                                                        Or (Local2, 0x02, Local2)
                                                                        Store (Local2, Index (BUFF, Zero))
                                                                        Store (0x13, P80H)
                                                                    }
                                                                    Else
                                                                    {
                                                                        Store (0x23, P80H)
                                                                    }

                                                                    If (^^H8EC.WLPW)
                                                                    {
                                                                        Store (DerefOf (Index (BUFF, Zero)), Local2)
                                                                        Or (Local2, One, Local2)
                                                                        Store (Local2, Index (BUFF, Zero))
                                                                        Store (0x33, P80H)
                                                                    }
                                                                    Else
                                                                    {
                                                                        Store (0x43, P80H)
                                                                    }
                                                                }
                                                            }
                                                            Else
                                                            {
                                                                If (LEqual (Local0, 0x0A))
                                                                {
                                                                    Store (0x0A, P80H)
                                                                    If (WMAX)
                                                                    {
                                                                        Store (0xAA, P80H)
                                                                        Store (And (DerefOf (Index (BUFF, 0x02)), 0x02), Local1)
                                                                        If (LEqual (Local1, 0x02))
                                                                        {
                                                                            Store (One, ^^H8EC.WLSL)
                                                                        }
                                                                        Else
                                                                        {
                                                                            Store (Zero, ^^H8EC.WLSL)
                                                                        }

                                                                        If (^^H8EC.WLRF)
                                                                        {
                                                                            Store (Zero, ^^H8EC.WLPW)
                                                                        }
                                                                        Else
                                                                        {
                                                                            Store (And (DerefOf (Index (BUFF, 0x02)), One), Local1)
                                                                            If (LEqual (Local1, One))
                                                                            {
                                                                                Store (One, ^^H8EC.WLPW)
                                                                            }
                                                                            Else
                                                                            {
                                                                                Store (Zero, ^^H8EC.WLPW)
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                Else
                                                                {
                                                                    If (LEqual (Local0, 0x0B))
                                                                    {
                                                                        Store (0x0B, P80H)
                                                                        Store (Zero, Index (BUFF, Zero))
                                                                        Store (Zero, Index (BUFF, One))
                                                                        Store (DerefOf (Index (BUFF, Zero)), Local1)
                                                                        If (WLAP)
                                                                        {
                                                                            Or (Local1, One, Local1)
                                                                        }

                                                                        If (BLTH)
                                                                        {
                                                                            Or (Local1, 0x02, Local1)
                                                                        }

                                                                        If (WNED)
                                                                        {
                                                                            Or (Local1, 0x04, Local1)
                                                                        }

                                                                        If (WNHP)
                                                                        {
                                                                            Or (Local1, 0x08, Local1)
                                                                        }

                                                                        If (WNEV)
                                                                        {
                                                                            Or (Local1, 0x10, Local1)
                                                                        }

                                                                        If (WMAX)
                                                                        {
                                                                            Or (Local1, 0x20, Local1)
                                                                        }

                                                                        Store (Local1, Index (BUFF, Zero))
                                                                    }
                                                                    Else
                                                                    {
                                                                        Store (0x0C, P80H)
                                                                        Noop
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Method (F125, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (^^H8EC.SFN0, Index (BUFF, Zero))
                            Store (^^H8EC.SFN1, Index (BUFF, One))
                            Store (^^H8EC.SFN2, Index (BUFF, 0x02))
                            Store (^^H8EC.SFN3, Index (BUFF, 0x03))
                            Store (^^H8EC.SFN4, Index (BUFF, 0x04))
                            Store (^^H8EC.SFN5, Index (BUFF, 0x05))
                            Store (^^H8EC.SFN6, Index (BUFF, 0x06))
                            Store (^^H8EC.SFN7, Index (BUFF, 0x07))
                        }
                    }

                    Method (F126, 0, NotSerialized)
                    {
                        Store (0xF6, P80H)
                        Name (TMNT, Package (0x10)
                        {
                            Zero, 
                            0xFF, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (TST1, Package (0x10)
                        {
                            Zero, 
                            0x11, 
                            0x22, 
                            0x33, 
                            0x44, 
                            0x55, 
                            0x66, 
                            0x77, 
                            0x88, 
                            0x99, 
                            0xAA, 
                            0xBB, 
                            0xCC, 
                            0xDD, 
                            0xEE, 
                            0xFF
                        })
                        Name (STAH, Package (0x10)
                        {
                            One, 
                            Zero, 
                            0x86, 
                            0x80, 
                            0x29, 
                            0x29, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (STRD, Package (0x10)
                        {
                            One, 
                            Zero, 
                            0x86, 
                            0x80, 
                            0x2A, 
                            0x28, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Name (USOP, Package (0x10)
                        {
                            0x02, 
                            Zero, 
                            0x86, 
                            0x80, 
                            0x3A, 
                            0x29, 
                            0x05, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        If (LEqual (BUF1, Zero))
                        {
                            Store (Zero, P80H)
                            If (^^H8EC.SOPP)
                            {
                                Store (0x1F, Local1)
                                Store (^^^SAT0.VID, Local2)
                                Store (^^^SAT0.DID, Local3)
                                If (LEqual (Local2, 0x8086))
                                {
                                    Name (_T_0, Zero)
                                    Store (Local3, _T_0)
                                    If (LEqual (_T_0, 0x2928))
                                    {
                                        While (LGreater (Local1, 0x10))
                                        {
                                            Subtract (Local1, 0x10, Local2)
                                            Store (DerefOf (Index (TMNT, Local2)), Index (BUFF, Local1))
                                            Decrement (Local1)
                                        }

                                        Store (DerefOf (Index (TMNT, Zero)), Index (BUFF, 0x10))
                                        Decrement (Local1)
                                        While (Local1)
                                        {
                                            Store (DerefOf (Index (TST1, Local1)), Index (BUFF, Local1))
                                            Decrement (Local1)
                                        }

                                        Store (DerefOf (Index (TST1, Zero)), Index (BUFF, Zero))
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x2929))
                                        {
                                            While (LGreater (Local1, 0x10))
                                            {
                                                Subtract (Local1, 0x10, Local2)
                                                Store (DerefOf (Index (TMNT, Local2)), Index (BUFF, Local1))
                                                Decrement (Local1)
                                            }

                                            Store (DerefOf (Index (TMNT, Zero)), Index (BUFF, 0x10))
                                            Decrement (Local1)
                                            While (Local1)
                                            {
                                                Store (DerefOf (Index (STAH, Local1)), Index (BUFF, Local1))
                                                Decrement (Local1)
                                            }

                                            Store (DerefOf (Index (STAH, Zero)), Index (BUFF, Zero))
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x282A))
                                            {
                                                While (LGreater (Local1, 0x10))
                                                {
                                                    Subtract (Local1, 0x10, Local2)
                                                    Store (DerefOf (Index (TMNT, Local2)), Index (BUFF, Local1))
                                                    Decrement (Local1)
                                                }

                                                Store (DerefOf (Index (TMNT, Zero)), Index (BUFF, 0x10))
                                                Decrement (Local1)
                                                While (Local1)
                                                {
                                                    Store (DerefOf (Index (STRD, Local1)), Index (BUFF, Local1))
                                                    Decrement (Local1)
                                                }

                                                Store (DerefOf (Index (STRD, Zero)), Index (BUFF, Zero))
                                            }
                                            Else
                                            {
                                                Noop
                                            }
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x0F, Local1)
                                While (Local1)
                                {
                                    Store (DerefOf (Index (TMNT, Local1)), Index (BUFF, Local1))
                                    Decrement (Local1)
                                }

                                Store (DerefOf (Index (TMNT, Zero)), Index (BUFF, Zero))
                            }
                        }
                        Else
                        {
                            If (LEqual (BUF1, One))
                            {
                                Store (One, P80H)
                                If (^^H8EC.SOPP)
                                {
                                    Store (^^H8EC.SOPS, Local1)
                                    If (Local1)
                                    {
                                        Store (One, Index (BUFF, Zero))
                                        Store (Zero, Index (BUFF, One))
                                    }
                                    Else
                                    {
                                        Store (Zero, Index (BUFF, Zero))
                                        Store (Zero, Index (BUFF, One))
                                    }
                                }
                                Else
                                {
                                    Store (Zero, Index (BUFF, Zero))
                                    Store (Zero, Index (BUFF, One))
                                }
                            }
                            Else
                            {
                                If (LEqual (BUF1, 0x02))
                                {
                                    Store (0x02, P80H)
                                    If (^^H8EC.SOPP)
                                    {
                                        Store (One, ^^H8EC.SOPS)
                                    }
                                    Else
                                    {
                                        Noop
                                    }
                                }
                                Else
                                {
                                    If (LEqual (BUF1, 0x03))
                                    {
                                        Store (0x03, P80H)
                                        If (^^H8EC.SOPP)
                                        {
                                            Store (Zero, ^^H8EC.SOPS)
                                        }
                                        Else
                                        {
                                            Noop
                                        }
                                    }
                                    Else
                                    {
                                        Store (0x04, P80H)
                                        Noop
                                    }
                                }
                            }
                        }
                    }

                    Method (F128, 0, NotSerialized)
                    {
                        If (LEqual (BUF1, Zero))
                        {
                            Store (HSC0 (), BUF0)
                        }

                        If (LEqual (BUF1, One))
                        {
                            Store (HSC1 (), BUF0)
                        }

                        If (LEqual (BUF1, 0x02))
                        {
                            HSC2 ()
                        }

                        If (LEqual (BUF1, 0x03))
                        {
                            HSC3 (BUF2)
                        }

                        If (LEqual (BUF1, 0x04))
                        {
                            HSC4 (BUF2)
                        }
                    }
                }
            }

            Device (UHC0)
            {
                Name (_ADR, 0x001D0000)
                Name (_PRW, Package (0x02)
                {
                    0x03, 
                    0x03
                })
                OperationRegion (USBR, PCI_Config, 0xC4, One)
                Field (USBR, AnyAcc, NoLock, Preserve)
                {
                    URES,   2, 
                            Offset (0x01)
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, URES)
                    }
                    Else
                    {
                        Store (Zero, URES)
                    }
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (UHC1)
            {
                Name (_ADR, 0x001D0001)
                Name (_PRW, Package (0x02)
                {
                    0x04, 
                    0x03
                })
                OperationRegion (USBR, PCI_Config, 0xC4, One)
                Field (USBR, AnyAcc, NoLock, Preserve)
                {
                    URES,   2, 
                            Offset (0x01)
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, URES)
                    }
                    Else
                    {
                        Store (Zero, URES)
                    }
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (UHC2)
            {
                Name (_ADR, 0x001D0002)
                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x03
                })
                OperationRegion (USBR, PCI_Config, 0xC4, One)
                Field (USBR, AnyAcc, NoLock, Preserve)
                {
                    URES,   2, 
                            Offset (0x01)
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, URES)
                    }
                    Else
                    {
                        Store (Zero, URES)
                    }
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (UHCR)
            {
                Name (_ADR, 0x001D0003)
                Name (_PRW, Package (0x02)
                {
                    0x20, 
                    0x03
                })
                OperationRegion (USBR, PCI_Config, 0xC4, One)
                Field (USBR, AnyAcc, NoLock, Preserve)
                {
                    URES,   2, 
                            Offset (0x01)
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, URES)
                    }
                    Else
                    {
                        Store (Zero, URES)
                    }
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (EHC1)
            {
                Name (_ADR, 0x001D0007)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
                OperationRegion (EHCR, PCI_Config, 0x54, 0x04)
                Field (EHCR, AnyAcc, NoLock, Preserve)
                {
                        ,   15, 
                    PMES,   1
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (UHC3)
            {
                Name (_ADR, 0x001A0000)
                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                OperationRegion (USBR, PCI_Config, 0xC4, One)
                Field (USBR, AnyAcc, NoLock, Preserve)
                {
                    URES,   2, 
                            Offset (0x01)
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, URES)
                    }
                    Else
                    {
                        Store (Zero, URES)
                    }
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (UHC4)
            {
                Name (_ADR, 0x001A0001)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                OperationRegion (USBR, PCI_Config, 0xC4, One)
                Field (USBR, AnyAcc, NoLock, Preserve)
                {
                    URES,   2, 
                            Offset (0x01)
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, URES)
                    }
                    Else
                    {
                        Store (Zero, URES)
                    }
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (UHC5)
            {
                Name (_ADR, 0x001A0002)
                Name (_PRW, Package (0x02)
                {
                    0x04, 
                    0x03
                })
                OperationRegion (USBR, PCI_Config, 0xC4, One)
                Field (USBR, AnyAcc, NoLock, Preserve)
                {
                    URES,   2, 
                            Offset (0x01)
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, URES)
                    }
                    Else
                    {
                        Store (Zero, URES)
                    }
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (EHC2)
            {
                Name (_ADR, 0x001A0007)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
                OperationRegion (EHCR, PCI_Config, 0x54, 0x04)
                Field (EHCR, AnyAcc, NoLock, Preserve)
                {
                        ,   15, 
                    PMES,   1
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (EXP1)
            {
                Name (_ADR, 0x001C0000)
                OperationRegion (PXCS, PCI_Config, Zero, 0xE0)
                Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
                {
                    VDID,   16, 
                            Offset (0x52), 
                        ,   13, 
                    LASX,   1, 
                            Offset (0x5A), 
                    ABPX,   1, 
                        ,   2, 
                    PDCX,   1, 
                        ,   2, 
                    PDSX,   1, 
                            Offset (0x5B), 
                    LSCX,   1, 
                            Offset (0x60), 
                            Offset (0x62), 
                    PSPX,   1, 
                            Offset (0xDC), 
                        ,   30, 
                    HPSX,   1, 
                    PMSX,   1
                }

                Device (ECD0)
                {
                    Name (_ADR, Zero)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Device (ECD1)
                {
                    Name (_ADR, One)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Device (ECD2)
                {
                    Name (_ADR, 0x02)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Device (ECD3)
                {
                    Name (_ADR, 0x03)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Device (ECD4)
                {
                    Name (_ADR, 0x04)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Device (ECD5)
                {
                    Name (_ADR, 0x05)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Device (ECD6)
                {
                    Name (_ADR, 0x06)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Device (ECD7)
                {
                    Name (_ADR, 0x07)
                    Name (_SUN, One)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Method (_RMV, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Name (_HPP, Package (0x04)
                {
                    0x10, 
                    Zero, 
                    Zero, 
                    Zero
                })
                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x03
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                ^^LPC.LNKA, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                Zero, 
                                0x10
                            }
                        })
                    }
                }
            }

            Device (EXP2)
            {
                Name (_ADR, 0x001C0001)
                OperationRegion (PXCS, PCI_Config, Zero, 0xE0)
                Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
                {
                    VDID,   16, 
                            Offset (0x52), 
                        ,   13, 
                    LASX,   1, 
                            Offset (0x5A), 
                    ABPX,   1, 
                        ,   2, 
                    PDCX,   1, 
                        ,   2, 
                    PDSX,   1, 
                            Offset (0x5B), 
                    LSCX,   1, 
                            Offset (0x60), 
                            Offset (0x62), 
                    PSPX,   1, 
                            Offset (0xDC), 
                        ,   30, 
                    HPSX,   1, 
                    PMSX,   1
                }

                Device (WLAN)
                {
                    Name (_ADR, Zero)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    OperationRegion (WLCS, PCI_Config, Zero, 0x04)
                    Field (WLCS, AnyAcc, NoLock, Preserve)
                    {
                        VID,    16, 
                        DID,    16
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x03
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                ^^LPC.LNKB, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                Zero, 
                                0x11
                            }
                        })
                    }
                }
            }

            Device (EXP3)
            {
                Name (_ADR, 0x001C0002)
                OperationRegion (PXCS, PCI_Config, Zero, 0xE0)
                Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
                {
                    VDID,   16, 
                            Offset (0x52), 
                        ,   13, 
                    LASX,   1, 
                            Offset (0x5A), 
                    ABPX,   1, 
                        ,   2, 
                    PDCX,   1, 
                        ,   2, 
                    PDSX,   1, 
                            Offset (0x5B), 
                    LSCX,   1, 
                            Offset (0x60), 
                            Offset (0x62), 
                    PSPX,   1, 
                            Offset (0xDC), 
                        ,   30, 
                    HPSX,   1, 
                    PMSX,   1
                }

                Device (MLAN)
                {
                    Name (_ADR, Zero)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                }

                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x03
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                ^^LPC.LNKC, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                Zero, 
                                0x12
                            }
                        })
                    }
                }
            }

            Device (EXP4)
            {
                Name (_ADR, 0x001C0003)
                OperationRegion (PXCS, PCI_Config, Zero, 0xE0)
                Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
                {
                    VDID,   16, 
                            Offset (0x52), 
                        ,   13, 
                    LASX,   1, 
                            Offset (0x5A), 
                    ABPX,   1, 
                        ,   2, 
                    PDCX,   1, 
                        ,   2, 
                    PDSX,   1, 
                            Offset (0x5B), 
                    LSCX,   1, 
                            Offset (0x60), 
                            Offset (0x62), 
                    PSPX,   1, 
                            Offset (0xDC), 
                        ,   30, 
                    HPSX,   1, 
                    PMSX,   1
                }

                Device (DLAN)
                {
                    Name (_ADR, Zero)
                    Name (_SUN, 0x04)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                    Name (_EJD, "\\_SB.DOCK")
                }

                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x03
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                ^^LPC.LNKD, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                Zero, 
                                0x13
                            }
                        })
                    }
                }
            }

            Device (EXP5)
            {
                Name (_ADR, 0x001C0004)
                OperationRegion (PXCS, PCI_Config, Zero, 0xE0)
                Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
                {
                    VDID,   16, 
                            Offset (0x52), 
                        ,   13, 
                    LASX,   1, 
                            Offset (0x5A), 
                    ABPX,   1, 
                        ,   2, 
                    PDCX,   1, 
                        ,   2, 
                    PDSX,   1, 
                            Offset (0x5B), 
                    LSCX,   1, 
                            Offset (0x60), 
                            Offset (0x62), 
                    PSPX,   1, 
                            Offset (0xDC), 
                        ,   30, 
                    HPSX,   1, 
                    PMSX,   1
                }

                Device (PXSX)
                {
                    Name (_ADR, Zero)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                }

                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x03
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                ^^LPC.LNKA, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                Zero, 
                                0x10
                            }
                        })
                    }
                }
            }

            Device (EXP6)
            {
                Name (_ADR, 0x001C0005)
                OperationRegion (PXCS, PCI_Config, Zero, 0xE0)
                Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
                {
                    VDID,   16, 
                            Offset (0x52), 
                        ,   13, 
                    LASX,   1, 
                            Offset (0x5A), 
                    ABPX,   1, 
                        ,   2, 
                    PDCX,   1, 
                        ,   2, 
                    PDSX,   1, 
                            Offset (0x5B), 
                    LSCX,   1, 
                            Offset (0x60), 
                            Offset (0x62), 
                    PSPX,   1, 
                            Offset (0xDC), 
                        ,   30, 
                    HPSX,   1, 
                    PMSX,   1
                }

                Device (PXSX)
                {
                    Name (_ADR, Zero)
                    Name (_PRW, Package (0x02)
                    {
                        0x09, 
                        0x03
                    })
                }

                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x03
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LEqual (GPIC, Zero))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                ^^LPC.LNKC, 
                                Zero
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                Zero, 
                                Zero, 
                                0x12
                            }
                        })
                    }
                }
            }

            Device (SAT0)
            {
                Name (_ADR, 0x001F0002)
                OperationRegion (SACS, PCI_Config, Zero, 0x0100)
                Field (SACS, DWordAcc, NoLock, Preserve)
                {
                    VID,    16, 
                    DID,    16, 
                            Offset (0x40), 
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                            Offset (0x48), 
                    SYNC,   4, 
                            Offset (0x4A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                            Offset (0x4B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                            Offset (0x54), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4, 
                            Offset (0x90), 
                    MAPV,   2
                }

                Device (PRID)
                {
                    Name (_ADR, Zero)
                    Method (_GTM, 0, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            Name (PBUF, Buffer (0x14)
                            {
                                /* 0000 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x00, 0x00, 0x00
                            })
                            CreateDWordField (PBUF, Zero, PIO0)
                            CreateDWordField (PBUF, 0x04, DMA0)
                            CreateDWordField (PBUF, 0x08, PIO1)
                            CreateDWordField (PBUF, 0x0C, DMA1)
                            CreateDWordField (PBUF, 0x10, FLAG)
                            Store (GETP (PRIT), PIO0)
                            Store (GDMA (And (SYNC, One), And (ICR3, One), 
                                And (ICR0, One), SDT0, And (ICR1, One)), DMA0)
                            If (LEqual (DMA0, Ones))
                            {
                                Store (PIO0, DMA0)
                            }

                            If (And (PRIT, 0x4000))
                            {
                                If (LEqual (And (PRIT, 0x90), 0x80))
                                {
                                    Store (0x0384, PIO1)
                                }
                                Else
                                {
                                    Store (GETT (PSIT), PIO1)
                                }
                            }
                            Else
                            {
                                Store (Ones, PIO1)
                            }

                            Store (GDMA (And (SYNC, 0x02), And (ICR3, 0x02), 
                                And (ICR0, 0x02), SDT1, And (ICR1, 0x02)), DMA1)
                            If (LEqual (DMA1, Ones))
                            {
                                Store (PIO1, DMA1)
                            }

                            Store (GETF (And (SYNC, One), And (SYNC, 0x02), 
                                PRIT), FLAG)
                            Return (PBUF)
                        }
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            CreateDWordField (Arg0, Zero, PIO0)
                            CreateDWordField (Arg0, 0x04, DMA0)
                            CreateDWordField (Arg0, 0x08, PIO1)
                            CreateDWordField (Arg0, 0x0C, DMA1)
                            CreateDWordField (Arg0, 0x10, FLAG)
                            If (LEqual (SizeOf (Arg1), 0x0200))
                            {
                                And (PRIT, 0x40F0, PRIT)
                                And (SYNC, 0x0E, SYNC)
                                Store (Zero, SDT0)
                                And (ICR0, 0x0E, ICR0)
                                And (ICR1, 0x0E, ICR1)
                                And (ICR3, 0x0E, ICR3)
                                And (ICR5, 0x0E, ICR5)
                                CreateWordField (Arg1, 0x62, W490)
                                CreateWordField (Arg1, 0x6A, W530)
                                CreateWordField (Arg1, 0x7E, W630)
                                CreateWordField (Arg1, 0x80, W640)
                                CreateWordField (Arg1, 0xB0, W880)
                                CreateWordField (Arg1, 0xBA, W930)
                                Or (PRIT, 0x8004, PRIT)
                                If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                                {
                                    Or (PRIT, 0x02, PRIT)
                                }

                                Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                                If (And (FLAG, One))
                                {
                                    Or (SYNC, One, SYNC)
                                    Store (SDMA (DMA0), SDT0)
                                    If (LLess (DMA0, 0x1E))
                                    {
                                        Or (ICR3, One, ICR3)
                                    }

                                    If (LLess (DMA0, 0x3C))
                                    {
                                        Or (ICR0, One, ICR0)
                                    }

                                    Or (ICR1, One, ICR1)
                                }
                            }

                            If (LEqual (SizeOf (Arg2), 0x0200))
                            {
                                And (PRIT, 0x3F0F, PRIT)
                                Store (Zero, PSIT)
                                And (SYNC, 0x0D, SYNC)
                                Store (Zero, SDT1)
                                And (ICR0, 0x0D, ICR0)
                                And (ICR1, 0x0D, ICR1)
                                And (ICR3, 0x0D, ICR3)
                                And (ICR5, 0x0D, ICR5)
                                CreateWordField (Arg2, 0x62, W491)
                                CreateWordField (Arg2, 0x6A, W531)
                                CreateWordField (Arg2, 0x7E, W631)
                                CreateWordField (Arg2, 0x80, W641)
                                CreateWordField (Arg2, 0xB0, W881)
                                CreateWordField (Arg2, 0xBA, W931)
                                Or (PRIT, 0x8040, PRIT)
                                If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                                {
                                    Or (PRIT, 0x20, PRIT)
                                }

                                If (And (FLAG, 0x10))
                                {
                                    Or (PRIT, 0x4000, PRIT)
                                    If (LGreater (PIO1, 0xF0))
                                    {
                                        Or (PRIT, 0x80, PRIT)
                                    }
                                    Else
                                    {
                                        Or (PRIT, 0x10, PRIT)
                                        Store (SETT (PIO1, W531, W641), PSIT)
                                    }
                                }

                                If (And (FLAG, 0x04))
                                {
                                    Or (SYNC, 0x02, SYNC)
                                    Store (SDMA (DMA1), SDT1)
                                    If (LLess (DMA1, 0x1E))
                                    {
                                        Or (ICR3, 0x02, ICR3)
                                    }

                                    If (LLess (DMA1, 0x3C))
                                    {
                                        Or (ICR0, 0x02, ICR0)
                                    }

                                    Or (ICR1, 0x02, ICR1)
                                }
                            }
                        }
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (PIB0, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                })
                                CreateByteField (PIB0, One, PMD0)
                                CreateByteField (PIB0, 0x08, DMD0)
                                If (And (PRIT, 0x02))
                                {
                                    If (LEqual (And (PRIT, 0x09), 0x08))
                                    {
                                        Store (0x08, PMD0)
                                    }
                                    Else
                                    {
                                        Store (0x0A, PMD0)
                                        ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
                                        ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
                                        Add (Local0, Local1, Local2)
                                        If (LEqual (0x03, Local2))
                                        {
                                            Store (0x0B, PMD0)
                                        }

                                        If (LEqual (0x05, Local2))
                                        {
                                            Store (0x0C, PMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD0)
                                }

                                If (And (SYNC, One))
                                {
                                    Store (Or (SDT0, 0x40), DMD0)
                                    If (And (ICR1, One))
                                    {
                                        If (And (ICR0, One))
                                        {
                                            Add (DMD0, 0x02, DMD0)
                                        }

                                        If (And (ICR3, One))
                                        {
                                            Store (0x45, DMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                                }

                                Return (PIB0)
                            }
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, One)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (PIB1, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                })
                                CreateByteField (PIB1, One, PMD1)
                                CreateByteField (PIB1, 0x08, DMD1)
                                If (And (PRIT, 0x20))
                                {
                                    If (LEqual (And (PRIT, 0x90), 0x80))
                                    {
                                        Store (0x08, PMD1)
                                    }
                                    Else
                                    {
                                        Add (And (PSIT, 0x03), ShiftRight (And (PSIT, 0x0C), 
                                            0x02), Local0)
                                        If (LEqual (0x05, Local0))
                                        {
                                            Store (0x0C, PMD1)
                                        }
                                        Else
                                        {
                                            If (LEqual (0x03, Local0))
                                            {
                                                Store (0x0B, PMD1)
                                            }
                                            Else
                                            {
                                                Store (0x0A, PMD1)
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD1)
                                }

                                If (And (SYNC, 0x02))
                                {
                                    Store (Or (SDT1, 0x40), DMD1)
                                    If (And (ICR1, 0x02))
                                    {
                                        If (And (ICR0, 0x02))
                                        {
                                            Add (DMD1, 0x02, DMD1)
                                        }

                                        If (And (ICR3, 0x02))
                                        {
                                            Store (0x45, DMD1)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                                }

                                Return (PIB1)
                            }
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, One)
                    Method (_GTM, 0, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            Name (SBUF, Buffer (0x14)
                            {
                                /* 0000 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x00, 0x00, 0x00
                            })
                            CreateDWordField (SBUF, Zero, PIO0)
                            CreateDWordField (SBUF, 0x04, DMA0)
                            CreateDWordField (SBUF, 0x08, PIO1)
                            CreateDWordField (SBUF, 0x0C, DMA1)
                            CreateDWordField (SBUF, 0x10, FLAG)
                            Store (GETP (SECT), PIO0)
                            Store (GDMA (And (SYNC, 0x04), And (ICR3, 0x04), 
                                And (ICR0, 0x04), SDT2, And (ICR1, 0x04)), DMA0)
                            If (LEqual (DMA0, Ones))
                            {
                                Store (PIO0, DMA0)
                            }

                            If (And (SECT, 0x4000))
                            {
                                If (LEqual (And (SECT, 0x90), 0x80))
                                {
                                    Store (0x0384, PIO1)
                                }
                                Else
                                {
                                    Store (GETT (SSIT), PIO1)
                                }
                            }
                            Else
                            {
                                Store (Ones, PIO1)
                            }

                            Store (GDMA (And (SYNC, 0x08), And (ICR3, 0x08), 
                                And (ICR0, 0x08), SDT3, And (ICR1, 0x08)), DMA1)
                            If (LEqual (DMA1, Ones))
                            {
                                Store (PIO1, DMA1)
                            }

                            Store (GETF (And (SYNC, 0x04), And (SYNC, 0x08), 
                                SECT), FLAG)
                            Return (SBUF)
                        }
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            CreateDWordField (Arg0, Zero, PIO0)
                            CreateDWordField (Arg0, 0x04, DMA0)
                            CreateDWordField (Arg0, 0x08, PIO1)
                            CreateDWordField (Arg0, 0x0C, DMA1)
                            CreateDWordField (Arg0, 0x10, FLAG)
                            If (LEqual (SizeOf (Arg1), 0x0200))
                            {
                                And (SECT, 0x40F0, SECT)
                                And (SYNC, 0x0B, SYNC)
                                Store (Zero, SDT2)
                                And (ICR0, 0x0B, ICR0)
                                And (ICR1, 0x0B, ICR1)
                                And (ICR3, 0x0B, ICR3)
                                And (ICR5, 0x0B, ICR5)
                                CreateWordField (Arg1, 0x62, W490)
                                CreateWordField (Arg1, 0x6A, W530)
                                CreateWordField (Arg1, 0x7E, W630)
                                CreateWordField (Arg1, 0x80, W640)
                                CreateWordField (Arg1, 0xB0, W880)
                                CreateWordField (Arg1, 0xBA, W930)
                                Or (SECT, 0x8004, SECT)
                                If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                                {
                                    Or (SECT, 0x02, SECT)
                                }

                                Or (SECT, SETP (PIO0, W530, W640), SECT)
                                If (And (FLAG, One))
                                {
                                    Or (SYNC, 0x04, SYNC)
                                    Store (SDMA (DMA0), SDT2)
                                    If (LLess (DMA0, 0x1E))
                                    {
                                        Or (ICR3, 0x04, ICR3)
                                    }

                                    If (LLess (DMA0, 0x3C))
                                    {
                                        Or (ICR0, 0x04, ICR0)
                                    }

                                    Or (ICR1, 0x04, ICR1)
                                }
                            }

                            If (LEqual (SizeOf (Arg2), 0x0200))
                            {
                                And (SECT, 0x3F0F, SECT)
                                Store (Zero, SSIT)
                                And (SYNC, 0x07, SYNC)
                                Store (Zero, SDT3)
                                And (ICR0, 0x07, ICR0)
                                And (ICR1, 0x07, ICR1)
                                And (ICR3, 0x07, ICR3)
                                And (ICR5, 0x07, ICR5)
                                CreateWordField (Arg2, 0x62, W491)
                                CreateWordField (Arg2, 0x6A, W531)
                                CreateWordField (Arg2, 0x7E, W631)
                                CreateWordField (Arg2, 0x80, W641)
                                CreateWordField (Arg2, 0xB0, W881)
                                CreateWordField (Arg2, 0xBA, W931)
                                Or (SECT, 0x8040, SECT)
                                If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                                {
                                    Or (SECT, 0x20, SECT)
                                }

                                If (And (FLAG, 0x10))
                                {
                                    Or (SECT, 0x4000, SECT)
                                    If (LGreater (PIO1, 0xF0))
                                    {
                                        Or (SECT, 0x80, SECT)
                                    }
                                    Else
                                    {
                                        Or (SECT, 0x10, SECT)
                                        Store (SETT (PIO1, W531, W641), SSIT)
                                    }
                                }

                                If (And (FLAG, 0x04))
                                {
                                    Or (SYNC, 0x08, SYNC)
                                    Store (SDMA (DMA1), SDT3)
                                    If (LLess (DMA1, 0x1E))
                                    {
                                        Or (ICR3, 0x08, ICR3)
                                    }

                                    If (LLess (DMA1, 0x3C))
                                    {
                                        Or (ICR0, 0x08, ICR0)
                                    }

                                    Or (ICR1, 0x08, ICR1)
                                }
                            }
                        }
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (SIB0, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                })
                                CreateByteField (SIB0, One, PMD0)
                                CreateByteField (SIB0, 0x08, DMD0)
                                If (And (SECT, 0x02))
                                {
                                    If (LEqual (And (SECT, 0x09), 0x08))
                                    {
                                        Store (0x08, PMD0)
                                    }
                                    Else
                                    {
                                        Store (0x0A, PMD0)
                                        ShiftRight (And (SECT, 0x0300), 0x08, Local0)
                                        ShiftRight (And (SECT, 0x3000), 0x0C, Local1)
                                        Add (Local0, Local1, Local2)
                                        If (LEqual (0x03, Local2))
                                        {
                                            Store (0x0B, PMD0)
                                        }

                                        If (LEqual (0x05, Local2))
                                        {
                                            Store (0x0C, PMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD0)
                                }

                                If (And (SYNC, 0x04))
                                {
                                    Store (Or (SDT2, 0x40), DMD0)
                                    If (And (ICR1, 0x04))
                                    {
                                        If (And (ICR0, 0x04))
                                        {
                                            Add (DMD0, 0x02, DMD0)
                                        }

                                        If (And (ICR3, 0x04))
                                        {
                                            Store (0x45, DMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                                }

                                Return (SIB0)
                            }
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, One)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (SIB1, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                })
                                CreateByteField (SIB1, One, PMD1)
                                CreateByteField (SIB1, 0x08, DMD1)
                                If (And (SECT, 0x20))
                                {
                                    If (LEqual (And (SECT, 0x90), 0x80))
                                    {
                                        Store (0x08, PMD1)
                                    }
                                    Else
                                    {
                                        Add (And (SSIT, 0x03), ShiftRight (And (SSIT, 0x0C), 
                                            0x02), Local0)
                                        If (LEqual (0x05, Local0))
                                        {
                                            Store (0x0C, PMD1)
                                        }
                                        Else
                                        {
                                            If (LEqual (0x03, Local0))
                                            {
                                                Store (0x0B, PMD1)
                                            }
                                            Else
                                            {
                                                Store (0x0A, PMD1)
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD1)
                                }

                                If (And (SYNC, 0x08))
                                {
                                    Store (Or (SDT3, 0x40), DMD1)
                                    If (And (ICR1, 0x08))
                                    {
                                        If (And (ICR0, 0x08))
                                        {
                                            Add (DMD1, 0x02, DMD1)
                                        }

                                        If (And (ICR3, 0x08))
                                        {
                                            Store (0x45, DMD1)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                                }

                                Return (SIB1)
                            }
                        }
                    }
                }

                Device (PRT0)
                {
                    Name (_ADR, 0xFFFF)
                    Method (_SDD, 1, NotSerialized)
                    {
                        Name (GBU0, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00
                        })
                        If (LEqual (SizeOf (Arg0), 0x0200))
                        {
                            Store (0xF5, Index (GBU0, 0x06))
                        }

                        Store (GBU0, GTF0)
                    }

                    Method (_GTF, 0, NotSerialized)
                    {
                        Return (GTF0)
                    }
                }

                Device (PRT1)
                {
                    Name (_ADR, 0x0001FFFF)
                    Method (_SDD, 1, NotSerialized)
                    {
                        Name (GBU1, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00
                        })
                        If (LEqual (SizeOf (Arg0), 0x0200))
                        {
                            If (ECON)
                            {
                                Store (^^^LPC.H8EC.SOPP, Local0)
                            }
                            Else
                            {
                                And (RECS (0x65), One, Local0)
                            }

                            If (LNot (Local0))
                            {
                                Store (0x20, P80H)
                                Store (0xF5, Index (GBU1, 0x06))
                            }
                        }

                        Store (GBU1, GTF1)
                    }

                    Method (_GTF, 0, NotSerialized)
                    {
                        Return (GTF1)
                    }
                }

                Device (PRT4)
                {
                    Name (_ADR, 0x0004FFFF)
                    Name (GTF4, Buffer (0x07) {})
                    Method (_SDD, 1, NotSerialized)
                    {
                        Name (GBU4, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00
                        })
                        If (LEqual (SizeOf (Arg0), 0x0200))
                        {
                            Store (0xF5, Index (GBU4, 0x06))
                        }

                        Store (GBU4, GTF4)
                    }

                    Method (_GTF, 0, NotSerialized)
                    {
                        Return (GTF4)
                    }
                }

                Device (PRT5)
                {
                    Name (_ADR, 0x0005FFFF)
                    Name (GTF5, Buffer (0x07) {})
                    Method (_SDD, 1, NotSerialized)
                    {
                        Name (GBU5, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00
                        })
                        If (LEqual (SizeOf (Arg0), 0x0200))
                        {
                            Store (0xF5, Index (GBU5, 0x06))
                        }

                        Store (GBU5, GTF5)
                    }

                    Method (_GTF, 0, NotSerialized)
                    {
                        Return (GTF5)
                    }
                }
            }

            Device (SAT1)
            {
                Name (_ADR, 0x001F0005)
                OperationRegion (SACS, PCI_Config, Zero, 0x0100)
                Field (SACS, DWordAcc, NoLock, Preserve)
                {
                    VID,    16, 
                    DID,    16, 
                            Offset (0x40), 
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                            Offset (0x48), 
                    SYNC,   4, 
                            Offset (0x4A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                            Offset (0x4B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                            Offset (0x54), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4, 
                            Offset (0x90), 
                    MAPV,   2
                }

                Device (PRID)
                {
                    Name (_ADR, Zero)
                    Method (_GTM, 0, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            Name (PBUF, Buffer (0x14)
                            {
                                /* 0000 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x00, 0x00, 0x00
                            })
                            CreateDWordField (PBUF, Zero, PIO0)
                            CreateDWordField (PBUF, 0x04, DMA0)
                            CreateDWordField (PBUF, 0x08, PIO1)
                            CreateDWordField (PBUF, 0x0C, DMA1)
                            CreateDWordField (PBUF, 0x10, FLAG)
                            Store (GETP (PRIT), PIO0)
                            Store (GDMA (And (SYNC, One), And (ICR3, One), 
                                And (ICR0, One), SDT0, And (ICR1, One)), DMA0)
                            If (LEqual (DMA0, Ones))
                            {
                                Store (PIO0, DMA0)
                            }

                            If (And (PRIT, 0x4000))
                            {
                                If (LEqual (And (PRIT, 0x90), 0x80))
                                {
                                    Store (0x0384, PIO1)
                                }
                                Else
                                {
                                    Store (GETT (PSIT), PIO1)
                                }
                            }
                            Else
                            {
                                Store (Ones, PIO1)
                            }

                            Store (GDMA (And (SYNC, 0x02), And (ICR3, 0x02), 
                                And (ICR0, 0x02), SDT1, And (ICR1, 0x02)), DMA1)
                            If (LEqual (DMA1, Ones))
                            {
                                Store (PIO1, DMA1)
                            }

                            Store (GETF (And (SYNC, One), And (SYNC, 0x02), 
                                PRIT), FLAG)
                            Return (PBUF)
                        }
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            CreateDWordField (Arg0, Zero, PIO0)
                            CreateDWordField (Arg0, 0x04, DMA0)
                            CreateDWordField (Arg0, 0x08, PIO1)
                            CreateDWordField (Arg0, 0x0C, DMA1)
                            CreateDWordField (Arg0, 0x10, FLAG)
                            If (LEqual (SizeOf (Arg1), 0x0200))
                            {
                                And (PRIT, 0x40F0, PRIT)
                                And (SYNC, 0x0E, SYNC)
                                Store (Zero, SDT0)
                                And (ICR0, 0x0E, ICR0)
                                And (ICR1, 0x0E, ICR1)
                                And (ICR3, 0x0E, ICR3)
                                And (ICR5, 0x0E, ICR5)
                                CreateWordField (Arg1, 0x62, W490)
                                CreateWordField (Arg1, 0x6A, W530)
                                CreateWordField (Arg1, 0x7E, W630)
                                CreateWordField (Arg1, 0x80, W640)
                                CreateWordField (Arg1, 0xB0, W880)
                                CreateWordField (Arg1, 0xBA, W930)
                                Or (PRIT, 0x8004, PRIT)
                                If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                                {
                                    Or (PRIT, 0x02, PRIT)
                                }

                                Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                                If (And (FLAG, One))
                                {
                                    Or (SYNC, One, SYNC)
                                    Store (SDMA (DMA0), SDT0)
                                    If (LLess (DMA0, 0x1E))
                                    {
                                        Or (ICR3, One, ICR3)
                                    }

                                    If (LLess (DMA0, 0x3C))
                                    {
                                        Or (ICR0, One, ICR0)
                                    }

                                    Or (ICR1, One, ICR1)
                                }
                            }

                            If (LEqual (SizeOf (Arg2), 0x0200))
                            {
                                And (PRIT, 0x3F0F, PRIT)
                                Store (Zero, PSIT)
                                And (SYNC, 0x0D, SYNC)
                                Store (Zero, SDT1)
                                And (ICR0, 0x0D, ICR0)
                                And (ICR1, 0x0D, ICR1)
                                And (ICR3, 0x0D, ICR3)
                                And (ICR5, 0x0D, ICR5)
                                CreateWordField (Arg2, 0x62, W491)
                                CreateWordField (Arg2, 0x6A, W531)
                                CreateWordField (Arg2, 0x7E, W631)
                                CreateWordField (Arg2, 0x80, W641)
                                CreateWordField (Arg2, 0xB0, W881)
                                CreateWordField (Arg2, 0xBA, W931)
                                Or (PRIT, 0x8040, PRIT)
                                If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                                {
                                    Or (PRIT, 0x20, PRIT)
                                }

                                If (And (FLAG, 0x10))
                                {
                                    Or (PRIT, 0x4000, PRIT)
                                    If (LGreater (PIO1, 0xF0))
                                    {
                                        Or (PRIT, 0x80, PRIT)
                                    }
                                    Else
                                    {
                                        Or (PRIT, 0x10, PRIT)
                                        Store (SETT (PIO1, W531, W641), PSIT)
                                    }
                                }

                                If (And (FLAG, 0x04))
                                {
                                    Or (SYNC, 0x02, SYNC)
                                    Store (SDMA (DMA1), SDT1)
                                    If (LLess (DMA1, 0x1E))
                                    {
                                        Or (ICR3, 0x02, ICR3)
                                    }

                                    If (LLess (DMA1, 0x3C))
                                    {
                                        Or (ICR0, 0x02, ICR0)
                                    }

                                    Or (ICR1, 0x02, ICR1)
                                }
                            }
                        }
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (PIB0, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                })
                                CreateByteField (PIB0, One, PMD0)
                                CreateByteField (PIB0, 0x08, DMD0)
                                If (And (PRIT, 0x02))
                                {
                                    If (LEqual (And (PRIT, 0x09), 0x08))
                                    {
                                        Store (0x08, PMD0)
                                    }
                                    Else
                                    {
                                        Store (0x0A, PMD0)
                                        ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
                                        ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
                                        Add (Local0, Local1, Local2)
                                        If (LEqual (0x03, Local2))
                                        {
                                            Store (0x0B, PMD0)
                                        }

                                        If (LEqual (0x05, Local2))
                                        {
                                            Store (0x0C, PMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD0)
                                }

                                If (And (SYNC, One))
                                {
                                    Store (Or (SDT0, 0x40), DMD0)
                                    If (And (ICR1, One))
                                    {
                                        If (And (ICR0, One))
                                        {
                                            Add (DMD0, 0x02, DMD0)
                                        }

                                        If (And (ICR3, One))
                                        {
                                            Store (0x45, DMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                                }

                                Return (PIB0)
                            }
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, One)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (PIB1, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                })
                                CreateByteField (PIB1, One, PMD1)
                                CreateByteField (PIB1, 0x08, DMD1)
                                If (And (PRIT, 0x20))
                                {
                                    If (LEqual (And (PRIT, 0x90), 0x80))
                                    {
                                        Store (0x08, PMD1)
                                    }
                                    Else
                                    {
                                        Add (And (PSIT, 0x03), ShiftRight (And (PSIT, 0x0C), 
                                            0x02), Local0)
                                        If (LEqual (0x05, Local0))
                                        {
                                            Store (0x0C, PMD1)
                                        }
                                        Else
                                        {
                                            If (LEqual (0x03, Local0))
                                            {
                                                Store (0x0B, PMD1)
                                            }
                                            Else
                                            {
                                                Store (0x0A, PMD1)
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD1)
                                }

                                If (And (SYNC, 0x02))
                                {
                                    Store (Or (SDT1, 0x40), DMD1)
                                    If (And (ICR1, 0x02))
                                    {
                                        If (And (ICR0, 0x02))
                                        {
                                            Add (DMD1, 0x02, DMD1)
                                        }

                                        If (And (ICR3, 0x02))
                                        {
                                            Store (0x45, DMD1)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                                }

                                Return (PIB1)
                            }
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, One)
                    Method (_GTM, 0, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            Name (SBUF, Buffer (0x14)
                            {
                                /* 0000 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x00, 0x00, 0x00
                            })
                            CreateDWordField (SBUF, Zero, PIO0)
                            CreateDWordField (SBUF, 0x04, DMA0)
                            CreateDWordField (SBUF, 0x08, PIO1)
                            CreateDWordField (SBUF, 0x0C, DMA1)
                            CreateDWordField (SBUF, 0x10, FLAG)
                            Store (GETP (SECT), PIO0)
                            Store (GDMA (And (SYNC, 0x04), And (ICR3, 0x04), 
                                And (ICR0, 0x04), SDT2, And (ICR1, 0x04)), DMA0)
                            If (LEqual (DMA0, Ones))
                            {
                                Store (PIO0, DMA0)
                            }

                            If (And (SECT, 0x4000))
                            {
                                If (LEqual (And (SECT, 0x90), 0x80))
                                {
                                    Store (0x0384, PIO1)
                                }
                                Else
                                {
                                    Store (GETT (SSIT), PIO1)
                                }
                            }
                            Else
                            {
                                Store (Ones, PIO1)
                            }

                            Store (GDMA (And (SYNC, 0x08), And (ICR3, 0x08), 
                                And (ICR0, 0x08), SDT3, And (ICR1, 0x08)), DMA1)
                            If (LEqual (DMA1, Ones))
                            {
                                Store (PIO1, DMA1)
                            }

                            Store (GETF (And (SYNC, 0x04), And (SYNC, 0x08), 
                                SECT), FLAG)
                            Return (SBUF)
                        }
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        If (LEqual (SCFG, Zero))
                        {
                            CreateDWordField (Arg0, Zero, PIO0)
                            CreateDWordField (Arg0, 0x04, DMA0)
                            CreateDWordField (Arg0, 0x08, PIO1)
                            CreateDWordField (Arg0, 0x0C, DMA1)
                            CreateDWordField (Arg0, 0x10, FLAG)
                            If (LEqual (SizeOf (Arg1), 0x0200))
                            {
                                And (SECT, 0x40F0, SECT)
                                And (SYNC, 0x0B, SYNC)
                                Store (Zero, SDT2)
                                And (ICR0, 0x0B, ICR0)
                                And (ICR1, 0x0B, ICR1)
                                And (ICR3, 0x0B, ICR3)
                                And (ICR5, 0x0B, ICR5)
                                CreateWordField (Arg1, 0x62, W490)
                                CreateWordField (Arg1, 0x6A, W530)
                                CreateWordField (Arg1, 0x7E, W630)
                                CreateWordField (Arg1, 0x80, W640)
                                CreateWordField (Arg1, 0xB0, W880)
                                CreateWordField (Arg1, 0xBA, W930)
                                Or (SECT, 0x8004, SECT)
                                If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                                {
                                    Or (SECT, 0x02, SECT)
                                }

                                Or (SECT, SETP (PIO0, W530, W640), SECT)
                                If (And (FLAG, One))
                                {
                                    Or (SYNC, 0x04, SYNC)
                                    Store (SDMA (DMA0), SDT2)
                                    If (LLess (DMA0, 0x1E))
                                    {
                                        Or (ICR3, 0x04, ICR3)
                                    }

                                    If (LLess (DMA0, 0x3C))
                                    {
                                        Or (ICR0, 0x04, ICR0)
                                    }

                                    Or (ICR1, 0x04, ICR1)
                                }
                            }

                            If (LEqual (SizeOf (Arg2), 0x0200))
                            {
                                And (SECT, 0x3F0F, SECT)
                                Store (Zero, SSIT)
                                And (SYNC, 0x07, SYNC)
                                Store (Zero, SDT3)
                                And (ICR0, 0x07, ICR0)
                                And (ICR1, 0x07, ICR1)
                                And (ICR3, 0x07, ICR3)
                                And (ICR5, 0x07, ICR5)
                                CreateWordField (Arg2, 0x62, W491)
                                CreateWordField (Arg2, 0x6A, W531)
                                CreateWordField (Arg2, 0x7E, W631)
                                CreateWordField (Arg2, 0x80, W641)
                                CreateWordField (Arg2, 0xB0, W881)
                                CreateWordField (Arg2, 0xBA, W931)
                                Or (SECT, 0x8040, SECT)
                                If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                                {
                                    Or (SECT, 0x20, SECT)
                                }

                                If (And (FLAG, 0x10))
                                {
                                    Or (SECT, 0x4000, SECT)
                                    If (LGreater (PIO1, 0xF0))
                                    {
                                        Or (SECT, 0x80, SECT)
                                    }
                                    Else
                                    {
                                        Or (SECT, 0x10, SECT)
                                        Store (SETT (PIO1, W531, W641), SSIT)
                                    }
                                }

                                If (And (FLAG, 0x04))
                                {
                                    Or (SYNC, 0x08, SYNC)
                                    Store (SDMA (DMA1), SDT3)
                                    If (LLess (DMA1, 0x1E))
                                    {
                                        Or (ICR3, 0x08, ICR3)
                                    }

                                    If (LLess (DMA1, 0x3C))
                                    {
                                        Or (ICR0, 0x08, ICR0)
                                    }

                                    Or (ICR1, 0x08, ICR1)
                                }
                            }
                        }
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, Zero)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (SIB0, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                })
                                CreateByteField (SIB0, One, PMD0)
                                CreateByteField (SIB0, 0x08, DMD0)
                                If (And (SECT, 0x02))
                                {
                                    If (LEqual (And (SECT, 0x09), 0x08))
                                    {
                                        Store (0x08, PMD0)
                                    }
                                    Else
                                    {
                                        Store (0x0A, PMD0)
                                        ShiftRight (And (SECT, 0x0300), 0x08, Local0)
                                        ShiftRight (And (SECT, 0x3000), 0x0C, Local1)
                                        Add (Local0, Local1, Local2)
                                        If (LEqual (0x03, Local2))
                                        {
                                            Store (0x0B, PMD0)
                                        }

                                        If (LEqual (0x05, Local2))
                                        {
                                            Store (0x0C, PMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD0)
                                }

                                If (And (SYNC, 0x04))
                                {
                                    Store (Or (SDT2, 0x40), DMD0)
                                    If (And (ICR1, 0x04))
                                    {
                                        If (And (ICR0, 0x04))
                                        {
                                            Add (DMD0, 0x02, DMD0)
                                        }

                                        If (And (ICR3, 0x04))
                                        {
                                            Store (0x45, DMD0)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                                }

                                Return (SIB0)
                            }
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, One)
                        Method (_GTF, 0, NotSerialized)
                        {
                            If (LEqual (SCFG, Zero))
                            {
                                Name (SIB1, Buffer (0x0E)
                                {
                                    /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                    /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                                })
                                CreateByteField (SIB1, One, PMD1)
                                CreateByteField (SIB1, 0x08, DMD1)
                                If (And (SECT, 0x20))
                                {
                                    If (LEqual (And (SECT, 0x90), 0x80))
                                    {
                                        Store (0x08, PMD1)
                                    }
                                    Else
                                    {
                                        Add (And (SSIT, 0x03), ShiftRight (And (SSIT, 0x0C), 
                                            0x02), Local0)
                                        If (LEqual (0x05, Local0))
                                        {
                                            Store (0x0C, PMD1)
                                        }
                                        Else
                                        {
                                            If (LEqual (0x03, Local0))
                                            {
                                                Store (0x0B, PMD1)
                                            }
                                            Else
                                            {
                                                Store (0x0A, PMD1)
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (One, PMD1)
                                }

                                If (And (SYNC, 0x08))
                                {
                                    Store (Or (SDT3, 0x40), DMD1)
                                    If (And (ICR1, 0x08))
                                    {
                                        If (And (ICR0, 0x08))
                                        {
                                            Add (DMD1, 0x02, DMD1)
                                        }

                                        If (And (ICR3, 0x08))
                                        {
                                            Store (0x45, DMD1)
                                        }
                                    }
                                }
                                Else
                                {
                                    Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                                }

                                Return (SIB1)
                            }
                        }
                    }
                }
            }

            Device (SBUS)
            {
                Name (_ADR, 0x001F0003)
                OperationRegion (SMBP, PCI_Config, 0x40, 0xC0)
                Field (SMBP, DWordAcc, NoLock, Preserve)
                {
                        ,   2, 
                    I2CE,   1
                }

                OperationRegion (SMBI, SystemIO, SMIO, 0x10)
                Field (SMBI, ByteAcc, NoLock, Preserve)
                {
                    HSTS,   8, 
                            Offset (0x02), 
                    HCON,   8, 
                    HCOM,   8, 
                    TXSA,   8, 
                    DAT0,   8, 
                    DAT1,   8, 
                    HBDR,   8, 
                    PECR,   8, 
                    RXSA,   8, 
                    SDAT,   16
                }

                Method (SSXB, 2, Serialized)
                {
                    If (STRT ())
                    {
                        Return (Zero)
                    }

                    Store (0xBF, HSTS)
                    Store (Arg0, TXSA)
                    Store (Arg1, HCOM)
                    Store (0x48, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (One)
                    }

                    Return (Zero)
                }

                Method (SRXB, 1, Serialized)
                {
                    If (STRT ())
                    {
                        Return (0xFFFF)
                    }

                    Store (0xBF, HSTS)
                    Store (Or (Arg0, One), TXSA)
                    Store (0x44, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (DAT0)
                    }

                    Return (0xFFFF)
                }

                Method (SWRB, 3, Serialized)
                {
                    If (STRT ())
                    {
                        Return (Zero)
                    }

                    Store (0xBF, HSTS)
                    Store (Arg0, TXSA)
                    Store (Arg1, HCOM)
                    Store (Arg2, DAT0)
                    Store (0x48, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (One)
                    }

                    Return (Zero)
                }

                Method (SRDB, 2, Serialized)
                {
                    If (STRT ())
                    {
                        Return (0xFFFF)
                    }

                    Store (0xBF, HSTS)
                    Store (Or (Arg0, One), TXSA)
                    Store (Arg1, HCOM)
                    Store (0x48, HCON)
                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (DAT0)
                    }

                    Return (0xFFFF)
                }

                Method (SBLW, 3, Serialized)
                {
                    If (STRT ())
                    {
                        Return (Zero)
                    }

                    Store (0xBF, HSTS)
                    Store (Arg0, TXSA)
                    Store (Arg1, HCOM)
                    Store (SizeOf (Arg2), DAT0)
                    Store (Zero, Local1)
                    Store (DerefOf (Index (Arg2, Zero)), HBDR)
                    Store (0x54, HCON)
                    While (LGreater (SizeOf (Arg2), Local1))
                    {
                        Store (0x0A, Local0)
                        While (LAnd (LNot (And (HSTS, 0x80)), Local0))
                        {
                            Sleep (0x64)
                            Decrement (Local0)
                        }

                        If (LNot (Local0))
                        {
                            KILL ()
                            Return (Zero)
                        }

                        Store (0x80, HSTS)
                        Increment (Local1)
                        If (LGreater (SizeOf (Arg2), Local1))
                        {
                            Store (DerefOf (Index (Arg2, Local1)), HBDR)
                        }
                    }

                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (One)
                    }

                    Return (Zero)
                }

                Method (SBLR, 2, Serialized)
                {
                    Name (TBUF, Buffer (0x0100) {})
                    If (STRT ())
                    {
                        Return (Zero)
                    }

                    Store (0xBF, HSTS)
                    Store (Or (Arg0, One), TXSA)
                    Store (Arg1, HCOM)
                    Store (0x54, HCON)
                    Store (0x0A, Local0)
                    While (LAnd (LNot (And (HSTS, 0x80)), Local0))
                    {
                        Sleep (0x64)
                        Decrement (Local0)
                    }

                    If (LNot (Local0))
                    {
                        KILL ()
                        Return (Zero)
                    }

                    Store (DAT0, Index (TBUF, Zero))
                    Store (0x80, HSTS)
                    Store (One, Local1)
                    While (LLess (Local1, DerefOf (Index (TBUF, Zero))))
                    {
                        Store (0x0A, Local0)
                        While (LAnd (LNot (And (HSTS, 0x80)), Local0))
                        {
                            Sleep (0x64)
                            Decrement (Local0)
                        }

                        If (LNot (Local0))
                        {
                            KILL ()
                            Return (Zero)
                        }

                        Store (HBDR, Index (TBUF, Local1))
                        Store (0x80, HSTS)
                        Increment (Local1)
                    }

                    If (COMP ())
                    {
                        Or (HSTS, 0xFF, HSTS)
                        Return (TBUF)
                    }

                    Return (Zero)
                }

                Method (STRT, 0, Serialized)
                {
                    Store (0x64, Local0)
                    While (Local0)
                    {
                        If (And (HSTS, 0x40))
                        {
                            Decrement (Local0)
                            Sleep (0x0A)
                            If (LEqual (Local0, Zero))
                            {
                                Return (One)
                            }
                        }
                        Else
                        {
                            Store (Zero, Local0)
                        }
                    }

                    Store (0x64, Local0)
                    While (Local0)
                    {
                        If (And (HSTS, One))
                        {
                            Decrement (Local0)
                            Sleep (0x0A)
                            If (LEqual (Local0, Zero))
                            {
                                KILL ()
                            }
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Return (One)
                }

                Method (COMP, 0, Serialized)
                {
                    Store (0x64, Local0)
                    While (Local0)
                    {
                        If (And (HSTS, 0x02))
                        {
                            Return (One)
                        }
                        Else
                        {
                            Decrement (Local0)
                            Sleep (0x0A)
                            If (LEqual (Local0, Zero))
                            {
                                KILL ()
                            }
                        }
                    }

                    Return (Zero)
                }

                Method (KILL, 0, Serialized)
                {
                    Or (HCON, 0x02, HCON)
                    Or (HSTS, 0xFF, HSTS)
                }
            }
        }
    }

    Name (SSPS, Zero)
    Name (HPLG, Zero)
    Name (HPEJ, Zero)
    Name (HPLE, One)
    Name (HGAP, Zero)
    Name (HNCD, Zero)
    Name (HNCA, Zero)
    Name (HPND, Zero)
    Name (POVR, Ones)
    Name (HDAE, Zero)
    Name (HDHE, Zero)
    Name (ADAD, Zero)
    Name (SNGT, Zero)
    Name (HGDD, Zero)
    Name (DDCA, Buffer (0x8000)
    {
        0x00
    })
    Name (DDCB, Buffer (0x8000)
    {
        0x00
    })
    Name (EPAS, Zero)
    Name (RPAS, Zero)
    Name (AVIL, Zero)
    Name (HGER, Zero)
    Scope (_SB.PCI0)
    {
        Device (WMI1)
        {
            Name (_HID, "pnp0c14")
            Name (_UID, "MXM2")
            Name (_WDG, Buffer (0x0190)
            {
                /* 0000 */    0x3C, 0x5C, 0xCB, 0xF6, 0xAE, 0x9C, 0xBD, 0x4E, 
                /* 0008 */    0xB5, 0x77, 0x93, 0x1E, 0xA3, 0x2A, 0x2C, 0xC0, 
                /* 0010 */    0x4D, 0x58, 0x01, 0x02, 0x40, 0x2F, 0x1A, 0x92, 
                /* 0018 */    0xC4, 0x0D, 0x2D, 0x40, 0xAC, 0x18, 0xB4, 0x84, 
                /* 0020 */    0x44, 0xEF, 0x9E, 0xD2, 0xD0, 0x00, 0x01, 0x08, 
                /* 0028 */    0x61, 0xD3, 0x2A, 0xC1, 0xA9, 0x9F, 0x74, 0x4C, 
                /* 0030 */    0x90, 0x1F, 0x95, 0xCB, 0x09, 0x45, 0xCF, 0x3E, 
                /* 0038 */    0xD9, 0x00, 0x01, 0x08, 0x06, 0x80, 0x84, 0x42, 
                /* 0040 */    0x86, 0x88, 0x0E, 0x49, 0x8C, 0x72, 0x2B, 0xDC, 
                /* 0048 */    0xA9, 0x3A, 0x8A, 0x09, 0xDB, 0x00, 0x01, 0x08, 
                /* 0050 */    0x62, 0xDE, 0x6B, 0xE0, 0x75, 0xEE, 0xF4, 0x48, 
                /* 0058 */    0xA5, 0x83, 0xB2, 0x3E, 0x69, 0xAB, 0xF8, 0x91, 
                /* 0060 */    0x80, 0x00, 0x01, 0x08, 0x0F, 0xBD, 0xDE, 0x3A, 
                /* 0068 */    0x5F, 0x0C, 0xED, 0x46, 0xAB, 0x2E, 0x04, 0x96, 
                /* 0070 */    0x2B, 0x4F, 0xDC, 0xBC, 0x81, 0x00, 0x01, 0x08, 
                /* 0078 */    0x64, 0x35, 0x4F, 0xEF, 0xC8, 0x48, 0x94, 0x48, 
                /* 0080 */    0x85, 0xC8, 0xB4, 0x6C, 0x26, 0xB8, 0x42, 0xC0, 
                /* 0088 */    0xDA, 0x00, 0x01, 0x08, 0x54, 0x59, 0x06, 0x85, 
                /* 0090 */    0x14, 0x83, 0x06, 0x4A, 0x8B, 0xB4, 0xCC, 0xAB, 
                /* 0098 */    0x45, 0x03, 0x2E, 0x88, 0xE0, 0x00, 0x01, 0x08, 
                /* 00A0 */    0x3F, 0x5E, 0x8F, 0x02, 0x53, 0x88, 0xA5, 0x45, 
                /* 00A8 */    0x80, 0x47, 0x3D, 0x24, 0x62, 0xF5, 0xA7, 0x34, 
                /* 00B0 */    0xE1, 0x00, 0x01, 0x08, 0xEE, 0x63, 0x9E, 0x30, 
                /* 00B8 */    0xB0, 0xED, 0xB6, 0x4F, 0x91, 0x73, 0xF6, 0x80, 
                /* 00C0 */    0x01, 0x3E, 0x73, 0x11, 0xE2, 0x00, 0x01, 0x08, 
                /* 00C8 */    0xAA, 0x56, 0x52, 0x4A, 0x2C, 0x43, 0xAE, 0x4C, 
                /* 00D0 */    0xB4, 0x9F, 0xDC, 0xA7, 0x07, 0x62, 0x2B, 0xAD, 
                /* 00D8 */    0xE3, 0x00, 0x01, 0x08, 0xCC, 0x1D, 0x96, 0x67, 
                /* 00E0 */    0x83, 0x16, 0x21, 0x44, 0xA1, 0x54, 0x68, 0xED, 
                /* 00E8 */    0xE0, 0xFF, 0x90, 0xD2, 0xE4, 0x00, 0x01, 0x08, 
                /* 00F0 */    0x5A, 0x7C, 0xAD, 0xB9, 0xEF, 0x6F, 0x4C, 0x48, 
                /* 00F8 */    0x80, 0xD3, 0x59, 0xA9, 0x21, 0x73, 0x67, 0x50, 
                /* 0100 */    0xE5, 0x00, 0x01, 0x08, 0xE9, 0xB5, 0xD5, 0xF7, 
                /* 0108 */    0x93, 0xCD, 0x43, 0x46, 0x98, 0x98, 0xA4, 0x5B, 
                /* 0110 */    0x2F, 0x2A, 0xE3, 0xE5, 0xE6, 0x00, 0x01, 0x08, 
                /* 0118 */    0xC2, 0xE2, 0xA8, 0x69, 0x22, 0xF5, 0x3A, 0x46, 
                /* 0120 */    0x89, 0x08, 0xC7, 0xE4, 0x65, 0x39, 0xC8, 0xB1, 
                /* 0128 */    0xE7, 0x00, 0x01, 0x08, 0x1B, 0xA5, 0x46, 0xAF, 
                /* 0130 */    0x23, 0x5C, 0x43, 0x4C, 0x96, 0x09, 0x3C, 0xBB, 
                /* 0138 */    0x95, 0x53, 0xD5, 0xA5, 0xE8, 0x00, 0x01, 0x08, 
                /* 0140 */    0xF2, 0x22, 0xD8, 0xA6, 0x67, 0x3A, 0xC7, 0x4D, 
                /* 0148 */    0xAA, 0xD1, 0x55, 0x50, 0x2A, 0x61, 0x62, 0xE8, 
                /* 0150 */    0xE9, 0x00, 0x01, 0x08, 0x29, 0x0A, 0xD2, 0x99, 
                /* 0158 */    0x50, 0x93, 0x14, 0x41, 0xAA, 0x90, 0x28, 0xF0, 
                /* 0160 */    0xEB, 0x83, 0xD3, 0x08, 0xEA, 0x00, 0x01, 0x08, 
                /* 0168 */    0x66, 0x02, 0x22, 0x53, 0x55, 0x2F, 0x18, 0x4E, 
                /* 0170 */    0x9E, 0x9C, 0xD0, 0x8C, 0x67, 0x43, 0xD6, 0xFD, 
                /* 0178 */    0xEB, 0x00, 0x01, 0x08, 0x21, 0x12, 0x90, 0x05, 
                /* 0180 */    0x66, 0xD5, 0xD1, 0x11, 0xB2, 0xF0, 0x00, 0xA0, 
                /* 0188 */    0xC9, 0x06, 0x29, 0x10, 0x58, 0x4D, 0x01, 0x00
            })
            Method (WMMX, 3, NotSerialized)
            {
                CreateDWordField (Arg2, Zero, FUNC)
                If (LEqual (FUNC, 0x444F445F))
                {
                    If (LEqual (Arg1, 0x10))
                    {
                        Return (^^OVGA._DOD ())
                    }
                    Else
                    {
                        Return (^^PEGP.DGPU._DOD ())
                    }
                }

                If (LGreaterEqual (SizeOf (Arg2), 0x04))
                {
                    CreateDWordField (Arg2, 0x04, ARGS)
                    If (LEqual (FUNC, 0x5343445F))
                    {
                        If (LEqual (ARGS, 0x80010100))
                        {
                            If (LEqual (Arg1, 0x10))
                            {
                                Return (^^OVGA.CRT._DCS ())
                            }
                            Else
                            {
                                Return (^^PEGP.DGPU.CRT._DCS ())
                            }
                        }

                        If (LEqual (ARGS, 0x80090320))
                        {
                            If (LNotEqual (Arg1, 0x10))
                            {
                                Return (^^PEGP.DGPU.DVI._DCS ())
                            }
                        }
                    }
                }

                If (LGreaterEqual (SizeOf (Arg2), 0x08))
                {
                    CreateDWordField (Arg2, 0x08, XARG)
                    If (LEqual (FUNC, 0x534F525F))
                    {
                        If (LNotEqual (Arg1, 0x10))
                        {
                            Return (^^PEGP.DGPU._ROM (ARGS, XARG))
                        }
                    }

                    If (LEqual (FUNC, 0x584D584D))
                    {
                        If (LEqual (ARGS, 0x80010100))
                        {
                            If (LEqual (Arg1, 0x10))
                            {
                                Return (^^OVGA.CRT.MXMX (XARG))
                            }
                            Else
                            {
                                Return (^^PEGP.DGPU.CRT.MXMX (XARG))
                            }
                        }
                    }

                    If (LEqual (FUNC, 0x5344584D))
                    {
                        If (LEqual (ARGS, 0x80010100))
                        {
                            If (LEqual (Arg1, 0x10))
                            {
                                Return (^^OVGA.CRT.MXDS (XARG))
                            }
                            Else
                            {
                                Return (^^PEGP.DGPU.CRT.MXDS (XARG))
                            }
                        }

                        If (LEqual (ARGS, 0x00010110))
                        {
                            If (LEqual (Arg1, 0x10))
                            {
                                Return (^^OVGA.LCD.MXDS (XARG))
                            }
                            Else
                            {
                                Return (^^PEGP.DGPU.LCD.MXDS (XARG))
                            }
                        }
                    }
                }

                If (LGreaterEqual (SizeOf (Arg2), 0x18))
                {
                    If (LEqual (FUNC, 0x4D53445F))
                    {
                        CreateField (Arg2, Zero, 0x80, MUID)
                        CreateDWordField (Arg2, 0x10, REVI)
                        CreateDWordField (Arg2, 0x14, SFNC)
                        CreateDWordField (Arg2, 0x18, PARM)
                        If (LEqual (Arg1, 0x10))
                        {
                            Return (^^OVGA._DSM (MUID, REVI, SFNC, PARM))
                        }
                    }
                }

                Return (Zero)
            }

            Name (WQXM, Buffer (0x029C)
            {
                /* 0000 */    0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
                /* 0008 */    0x8B, 0x02, 0x00, 0x00, 0x0C, 0x08, 0x00, 0x00, 
                /* 0010 */    0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
                /* 0018 */    0x18, 0xD2, 0x83, 0x00, 0x01, 0x06, 0x18, 0x42, 
                /* 0020 */    0x10, 0x05, 0x10, 0x8A, 0xE6, 0x80, 0x42, 0x04, 
                /* 0028 */    0x92, 0x43, 0xA4, 0x30, 0x30, 0x28, 0x0B, 0x20, 
                /* 0030 */    0x86, 0x90, 0x0B, 0x26, 0x26, 0x40, 0x04, 0x84, 
                /* 0038 */    0xBC, 0x0A, 0xB0, 0x29, 0xC0, 0x24, 0x88, 0xFA, 
                /* 0040 */    0xF7, 0x87, 0x28, 0x09, 0x0E, 0x25, 0x04, 0x42, 
                /* 0048 */    0x12, 0x05, 0x98, 0x17, 0xA0, 0x5B, 0x80, 0x61, 
                /* 0050 */    0x01, 0xB6, 0x05, 0x98, 0x16, 0xE0, 0x18, 0x92, 
                /* 0058 */    0x4A, 0x03, 0xA7, 0x04, 0x96, 0x02, 0x21, 0xA1, 
                /* 0060 */    0x02, 0x94, 0x0B, 0xF0, 0x2D, 0x40, 0x3B, 0xA2, 
                /* 0068 */    0x24, 0x0B, 0xB0, 0x0C, 0x23, 0x02, 0x8F, 0x82, 
                /* 0070 */    0xA1, 0x71, 0x68, 0xEC, 0x30, 0x2C, 0x13, 0x4C, 
                /* 0078 */    0x83, 0x38, 0x8C, 0xB2, 0x91, 0x45, 0x60, 0xDC, 
                /* 0080 */    0x4E, 0x05, 0xC8, 0x15, 0x20, 0x4C, 0x80, 0x78, 
                /* 0088 */    0x54, 0x61, 0x34, 0x07, 0x45, 0xE0, 0x42, 0x63, 
                /* 0090 */    0x64, 0x40, 0xC8, 0xA3, 0x00, 0xAB, 0xA3, 0xD0, 
                /* 0098 */    0xA4, 0x12, 0xD8, 0xBD, 0x00, 0x8D, 0x02, 0xB4, 
                /* 00A0 */    0x09, 0x70, 0x28, 0x40, 0xA1, 0x00, 0x6B, 0x18, 
                /* 00A8 */    0x72, 0x06, 0x21, 0x5B, 0xD8, 0xC2, 0x68, 0x50, 
                /* 00B0 */    0x80, 0x45, 0x14, 0x8D, 0xE0, 0x2C, 0x2A, 0x9E, 
                /* 00B8 */    0x93, 0x50, 0x02, 0xDA, 0x1B, 0x82, 0xF0, 0x8C, 
                /* 00C0 */    0xD9, 0x18, 0x9E, 0x10, 0x83, 0x54, 0x86, 0x21, 
                /* 00C8 */    0x88, 0xB8, 0x11, 0x8E, 0xA5, 0xFD, 0x41, 0x10, 
                /* 00D0 */    0xF9, 0xAB, 0xD7, 0xB8, 0x1D, 0x69, 0x34, 0xA8, 
                /* 00D8 */    0xB1, 0x26, 0x38, 0x76, 0x8F, 0xE6, 0x84, 0x3B, 
                /* 00E0 */    0x17, 0x20, 0x7D, 0x6E, 0x02, 0x39, 0xBA, 0xD3, 
                /* 00E8 */    0xA8, 0x73, 0xD0, 0x64, 0x78, 0x0C, 0x2B, 0xC1, 
                /* 00F0 */    0x7F, 0x80, 0x4F, 0x01, 0x78, 0xD7, 0x80, 0x9A, 
                /* 00F8 */    0xFE, 0xC1, 0x33, 0x41, 0x70, 0xA8, 0x21, 0x7A, 
                /* 0100 */    0xD4, 0xE1, 0x4E, 0xE0, 0xBC, 0x8E, 0x84, 0x41, 
                /* 0108 */    0x1C, 0xD1, 0x71, 0x63, 0x67, 0x75, 0x32, 0x07, 
                /* 0110 */    0x5D, 0xAA, 0x00, 0xB3, 0x07, 0x00, 0x0D, 0x2E, 
                /* 0118 */    0xC1, 0x69, 0x9F, 0x49, 0xE8, 0xF7, 0x80, 0xF3, 
                /* 0120 */    0xE9, 0x79, 0x6C, 0x6C, 0x10, 0xA8, 0x91, 0xF9, 
                /* 0128 */    0xFF, 0x0F, 0xED, 0x41, 0x9E, 0x56, 0xCC, 0x90, 
                /* 0130 */    0xCF, 0x02, 0x87, 0xC5, 0xC4, 0x1E, 0x19, 0xE8, 
                /* 0138 */    0x78, 0xC0, 0x7F, 0x00, 0x78, 0x34, 0x88, 0xF0, 
                /* 0140 */    0x66, 0xE0, 0xF9, 0x9A, 0x60, 0x50, 0x08, 0x39, 
                /* 0148 */    0x19, 0x0F, 0x4A, 0xCC, 0xF9, 0x80, 0xCC, 0x25, 
                /* 0150 */    0xC4, 0x43, 0xC0, 0x31, 0xC4, 0x08, 0x7A, 0x46, 
                /* 0158 */    0x45, 0x23, 0x6B, 0x22, 0x3E, 0x03, 0x78, 0xDC, 
                /* 0160 */    0x96, 0x05, 0x42, 0x09, 0x0C, 0xEC, 0x73, 0xC3, 
                /* 0168 */    0x3B, 0x84, 0x61, 0x71, 0xA3, 0x09, 0xEC, 0xF3, 
                /* 0170 */    0x85, 0x05, 0x0E, 0x0A, 0x05, 0xEB, 0xBB, 0x42, 
                /* 0178 */    0xCC, 0xE7, 0x81, 0xE3, 0x3C, 0x60, 0x0B, 0x9F, 
                /* 0180 */    0x28, 0x01, 0x3E, 0x24, 0x8F, 0x06, 0xDE, 0x20, 
                /* 0188 */    0xE1, 0x5B, 0x3F, 0x02, 0x10, 0xE0, 0x27, 0x06, 
                /* 0190 */    0x13, 0x58, 0x1E, 0x30, 0x7A, 0x94, 0xF6, 0x2B, 
                /* 0198 */    0x00, 0x21, 0xF8, 0x8B, 0xC5, 0x53, 0xC0, 0xEB, 
                /* 01A0 */    0x40, 0x84, 0x63, 0x81, 0x29, 0x72, 0x6C, 0x68, 
                /* 01A8 */    0x78, 0x7E, 0x70, 0x88, 0x1E, 0xF5, 0x5C, 0xC2, 
                /* 01B0 */    0x1F, 0x4D, 0x94, 0x53, 0x38, 0x1C, 0x1F, 0x39, 
                /* 01B8 */    0x8C, 0x10, 0xFE, 0x49, 0xE3, 0xC9, 0xC3, 0x9A, 
                /* 01C0 */    0xEF, 0x00, 0x9A, 0xD2, 0x5B, 0xC0, 0xFB, 0x83, 
                /* 01C8 */    0x47, 0x80, 0x11, 0x20, 0xE1, 0x68, 0x82, 0x89, 
                /* 01D0 */    0x7C, 0x3A, 0x01, 0xD5, 0xFF, 0xFF, 0x74, 0x02, 
                /* 01D8 */    0xB8, 0xBA, 0x01, 0x14, 0x37, 0x6A, 0x9D, 0x49, 
                /* 01E0 */    0x7C, 0x2C, 0xF1, 0xAD, 0xE4, 0xBC, 0x43, 0xC5, 
                /* 01E8 */    0x7F, 0x93, 0x78, 0x3A, 0xF1, 0x34, 0x1E, 0x4C, 
                /* 01F0 */    0x42, 0x44, 0x89, 0x18, 0x21, 0xA2, 0xEF, 0x27, 
                /* 01F8 */    0x46, 0x08, 0x15, 0x31, 0x6C, 0xA4, 0x37, 0x80, 
                /* 0200 */    0xE7, 0x13, 0xE3, 0x84, 0x08, 0xF4, 0x74, 0xC2, 
                /* 0208 */    0x42, 0x3E, 0x34, 0xA4, 0xE1, 0x74, 0x02, 0x50, 
                /* 0210 */    0xE0, 0xFF, 0x7F, 0x3A, 0x81, 0x1F, 0xF5, 0x74, 
                /* 0218 */    0x82, 0x1E, 0xAE, 0x4F, 0x19, 0x18, 0xE4, 0x03, 
                /* 0220 */    0xF2, 0xA9, 0xC3, 0xF7, 0x1F, 0x13, 0xF8, 0x78, 
                /* 0228 */    0xC2, 0x45, 0x1D, 0x4F, 0x50, 0xA7, 0x07, 0x1F, 
                /* 0230 */    0x4F, 0xD8, 0x19, 0xE1, 0x2C, 0x1E, 0x03, 0x7C, 
                /* 0238 */    0x3A, 0xC1, 0xDC, 0x13, 0x7C, 0x3A, 0x01, 0xDB, 
                /* 0240 */    0x68, 0x60, 0x1C, 0x4F, 0xC0, 0x77, 0x74, 0xC1, 
                /* 0248 */    0x1D, 0x4F, 0xC0, 0x30, 0x18, 0x18, 0xE7, 0x13, 
                /* 0250 */    0xE0, 0x31, 0x5E, 0xDC, 0x31, 0xC0, 0x43, 0xE0, 
                /* 0258 */    0x03, 0x78, 0xDC, 0x38, 0x3D, 0x2B, 0x9D, 0x14, 
                /* 0260 */    0xF2, 0x24, 0xC2, 0x07, 0x85, 0x39, 0xB0, 0xE0, 
                /* 0268 */    0x14, 0xDA, 0xF4, 0xA9, 0xD1, 0xA8, 0x55, 0x83, 
                /* 0270 */    0x32, 0x35, 0xCA, 0x34, 0xA8, 0xD5, 0xA7, 0x52, 
                /* 0278 */    0x63, 0xC6, 0xCE, 0x19, 0x0E, 0xF8, 0x10, 0xD0, 
                /* 0280 */    0x89, 0xC0, 0xF2, 0x9E, 0x0D, 0x02, 0xB1, 0x0C, 
                /* 0288 */    0x0A, 0x81, 0x58, 0xFA, 0xAB, 0x45, 0x20, 0x0E, 
                /* 0290 */    0x0E, 0xA2, 0xFF, 0x3F, 0x88, 0x23, 0xD2, 0x0A, 
                /* 0298 */    0xC4, 0xFF, 0x7F, 0x7F
            })
        }
    }

    Scope (_SB.PCI0)
    {
        PowerResource (DGPR, 0x00, 0x0001)
        {
            Method (_ON, 0, NotSerialized)
            {
                Return (Zero)
            }

            Method (_OFF, 0, NotSerialized)
            {
                Return (Zero)
            }

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

    Scope (_SB.PCI0.PEGP)
    {
        Method (_STA, 0, NotSerialized)
        {
            Return (0x0F)
        }

        Device (DGPU)
        {
            Name (_ADR, Zero)
            Name (_PR0, Package (0x01)
            {
                DGPR
            })
            Method (_ON, 0, Serialized)
            {
                If (ECOK)
                {
                    DGPC (One)
                }

                Return (One)
            }

            Method (_OFF, 0, Serialized)
            {
                If (ECOK)
                {
                    DGPC (Zero)
                }

                Return (One)
            }

            Method (_STA, 0, Serialized)
            {
                If (ECOK)
                {
                    If (^^^LPC.H8EC.HPOK)
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (One)
                    }
                }
                Else
                {
                    Return (0x0F)
                }
            }

            OperationRegion (EDIM, SystemMemory, EDPT, 0x0100)
            Field (EDIM, AnyAcc, NoLock, Preserve)
            {
                E256,   2048
            }

            OperationRegion (VBIM, SystemMemory, VBPT, 0x00010000)
            Field (VBIM, AnyAcc, NoLock, Preserve)
            {
                UP32,   262144, 
                LO32,   262144
            }

            Method (_ROM, 2, NotSerialized)
            {
                If (LGreater (Arg1, 0x1000))
                {
                    Return (Zero)
                }

                Name (RETB, Buffer (Arg1) {})
                Name (TMP0, Buffer (0x8000) {})
                Name (TMP1, Buffer (0x8000) {})
                Store (UP32, TMP0)
                Store (LO32, TMP1)
                If (LAnd (LGreaterEqual (Arg0, Zero), LLess (Arg0, 0x8000)))
                {
                    If (LLess (Add (Arg0, Arg1), 0x8000))
                    {
                        Store (Zero, Local0)
                        While (LLess (Local0, Arg1))
                        {
                            Store (DerefOf (Index (TMP0, Add (Arg0, Local0))), Index (
                                RETB, Local0))
                            Increment (Local0)
                        }

                        Return (RETB)
                    }
                    Else
                    {
                        Store (Subtract (0x8000, Arg0), Local1)
                        Store (Subtract (Arg1, Local1), Local2)
                        Store (Zero, Local0)
                        While (LLess (Local0, Local1))
                        {
                            Store (DerefOf (Index (TMP0, Add (Arg0, Local0))), Index (
                                RETB, Local0))
                            Increment (Local0)
                        }

                        Store (Local0, Local3)
                        Store (Zero, Local0)
                        While (LLess (Local0, Local2))
                        {
                            Store (DerefOf (Index (TMP1, Local0)), Index (RETB, Add (Local3, 
                                Local0)))
                            Increment (Local0)
                        }

                        Return (RETB)
                    }
                }

                If (LAnd (LGreaterEqual (Arg0, 0x8000), LLess (Add (Arg0, Arg1
                    ), 0x00010000)))
                {
                    Store (Zero, Local0)
                    While (LLess (Local0, Arg1))
                    {
                        Store (DerefOf (Index (TMP1, Add (Subtract (Arg0, 0x8000), Local0
                            ))), Index (RETB, Local0))
                        Increment (Local0)
                    }

                    Return (RETB)
                }

                Return (Zero)
            }

            Mutex (PWRC, 0x00)
            Method (DGPC, 1, Serialized)
            {
                If (Arg0)
                {
                    If (LEqual (^^^LPC.H8EC.HPOK, Zero))
                    {
                        Acquire (PWRC, 0xFFFF)
                        If (LEqual (HPLE, One))
                        {
                            Store (0x03, HPI0)
                            Store (One, HPI1)
                            TRAP (TRTA, 0x1B)
                            Store (0x0B, HPI0)
                            TRAP (TRTA, 0x1B)
                        }

                        Store (0x0A, HPI0)
                        Store (Zero, HPI1)
                        TRAP (TRTA, 0x1B)
                        Store (One, ^^^LPC.H8EC.HPWR)
                        While (LEqual (^^^LPC.H8EC.HPOK, Zero))
                        {
                            Sleep (0x0A)
                        }

                        Sleep (0x64)
                        Store (Zero, HPI0)
                        TRAP (TRTA, 0x1B)
                        Store (0x02, HPI0)
                        TRAP (TRTA, 0x1B)
                        Store (0x09, HPI0)
                        Store (One, HPI1)
                        TRAP (TRTA, 0x1B)
                        Release (PWRC)
                    }
                }
                Else
                {
                    If (LEqual (^^^LPC.H8EC.HPOK, One))
                    {
                        Acquire (PWRC, 0xFFFF)
                        Store (0x0A, HPI0)
                        Store (Zero, HPI1)
                        TRAP (TRTA, 0x1B)
                        Store (0x09, HPI0)
                        Store (Zero, HPI1)
                        TRAP (TRTA, 0x1B)
                        Store (One, HPI0)
                        TRAP (TRTA, 0x1B)
                        Store (Zero, ^^^LPC.H8EC.HPWR)
                        While (LEqual (^^^LPC.H8EC.HPOK, One))
                        {
                            Sleep (0x0A)
                        }

                        Store (0x0A, HPI0)
                        Store (0x03, HPI1)
                        TRAP (TRTA, 0x1B)
                        If (LEqual (HPLE, One))
                        {
                            Store (0x03, HPI0)
                            Store (Zero, HPI1)
                            TRAP (TRTA, 0x1B)
                        }

                        Release (PWRC)
                    }
                }
            }

            Method (_DOD, 0, NotSerialized)
            {
                Return (Package (0x04)
                {
                    0x80090320, 
                    0x80097330, 
                    0x00010110, 
                    0x80010100
                })
            }

            Method (_DOS, 1, NotSerialized)
            {
            }

            Method (MXDS, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    Return (^^^LPC.H8EC.HLMX)
                }

                If (LEqual (Arg0, One))
                {
                    Store (One, ^^^LPC.H8EC.HLMX)
                }

                Return (One)
            }

            Method (MXMX, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    Store (One, ^^^LPC.H8EC.HCMM)
                }

                If (LEqual (Arg0, One))
                {
                    Store (Zero, ^^^LPC.H8EC.HCMM)
                }

                If (LEqual (Arg0, 0x02))
                {
                    Return (^^^LPC.H8EC.HCMM)
                }

                Return (One)
            }

            Method (_DSM, 4, Serialized)
            {
                Return (^^^OVGA._DSM (Arg0, Arg1, Arg2, Arg3))
            }

            Device (LCD)
            {
                Method (_ADR, 0, Serialized)
                {
                    Return (0x0110)
                }

                Method (_DCS, 0, NotSerialized)
                {
                    If (^^^^LPC.H8EC.LIDS)
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (One)
                    }
                }

                Method (MXDS, 1, NotSerialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Return (^^^^LPC.H8EC.HLMX)
                    }

                    If (LEqual (Arg0, One))
                    {
                        Store (One, ^^^^LPC.H8EC.HLMX)
                    }

                    Return (One)
                }

                Method (_DDC, 1, NotSerialized)
                {
                    Name (T128, Buffer (0x80) {})
                    Name (T256, Buffer (0x0100) {})
                    Store (E256, T256)
                    Return (T256)
                    If (LEqual (Arg0, One))
                    {
                        Store (Zero, Local0)
                        While (LLess (Local0, SizeOf (T128)))
                        {
                            Store (DerefOf (Index (T256, Local0)), Index (T128, Local0))
                            Increment (Local0)
                        }

                        Return (T128)
                    }

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

                    Return (Zero)
                }

                Method (_DSS, 1, NotSerialized)
                {
                }
            }

            Device (CRT)
            {
                Method (_ADR, 0, Serialized)
                {
                    Return (0x0100)
                }

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

                Method (MXDS, 1, NotSerialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Return (^^^^LPC.H8EC.HLMX)
                    }

                    If (LEqual (Arg0, One))
                    {
                        Store (One, ^^^^LPC.H8EC.HLMX)
                    }

                    Return (One)
                }

                Method (MXMX, 1, NotSerialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Store (One, ^^^^LPC.H8EC.HCMM)
                    }

                    If (LEqual (Arg0, One))
                    {
                        Store (Zero, ^^^^LPC.H8EC.HCMM)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Return (^^^^LPC.H8EC.HCMM)
                    }

                    Return (One)
                }

                Method (_DSS, 1, NotSerialized)
                {
                }
            }

            Device (DVI)
            {
                Method (_ADR, 0, Serialized)
                {
                    Return (0x0320)
                }

                Method (_DCS, 0, NotSerialized)
                {
                    If (^^^^LPC.H8EC.DCKS)
                    {
                        Return (One)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Method (MXDS, 1, NotSerialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Return (One)
                    }

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

                Method (MXMX, 1, NotSerialized)
                {
                    If (LEqual (Arg0, Zero)) {}
                    If (LEqual (Arg0, One)) {}
                    If (LEqual (Arg0, 0x02))
                    {
                        Return (One)
                    }

                    Return (One)
                }

                Method (_DSS, 1, NotSerialized)
                {
                }
            }

            Device (HDMI)
            {
                Method (_ADR, 0, Serialized)
                {
                    Return (0x7330)
                }

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

                Method (MXDS, 1, NotSerialized)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Return (One)
                    }

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

                Method (MXMX, 1, NotSerialized)
                {
                    If (LEqual (Arg0, Zero)) {}
                    If (LEqual (Arg0, One)) {}
                    If (LEqual (Arg0, 0x02))
                    {
                        Return (One)
                    }

                    Return (One)
                }

                Method (_DSS, 1, NotSerialized)
                {
                }
            }
        }
    }

    Scope (_SB.PCI0)
    {
        PowerResource (MGPR, 0x00, 0x0002)
        {
            Method (_ON, 0, NotSerialized)
            {
                Return (Zero)
            }

            Method (_OFF, 0, NotSerialized)
            {
                Return (Zero)
            }

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

    Scope (_SB.PCI0.OVGA)
    {
        Name (_PR0, Package (0x01)
        {
            MGPR
        })
        Method (_DOD, 0, NotSerialized)
        {
            Return (Package (0x04)
            {
                0x00010110, 
                0x80010100, 
                0x80090320, 
                0x80097330
            })
        }

        Method (_DOS, 1, NotSerialized)
        {
            If (LEqual (Arg0, Zero))
            {
                If (LEqual (HGDD, One))
                {
                    If (LEqual (HPND, Zero))
                    {
                        Store (One, HPND)
                        Store (0x03, HNCD)
                    }

                    Store (Zero, POVR)
                    Notify (OVGA, 0xD0)
                    Notify (WMI1, 0xD0)
                }
            }

            If (LEqual (Arg0, 0x02))
            {
                Store (Zero, HGDD)
            }
        }

        Method (MXDS, 1, NotSerialized)
        {
            If (LEqual (Arg0, Zero))
            {
                If (^^LPC.H8EC.HLMX)
                {
                    Return (Zero)
                }
                Else
                {
                    Return (One)
                }
            }

            If (LEqual (Arg0, One))
            {
                Store (Zero, ^^LPC.H8EC.HLMX)
            }

            Return (One)
        }

        Method (MXMX, 1, NotSerialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Store (Zero, ^^LPC.H8EC.HCMM)
            }

            If (LEqual (Arg0, One))
            {
                Store (One, ^^LPC.H8EC.HCMM)
            }

            If (LEqual (Arg0, 0x02))
            {
                If (^^LPC.H8EC.HCMM)
                {
                    Return (Zero)
                }
                Else
                {
                    Return (One)
                }
            }

            Return (One)
        }

        Device (LCD)
        {
            Method (_ADR, 0, Serialized)
            {
                Return (0x0110)
            }

            Name (VTBL, Package (0x0B)
            {
                0x64, 
                0x64, 
                0x04, 
                0x10, 
                0x1C, 
                0x28, 
                0x34, 
                0x40, 
                0x4C, 
                0x58, 
                0x64
            })
            Method (_BCL, 0, NotSerialized)
            {
                Return (VTBL)
            }

            Method (_BCM, 1, NotSerialized)
            {
                Store (Match (VTBL, MEQ, Arg0, MTR, Zero, 0x02), Local0)
                If (LEqual (Local0, Ones))
                {
                    Return (Zero)
                }

                Store (Arg0, BRTL)
                Subtract (Local0, 0x02, Local0)
                Store (Local0, LCDB)
                Store (ISTP (0x07, Zero), Local0)
                AINT (One, Local0)
            }

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

            Method (_DCS, 0, NotSerialized)
            {
                If (^^^LPC.H8EC.LIDS)
                {
                    Return (Zero)
                }
                Else
                {
                    Return (One)
                }
            }

            Method (MXDS, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    If (^^^LPC.H8EC.HLMX)
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (One)
                    }
                }

                If (LEqual (Arg0, One))
                {
                    Store (Zero, ^^^LPC.H8EC.HLMX)
                }

                Return (One)
            }

            Method (_DDC, 1, NotSerialized)
            {
                Return (^^^PEGP.DGPU.LCD._DDC (Arg0))
            }

            Method (_DSS, 1, NotSerialized)
            {
            }
        }

        Device (CRT)
        {
            Method (_ADR, 0, Serialized)
            {
                Return (0x0100)
            }

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

            Method (MXDS, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    If (^^^LPC.H8EC.HLMX)
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (One)
                    }
                }

                If (LEqual (Arg0, One))
                {
                    Store (Zero, ^^^LPC.H8EC.HLMX)
                }

                Return (One)
            }

            Method (MXMX, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    Store (Zero, ^^^LPC.H8EC.HCMM)
                }

                If (LEqual (Arg0, One))
                {
                    Store (One, ^^^LPC.H8EC.HCMM)
                }

                If (LEqual (Arg0, 0x02))
                {
                    If (^^^LPC.H8EC.HCMM)
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (One)
                    }
                }

                Return (One)
            }

            Method (_DSS, 1, NotSerialized)
            {
            }
        }

        Device (DVI)
        {
            Method (_ADR, 0, Serialized)
            {
                Return (0x0320)
            }

            Method (_DCS, 0, NotSerialized)
            {
                Return (Zero)
            }

            Method (MXDS, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    Return (Zero)
                }

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

            Method (MXMX, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero)) {}
                If (LEqual (Arg0, One)) {}
                If (LEqual (Arg0, 0x02))
                {
                    Return (Zero)
                }

                Return (One)
            }

            Method (_DSS, 1, NotSerialized)
            {
                If (LAnd (Arg0, One))
                {
                    Store (One, HGDD)
                }
                Else
                {
                    Store (Zero, HGDD)
                }
            }
        }

        Device (HDMI)
        {
            Method (_ADR, 0, Serialized)
            {
                Return (0x7330)
            }

            Method (_DCS, 0, NotSerialized)
            {
                Return (Zero)
            }

            Method (MXDS, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    Return (Zero)
                }

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

            Method (MXMX, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero)) {}
                If (LEqual (Arg0, One)) {}
                If (LEqual (Arg0, 0x02))
                {
                    Return (Zero)
                }

                Return (One)
            }

            Method (_DSS, 1, NotSerialized)
            {
                If (LAnd (Arg0, One))
                {
                    Store (One, HGDD)
                }
                Else
                {
                    Store (Zero, HGDD)
                }
            }
        }
    }

    Scope (_SB.PCI0.OVGA)
    {
        Method (_DSM, 4, Serialized)
        {
            Store (Buffer (0x04)
                {
                    0x00, 0x00, 0x00, 0x00
                }, Local0)
            CreateDWordField (Local0, Zero, RBUF)
            If (LNotEqual (Arg0, Buffer (0x10)
                        {
                            /* 0000 */    0xA0, 0xA0, 0x95, 0x9D, 0x60, 0x00, 0x48, 0x4D, 
                            /* 0008 */    0xB3, 0x4D, 0x7E, 0x5F, 0xEA, 0x12, 0x9F, 0xD4
                        }))
            {
                Store (0x80000002, RBUF)
                Return (Local0)
            }

            If (LEqual (Arg1, 0x0102))
            {
                Name (_T_0, Zero)
                Store (Arg2, _T_0)
                If (LEqual (_T_0, Zero))
                {
                    Store (0x307F, RBUF)
                    Return (Local0)
                }
                Else
                {
                    If (LEqual (_T_0, One))
                    {
                        Store (0x07, HPI0)
                        TRAP (TRTA, 0x1B)
                        If (LEqual (HPO0, Zero))
                        {
                            Or (RBUF, One, RBUF)
                        }

                        Or (RBUF, 0x02, RBUF)
                        Or (RBUF, 0x04, RBUF)
                        Or (RBUF, ShiftLeft (^^LPC.H8EC.HPWR, 0x03), RBUF)
                        Or (RBUF, ShiftLeft (^^LPC.H8EC.HPOK, 0x04), RBUF)
                        Or (RBUF, ShiftLeft (HNCD, 0x08), RBUF)
                        Store (Zero, HNCD)
                        Or (RBUF, ShiftLeft (HNCA, 0x0B), RBUF)
                        Store (Zero, HNCA)
                        If (LEqual (HPLE, One))
                        {
                            Or (RBUF, 0x8000, RBUF)
                        }
                        Else
                        {
                            Or (RBUF, 0x4000, RBUF)
                        }

                        Return (Local0)
                    }
                    Else
                    {
                        If (LEqual (_T_0, 0x02))
                        {
                            If (And (Arg3, 0x10))
                            {
                                And (Arg3, 0x0F, HGAP)
                                Store (Zero, HPND)
                                If (LEqual (HGAP, One))
                                {
                                    Store (One, ^^LPC.H8EC.ILED)
                                    Store (Zero, ^^LPC.H8EC.DLED)
                                }
                                Else
                                {
                                    If (LEqual (HGAP, 0x02))
                                    {
                                        Store (One, ^^LPC.H8EC.DLED)
                                        Store (Zero, ^^LPC.H8EC.ILED)
                                    }
                                    Else
                                    {
                                        Store (Zero, ^^LPC.H8EC.ILED)
                                        Store (Zero, ^^LPC.H8EC.DLED)
                                    }
                                }

                                Notify (OVGA, 0xD9)
                                Notify (WMI1, 0xD9)
                                If (LOr (LEqual (POVR, Zero), LEqual (POVR, One)))
                                {
                                    Store (Ones, POVR)
                                }

                                Store (One, AVIL)
                                Store (0x04, HGER)
                                ^^LPC.SNC.SNNE (0x0128)
                            }

                            Name (_T_1, Zero)
                            Store (SSPS, _T_1)
                            If (LEqual (_T_1, 0x05))
                            {
                                If (^^LPC.H8EC.SWPS)
                                {
                                    Or (RBUF, 0x02, RBUF)
                                }
                                Else
                                {
                                    Or (RBUF, One, RBUF)
                                }

                                Or (RBUF, 0x10, RBUF)
                                Store (Zero, SSPS)
                            }
                            Else
                            {
                                If (LEqual (_T_1, 0x04))
                                {
                                    If (LEqual (HGAP, 0x02))
                                    {
                                        Or (RBUF, 0x02, RBUF)
                                    }
                                    Else
                                    {
                                        Or (RBUF, One, RBUF)
                                    }

                                    Store (Zero, SSPS)
                                }
                                Else
                                {
                                    If (LEqual (_T_1, 0x03))
                                    {
                                        If (LEqual (HGAP, 0x02))
                                        {
                                            Or (RBUF, 0x02, RBUF)
                                        }
                                        Else
                                        {
                                            Or (RBUF, One, RBUF)
                                        }

                                        Store (Zero, SSPS)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_1, Zero))
                                        {
                                            If (^^LPC.H8EC.SWPS)
                                            {
                                                Or (RBUF, 0x02, RBUF)
                                            }
                                            Else
                                            {
                                                Or (RBUF, One, RBUF)
                                            }

                                            If (LNot (^^LPC.H8EC.HSMP ()))
                                            {
                                                Or (RBUF, 0x10, RBUF)
                                            }

                                            If (LOr (LEqual (POVR, Zero), LEqual (POVR, One)))
                                            {
                                                Store (Zero, RBUF)
                                                If (LEqual (POVR, Zero))
                                                {
                                                    Or (RBUF, 0x02, RBUF)
                                                }

                                                If (LEqual (POVR, One))
                                                {
                                                    Or (RBUF, One, RBUF)
                                                }

                                                Or (RBUF, 0x10, RBUF)
                                            }
                                        }
                                    }
                                }
                            }

                            Return (Local0)
                        }
                        Else
                        {
                            If (LEqual (_T_0, 0x03))
                            {
                                If (LEqual (And (Arg3, 0x03), Zero))
                                {
                                    Return (^^PEGP.DGPU._STA ())
                                }

                                If (LEqual (And (Arg3, 0x03), One))
                                {
                                    ^^PEGP.DGPU._ON ()
                                    Return (One)
                                }

                                If (LEqual (And (Arg3, 0x03), 0x02))
                                {
                                    ^^PEGP.DGPU._OFF ()
                                    Return (Zero)
                                }
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x04))
                                {
                                    Store (0x06, HPI0)
                                    Store (One, HPI1)
                                    TRAP (TRTA, 0x1B)
                                    Store (HPO0, RBUF)
                                    Or (RBUF, 0x08000000, RBUF)
                                    If (And (Arg3, 0x1000))
                                    {
                                        Store (Zero, Local1)
                                        Or (Local1, 0x0800, Local1)
                                        Or (Local1, 0x0400, Local1)
                                        Or (Local1, 0x0200, Local1)
                                        Or (Local1, 0x0100, Local1)
                                        Or (Local1, 0x80, Local1)
                                        Or (Local1, 0x40, Local1)
                                        Or (Local1, 0x20, Local1)
                                        Or (Local1, 0x10, Local1)
                                        Or (Local1, 0x08, Local1)
                                        Or (Local1, 0x04, Local1)
                                        Or (Local1, 0x02, Local1)
                                        Or (Local1, One, Local1)
                                        And (Arg3, Local1, Local2)
                                        And (HPO0, Not (Local1), Local3)
                                        Or (Local3, Local2, HPO0)
                                    }

                                    If (And (Arg3, 0x00010000))
                                    {
                                        Store (Zero, Local1)
                                        Or (Local1, 0x4000, Local1)
                                        Or (Local1, 0x2000, Local1)
                                        And (Arg3, Local1, Local2)
                                        And (HPO0, Not (Local1), Local3)
                                        Or (Local3, Local2, HPO0)
                                    }

                                    If (And (Arg3, 0x00200000))
                                    {
                                        Store (Zero, Local1)
                                        Or (Local1, 0x00100000, Local1)
                                        Or (Local1, 0x00080000, Local1)
                                        Or (Local1, 0x00040000, Local1)
                                        Or (Local1, 0x00020000, Local1)
                                        And (Arg3, Local1, Local2)
                                        ShiftRight (Local1, One, Local1)
                                        ShiftRight (Local2, One, Local2)
                                        And (HPO0, Not (Local1), Local3)
                                        Or (Local3, Local2, HPO0)
                                    }

                                    If (And (Arg3, 0x08000000))
                                    {
                                        Store (Zero, Local1)
                                        Or (Local1, 0x04000000, Local1)
                                        Or (Local1, 0x02000000, Local1)
                                        Or (Local1, 0x01000000, Local1)
                                        Or (Local1, 0x00800000, Local1)
                                        Or (Local1, 0x00400000, Local1)
                                        And (Arg3, Local1, Local2)
                                        ShiftRight (Local1, One, Local1)
                                        ShiftRight (Local2, One, Local2)
                                        And (HPO0, Not (Local1), Local3)
                                        Or (Local3, Local2, HPO0)
                                    }

                                    Store (0x06, HPI0)
                                    Store (Zero, HPI1)
                                    TRAP (TRTA, 0x1B)
                                    Return (Local0)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x05))
                                    {
                                        If (And (Arg3, 0x01000000))
                                        {
                                            And (Arg3, 0x00FFFFFF, ADAD)
                                        }

                                        If (And (Arg3, 0x80000000))
                                        {
                                            ShiftRight (Arg3, 0x19, Local1)
                                            And (Local1, 0x3F, SNGT)
                                        }

                                        Or (RBUF, ShiftLeft (HDAE, Zero), RBUF)
                                        If (LAnd (LEqual (HDAE, 0x02), LEqual (HDHE, 0x00010110)))
                                        {
                                            Or (RBUF, 0x10, RBUF)
                                        }

                                        If (^^LPC.H8EC.DCKS)
                                        {
                                            Or (RBUF, 0x20, RBUF)
                                        }

                                        And (SNGT, 0x1F, Local1)
                                        If (LAnd (LEqual (HDAE, One), LEqual (And (Arg3, 0x80000000), 
                                            Zero)))
                                        {
                                            Increment (Local1)
                                        }

                                        If (LGreaterEqual (Local1, 0x08))
                                        {
                                            Store (One, Local1)
                                        }

                                        Or (RBUF, ShiftLeft (Local1, 0x08), RBUF)
                                        If (LEqual (HDAE, 0x02))
                                        {
                                            Name (_T_2, Zero)
                                            Store (HDHE, _T_2)
                                            If (LEqual (_T_2, 0x00010110))
                                            {
                                                If (LNot (^^LPC.H8EC.LIDS))
                                                {
                                                    Or (RBUF, 0x00100000, RBUF)
                                                }
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_2, 0x80010100))
                                                {
                                                    Store (GIDX (0x80010100), Local1)
                                                    ShiftLeft (One, Local1, Local1)
                                                    If (And (ADAD, Local1))
                                                    {
                                                        Or (RBUF, 0x00100000, RBUF)
                                                    }
                                                }
                                                Else
                                                {
                                                    If (LEqual (_T_2, 0x80090320))
                                                    {
                                                        If (^^LPC.H8EC.DHPD)
                                                        {
                                                            Or (RBUF, 0x00100000, RBUF)
                                                        }
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (_T_2, 0x80097330))
                                                        {
                                                            If (^^LPC.H8EC.HHPD)
                                                            {
                                                                Or (RBUF, 0x00100000, RBUF)
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }

                                        If (LEqual (HDAE, 0x02))
                                        {
                                            Store (GIDX (HDHE), Local1)
                                            If (LNotEqual (Local1, Ones))
                                            {
                                                Increment (Local1)
                                                Or (RBUF, ShiftLeft (Local1, 0x15), RBUF)
                                            }
                                        }

                                        Return (Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (_T_0, 0x06))
                                        {
                                            Return (Package (0x11)
                                            {
                                                0x0110, 
                                                0x2C, 
                                                0x0110, 
                                                0x0100, 
                                                0x2C, 
                                                0x0110, 
                                                0x0320, 
                                                0x2C, 
                                                0x0110, 
                                                0x7330, 
                                                0x2C, 
                                                0x0100, 
                                                0x2C, 
                                                0x0320, 
                                                0x2C, 
                                                0x7330, 
                                                0x2C
                                            })
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_0, 0x0C))
                                            {
                                                Store (One, RBUF)
                                                And (Arg3, 0xFF00, Local1)
                                                ShiftRight (Local1, 0x08, Local1)
                                                Store (GDID (Local1), Local2)
                                                If (LEqual (Local2, Zero))
                                                {
                                                    Store (One, RBUF)
                                                    Return (Local0)
                                                }

                                                Store (SBYT (Local2, Zero), Local3)
                                                If (LNotEqual (ObjectType (Local3), 0x03))
                                                {
                                                    Store (One, RBUF)
                                                    Return (Local0)
                                                }

                                                Store (Zero, Local4)
                                                While (LLess (Local4, 0x80))
                                                {
                                                    If (LEqual (Local2, 0x80090320))
                                                    {
                                                        Store (DerefOf (Index (Local3, Local4)), Index (DDCA, Local4))
                                                    }

                                                    If (LEqual (Local2, 0x80097330))
                                                    {
                                                        Store (DerefOf (Index (Local3, Local4)), Index (DDCB, Local4))
                                                    }

                                                    Increment (Local4)
                                                }

                                                Store (DerefOf (Index (Local3, 0x7E)), Local4)
                                                Store (One, Local5)
                                                While (LLessEqual (Local5, Local4))
                                                {
                                                    Store (SBYT (Local2, Local5), Local3)
                                                    If (LNotEqual (ObjectType (Local3), 0x03))
                                                    {
                                                        CDGB (Local2)
                                                        Store (One, RBUF)
                                                        Return (Local0)
                                                    }

                                                    Store (Zero, Local6)
                                                    While (LLess (Local6, 0x80))
                                                    {
                                                        If (LEqual (Local2, 0x80090320))
                                                        {
                                                            Store (DerefOf (Index (Local3, Local6)), Index (DDCA, Add (Multiply (
                                                                0x80, Local5), Local6)))
                                                        }

                                                        If (LEqual (Local2, 0x80097330))
                                                        {
                                                            Store (DerefOf (Index (Local3, Local6)), Index (DDCB, Add (Multiply (
                                                                0x80, Local5), Local6)))
                                                        }

                                                        Increment (Local6)
                                                    }

                                                    Increment (Local5)
                                                }

                                                If (VEGB (Local2))
                                                {
                                                    Notify (OVGA, Add (0xE0, Local1))
                                                    Notify (WMI1, Add (0xE0, Local1))
                                                    Store (One, HNCA)
                                                    Store (Zero, RBUF)
                                                }

                                                Return (Local0)
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_0, 0x0D))
                                                {
                                                    And (Arg3, 0xFF00, Local1)
                                                    ShiftRight (Local1, 0x08, Local1)
                                                    Store (GDID (Local1), Local1)
                                                    If (LEqual (Local1, Zero))
                                                    {
                                                        Store (Zero, RBUF)
                                                        Return (Local0)
                                                    }

                                                    Name (_T_3, Zero)
                                                    Store (Local1, _T_3)
                                                    If (LEqual (_T_3, 0x80090320))
                                                    {
                                                        Store (DDCA, Local2)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (_T_3, 0x80097330))
                                                        {
                                                            Store (DDCB, Local2)
                                                        }
                                                    }

                                                    CDGB (Local1)
                                                    Store (DerefOf (Index (Local2, 0x7E)), Local1)
                                                    Increment (Local1)
                                                    Multiply (Local1, 0x80, Local1)
                                                    Name (WEDB, Buffer (Local1)
                                                    {
                                                        0x00
                                                    })
                                                    Store (Zero, Local3)
                                                    While (LLess (Local3, Local1))
                                                    {
                                                        Store (DerefOf (Index (Local2, Local3)), Index (WEDB, Local3))
                                                        Increment (Local3)
                                                    }

                                                    Return (WEDB)
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            Store (0x80000002, RBUF)
            Return (Local0)
        }

        Method (GDID, 1, NotSerialized)
        {
            Store (_DOD (), Local0)
            If (LGreaterEqual (Arg0, SizeOf (Local0)))
            {
                Return (Zero)
            }
            Else
            {
                Return (DerefOf (Index (Local0, Arg0)))
            }
        }

        Method (GIDX, 1, NotSerialized)
        {
            Store (_DOD (), Local0)
            Store (Zero, Local1)
            While (LLess (Local1, SizeOf (Local0)))
            {
                Store (DerefOf (Index (Local0, Local1)), Local2)
                If (LEqual (Arg0, Local2))
                {
                    Return (Local1)
                }

                Increment (Local1)
            }

            Return (Ones)
        }

        Method (SBYT, 2, Serialized)
        {
            Name (EBLK, Buffer (0x80)
            {
                0x00
            })
            If (LOr (LEqual (Arg0, 0x80090320), LEqual (Arg0, 0x80097330)))
            {
                If (LEqual (Arg0, 0x80090320))
                {
                    Store (Zero, GP27)
                    Store (One, GP28)
                }
                Else
                {
                    Store (One, GP27)
                    Store (One, GP28)
                }

                Sleep (One)
                Store (Zero, Local0)
                While (LLess (Local0, 0x80))
                {
                    Add (Multiply (0x80, Arg1), Local0, Local1)
                    Store (^^SBUS.SRDB (0xA0, Local1), Local2)
                    If (LEqual (Local2, 0xFFFF))
                    {
                        Store (Zero, GP28)
                        Sleep (One)
                        Return (Zero)
                    }
                    Else
                    {
                        Store (Local2, Index (EBLK, Local0))
                    }

                    Increment (Local0)
                }

                Store (Zero, GP28)
                Sleep (One)
                Return (EBLK)
            }

            Return (Zero)
        }

        Method (CDGB, 1, Serialized)
        {
            Store (Zero, Local0)
            Name (_T_0, Zero)
            Store (Arg0, _T_0)
            If (LEqual (_T_0, 0x80090320))
            {
                While (LLess (Local0, SizeOf (DDCA)))
                {
                    Store (Zero, Index (DDCA, Local0))
                    Increment (Local0)
                }

                Return (One)
            }
            Else
            {
                If (LEqual (_T_0, 0x80097330))
                {
                    While (LLess (Local0, SizeOf (DDCB)))
                    {
                        Store (Zero, Index (DDCB, Local0))
                        Increment (Local0)
                    }

                    Return (One)
                }
            }

            Return (Zero)
        }

        Method (VEGB, 1, Serialized)
        {
            Name (EHDR, Buffer (0x08)
            {
                /* 0000 */    0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00
            })
            Name (_T_0, Zero)
            Store (Arg0, _T_0)
            If (LEqual (_T_0, 0x80090320))
            {
                Store (DDCA, Local0)
            }
            Else
            {
                If (LEqual (_T_0, 0x80097330))
                {
                    Store (DDCB, Local0)
                }
            }

            Store (Zero, Local1)
            While (LLess (Local1, SizeOf (EHDR)))
            {
                If (LNotEqual (DerefOf (Index (EHDR, Local1)), DerefOf (Index (
                    Local0, Local1))))
                {
                    Return (Zero)
                }

                Increment (Local1)
            }

            Return (One)
        }
    }

    Scope (_SB.PCI0.LPC.H8EC)
    {
        Method (_Q40, 0, NotSerialized)
        {
            Store (0x40, P80H)
            Store (One, HGER)
            ^^SNC.SNNE (0x0128)
        }

        Method (_Q41, 0, NotSerialized)
        {
            Store (0x41, P80H)
            Store (0x02, HDAE)
            Store (0x80097330, HDHE)
            Notify (OVGA, 0x81)
            Notify (WMI1, 0x81)
            If (HHPD)
            {
                If (LEqual (HGAP, One))
                {
                    Store (0x02, HGER)
                    ^^SNC.SNNE (0x0128)
                }
            }
            Else
            {
                If (LEqual (HGAP, One))
                {
                    Store (0x03, HGER)
                    ^^SNC.SNNE (0x0128)
                }
            }
        }

        Method (_Q42, 0, NotSerialized)
        {
            Store (0x42, P80H)
            Store (0x02, HDAE)
            Store (0x80090320, HDHE)
            Notify (OVGA, 0x81)
            Notify (WMI1, 0x81)
            If (DHPD)
            {
                If (LEqual (HGAP, One))
                {
                    Store (0x02, HGER)
                    ^^SNC.SNNE (0x0128)
                }
            }
            Else
            {
                If (LEqual (HGAP, One))
                {
                    Store (0x03, HGER)
                    ^^SNC.SNNE (0x0128)
                }
            }
        }

        Field (ECF2, ByteAcc, Lock, Preserve)
        {
                    Offset (0x60), 
            HPWR,   1, 
            HLMX,   1, 
            HCMM,   1, 
            DLED,   1, 
            ILED,   1, 
                    Offset (0x61), 
            SWPS,   1, 
            HPOK,   1, 
            HHPD,   1, 
            DHPD,   1
        }

        Method (HSMP, 0, NotSerialized)
        {
            If (LAnd (LEqual (SWPS, Zero), LEqual (HGAP, One)))
            {
                Return (One)
            }

            If (LAnd (LEqual (SWPS, One), LEqual (HGAP, 0x02)))
            {
                Return (One)
            }

            Return (Zero)
        }
    }

    Scope (\)
    {
        Method (HGWH, 1, NotSerialized)
        {
            Store (Zero, AVIL)
            Store (Ones, POVR)
            Store (Zero, HGER)
            Store (Zero, ADAD)
            Store (One, SNGT)
            Store (Zero, HGDD)
            Store (Zero, HDHE)
            Store (0x05, HPI0)
            Store (Zero, HPI1)
            TRAP (TRTA, 0x1B)
            Name (_T_0, Zero)
            Store (Arg0, _T_0)
            If (LEqual (_T_0, 0x03))
            {
                Store (0x03, SSPS)
            }
            Else
            {
                If (LEqual (_T_0, 0x04))
                {
                    Store (0x04, SSPS)
                    Store (0x08, HPI0)
                    TRAP (TRTA, 0x1B)
                }
                Else
                {
                    If (LEqual (_T_0, 0x05))
                    {
                        Store (0x05, SSPS)
                        Store (0x04, HPI0)
                        If (LLess (OSYS, 0x07D6))
                        {
                            Store (One, HPI1)
                        }
                        Else
                        {
                            Store (Zero, HPI1)
                        }

                        TRAP (TRTA, 0x1B)
                        Store (0x08, HPI0)
                        TRAP (TRTA, 0x1B)
                        If (LEqual (TXTS, One))
                        {
                            Store (Zero, HPLE)
                        }
                        Else
                        {
                            Store (One, HPLE)
                        }
                    }
                }
            }
        }

        Method (HGSH, 1, NotSerialized)
        {
            Store (0x05, HPI0)
            Store (Arg0, HPI1)
            TRAP (TRTA, 0x1B)
            Name (_T_0, Zero)
            Store (Arg0, _T_0)
            If (LEqual (_T_0, 0x03)) {}
            Else
            {
                If (LEqual (_T_0, 0x04)) {}
                Else
                {
                    If (LEqual (_T_0, 0x05)) {}
                }
            }
        }

        Field (GPIO, ByteAcc, NoLock, Preserve)
        {
                    Offset (0x0F), 
                ,   3, 
            GP27,   1, 
            GP28,   1
        }
    }

    Scope (_SB.PCI0.LPC.SNC)
    {
        Method (HSC0, 0, Serialized)
        {
            Return (HGER)
        }

        Method (HSC1, 0, Serialized)
        {
            Store (Zero, Local0)
            If (AVIL)
            {
                Or (Local0, One, Local0)
            }

            If (^^H8EC.SWPS)
            {
                Or (Local0, Zero, Local0)
            }
            Else
            {
                Or (Local0, 0x02, Local0)
            }

            If (LEqual (HGAP, One))
            {
                Or (Local0, 0x04, Local0)
            }

            If (LEqual (HGAP, 0x02))
            {
                Or (Local0, Zero, Local0)
            }

            If (^^H8EC.HHPD)
            {
                Or (Local0, 0x08, Local0)
            }

            If (^^H8EC.DHPD)
            {
                Or (Local0, 0x10, Local0)
            }

            Return (Local0)
        }

        Method (HSC2, 0, Serialized)
        {
            Store (One, HPND)
            If (LEqual (HGAP, One))
            {
                If (LOr (^^H8EC.HHPD, ^^H8EC.DHPD))
                {
                    Store (0x03, HNCD)
                }
                Else
                {
                    Store (One, HNCD)
                }
            }
            Else
            {
                Store (One, HNCD)
            }

            Notify (OVGA, 0xD0)
            Notify (WMI1, 0xD0)
        }

        Method (HSC3, 1, Serialized)
        {
            And (Arg0, One, POVR)
            If (LNot (HOMP ()))
            {
                Store (One, HPND)
                Store (One, HNCD)
                Notify (OVGA, 0xD0)
                Notify (WMI1, 0xD0)
            }
        }

        Method (HSC4, 1, Serialized)
        {
            And (Arg0, One, Arg0)
            Store (0x04, HPI0)
            If (Arg0)
            {
                Store (One, HPI1)
            }
            Else
            {
                Store (Zero, HPI1)
            }

            TRAP (TRTA, 0x1B)
        }

        Method (HOMP, 0, Serialized)
        {
            If (LAnd (LEqual (POVR, Zero), LEqual (HGAP, 0x02)))
            {
                Return (One)
            }

            If (LAnd (LEqual (POVR, One), LEqual (HGAP, One)))
            {
                Return (One)
            }

            Return (Zero)
        }
    }
}


References