/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20090521
 *
 * Disassembly of DSDT.dat, Thu Dec  3 13:33:27 2009
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x000047C1 (18369)
 *     Revision         0x01 **** ACPI 1.0, no 64-bit math support
 *     Checksum         0x32
 *     OEM ID           "HP-CPC"
 *     OEM Table ID     "AWRDACPI"
 *     OEM Revision     0x00001000 (4096)
 *     Compiler ID      "MSFT"
 *     Compiler Version 0x0100000E (16777230)
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "HP-CPC", "AWRDACPI", 0x00001000)
{
    External (\_SB_.PCI0.LPC0.LNK1)
    External (\_SB_.PCI0.LPC0.LNK0)

    Scope (\_PR)
    {
        Processor (\_PR.CPU0, 0x00, 0x00004010, 0x06) {}
        Processor (\_PR.CPU1, 0x01, 0x00004010, 0x06) {}
    }

    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S1, Package (0x04)
    {
        0x01, 
        0x01, 
        0x01, 
        0x01
    })
    Name (\_S3, Package (0x04)
    {
        0x03, 
        0x03, 
        0x03, 
        0x03
    })
    Name (\_S4, Package (0x04)
    {
        0x04, 
        0x04, 
        0x04, 
        0x04
    })
    Name (\_S5, Package (0x04)
    {
        0x05, 
        0x05, 
        0x05, 
        0x05
    })
    OperationRegion (\DEBG, SystemIO, 0x80, 0x01)
    Field (\DEBG, ByteAcc, NoLock, Preserve)
    {
        DBG1,   8
    }

    OperationRegion (EXTM, SystemMemory, 0x000FF830, 0x12)
    Field (EXTM, WordAcc, NoLock, Preserve)
    {
        ROM1,   16, 
        RMS1,   16, 
        ROM2,   16, 
        RMS2,   16, 
        ROM3,   16, 
        RMS3,   16, 
        AMEM,   32, 
        AINF,   8
    }

    OperationRegion (ELCR, SystemIO, 0x04D0, 0x02)
    Field (ELCR, ByteAcc, NoLock, Preserve)
    {
        ELC1,   8, 
        ELC2,   8
    }

    OperationRegion (\P01, SystemIO, 0x4001, 0x01)
    Field (\P01, ByteAcc, NoLock, Preserve)
    {
        P1,     8
    }

    OperationRegion (\PR20, SystemIO, 0x4020, 0x04)
    Field (\PR20, DWordAcc, NoLock, Preserve)
    {
        P20,    32
    }

    OperationRegion (\GPE0, SystemIO, 0x00400020, 0x04)
    Field (\GPE0, DWordAcc, NoLock, Preserve)
    {
        GPE1,   32
    }

    Name (OSFX, 0x01)
    Name (OSFL, 0x01)
    Method (STRC, 2, NotSerialized)
    {
        If (LNotEqual (SizeOf (Arg0), SizeOf (Arg1)))
        {
            Return (0x00)
        }

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

        Return (One)
    }

    OperationRegion (RTCM, SystemIO, 0x70, 0x02)
    Field (RTCM, ByteAcc, NoLock, Preserve)
    {
        CMIN,   8, 
        CMDA,   8
    }

    IndexField (CMIN, CMDA, ByteAcc, NoLock, Preserve)
    {
                Offset (0x0F), 
        SHUT,   8
    }

    OperationRegion (INFO, SystemMemory, 0x000FF840, 0x01)
    Field (INFO, ByteAcc, NoLock, Preserve)
    {
        KBDI,   1, 
        RTCW,   1, 
        PS2F,   1, 
        IRFL,   2, 
        DISE,   1, 
        SSHU,   1
    }

    OperationRegion (BEEP, SystemIO, 0x61, 0x01)
    Field (BEEP, ByteAcc, NoLock, Preserve)
    {
        S1B,    8
    }

    OperationRegion (CONT, SystemIO, 0x40, 0x04)
    Field (CONT, ByteAcc, NoLock, Preserve)
    {
        CNT0,   8, 
        CNT1,   8, 
        CNT2,   8, 
        CTRL,   8
    }

    Method (SPKR, 1, NotSerialized)
    {
        Store (S1B, Local0)
        Store (0xB6, CTRL)
        Store (0x55, CNT2)
        Store (0x03, CNT2)
        Store (Arg0, Local2)
        While (LGreater (Local2, 0x00))
        {
            Or (S1B, 0x03, S1B)
            Store (0x5FFF, Local3)
            While (LGreater (Local3, 0x00))
            {
                Decrement (Local3)
            }

            And (S1B, 0xFC, S1B)
            Store (0x0EFF, Local3)
            While (LGreater (Local3, 0x00))
            {
                Decrement (Local3)
            }

            Decrement (Local2)
        }

        Store (Local0, S1B)
    }

    OperationRegion (ELKM, SystemMemory, 0x000FFFEA, 0x01)
    Field (ELKM, ByteAcc, NoLock, Preserve)
    {
            ,   1, 
        ELSO,   1, 
        ARSO,   1, 
            ,   1, 
            ,   1, 
            ,   1, 
            ,   1, 
                Offset (0x01)
    }

    Scope (\_SB)
    {
        Device (IELK)
        {
            Name (_HID, "AWY0001")
            Method (_STA, 0, NotSerialized)
            {
                If (LOr (ELSO, ARSO))
                {
                    Return (0x0F)
                }

                Return (0x00)
            }

            Method (SMOD, 1, NotSerialized)
            {
                Name (LDON, 0x03)
                Name (LDOF, 0x02)
                If (LNot (Arg0))
                {
                    If (ARSO)
                    {
                        \_SI._SST (0x03)
                    }
                }
                Else
                {
                    If (ARSO)
                    {
                        \_SI._SST (0x01)
                    }
                }

                Return (Zero)
            }
        }
    }

    Scope (\)
    {
        Name (PICF, 0x00)
        Method (_PIC, 1, NotSerialized)
        {
            Store (Arg0, PICF)
            If (Arg0)
            {
                \_SB.PCI0.LPC0.DSPI ()
            }
        }
    }

    Name (FLFG, 0x01)
    Method (\_PTS, 1, NotSerialized)
    {
        Store (0x00, RTCW)
        Or (Arg0, 0xF0, Local0)
        Store (Local0, DBG1)
        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x05)) {}
        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x03))
        {
            Store (0x00, FLFG)
        }
    }

    Method (\_WAK, 1, NotSerialized)
    {
        Store (0xFF, DBG1)
        If (LEqual (Arg0, 0x04))
        {
            If (LEqual (OSFL, 0x00))
            {
                Store (0x58, SMIP)
            }

            If (LEqual (OSFL, 0x02))
            {
                Store (0x57, SMIP)
            }

            If (LEqual (OSFL, 0x01))
            {
                Store (0x56, SMIP)
            }

            If (LEqual (OSFX, 0x03))
            {
                Store (0x59, SMIP)
            }
        }

        If (LEqual (OSFL, 0x01))
        {
            Notify (\_SB.PWRB, 0x02)
        }
        Else
        {
            If (LEqual (Arg0, 0x01))
            {
                If (LEqual (RTCW, Zero))
                {
                    Notify (\_SB.PWRB, 0x02)
                }
            }

            If (LEqual (Arg0, 0x03))
            {
                If (LEqual (RTCW, Zero))
                {
                    Notify (\_SB.PWRB, 0x02)
                }
            }
        }

        If (LEqual (Arg0, 0x04))
        {
            Notify (\_SB.PWRB, 0x02)
            If (PICF)
            {
                \_SB.PCI0.LPC0.DSPI ()
            }
        }
    }

    Scope (\_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x01))
            {
                LEDL ()
            }

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

    OperationRegion (TEMM, SystemMemory, 0x000FF810, 0x0C)
    Field (TEMM, WordAcc, NoLock, Preserve)
    {
        TP1H,   16, 
        TP1L,   16, 
        TP2H,   16, 
        TP2L,   16, 
        TRPC,   16, 
        SENF,   16
    }

    OperationRegion (TEM1, SystemMemory, 0x000FF81C, 0x10)
    Field (TEM1, ByteAcc, NoLock, Preserve)
    {
        TP3H,   8, 
        TP3L,   8, 
        TP4H,   8, 
        TP4L,   8, 
        TP5H,   8, 
        TP5L,   8, 
        TP6M,   8, 
        TP6H,   8, 
        TP6L,   8, 
        TP7T,   8, 
        TP7H,   8, 
        TP7L,   8, 
        TP8L,   8, 
        TP8M,   8, 
        TP8H,   8, 
        TP8T,   8
    }

    Name (TVAR, Buffer (0x05)
    {
        0x00, 0x00, 0x00, 0x00, 0x00
    })
    CreateByteField (TVAR, 0x00, PLCY)
    CreateWordField (TVAR, 0x01, CTOS)
    CreateWordField (TVAR, 0x03, CTHY)
    Name (TBUF, Buffer (0x04)
    {
        0x00, 0x00, 0x00, 0x00
    })
    CreateByteField (TBUF, 0x00, DB00)
    CreateByteField (TBUF, 0x01, DB01)
    CreateWordField (TBUF, 0x00, DW00)
    CreateWordField (TBUF, 0x02, DW01)
    CreateDWordField (TBUF, 0x00, DATD)
    Name (TSAD, 0x5C)
    Method (STOS, 3, NotSerialized)
    {
        WBYT (TSAD, 0x4F, Local0)
    }

    Method (STHY, 3, NotSerialized)
    {
        WBYT (TSAD, 0x4F, Arg1)
    }

    Method (RTMP, 0, NotSerialized)
    {
        Store (RBYT (TSAD, 0x25), Local0)
        Store (RBYT (TSAD, 0x27), Local0)
        If (LLess (Local0, 0x80))
        {
            Multiply (Local0, 0x0A, Local0)
            Add (Local0, 0x0AAC, Local0)
        }
        Else
        {
            Subtract (Local0, 0x80, Local0)
            Multiply (Local0, 0x0A, Local0)
            Subtract (0x0AAC, Local0, Local0)
        }

        If (LEqual (SSHU, 0x01))
        {
            Return (0x0C3C)
        }
        Else
        {
            Return (Local0)
        }
    }

    Method (SFAN, 1, NotSerialized)
    {
        And (SENF, 0x02, Local0)
        If (LEqual (Local0, Zero))
        {
            If (LEqual (Arg0, Zero))
            {
                FOFF ()
            }
            Else
            {
                FON ()
            }
        }
    }

    Method (FON, 0, NotSerialized)
    {
        WBYT (TSAD, 0x30, 0xFF)
        WBYT (TSAD, 0x31, 0xFF)
        WBYT (TSAD, 0x32, 0xFF)
    }

    Method (FOFF, 0, NotSerialized)
    {
        WBYT (TSAD, 0x30, 0x00)
        WBYT (TSAD, 0x31, 0x00)
        WBYT (TSAD, 0x32, 0x00)
    }

    Method (CSOU, 2, NotSerialized)
    {
        If (LLessEqual (Arg0, 0x7F))
        {
            If (LLessEqual (Arg1, 0x7F))
            {
                If (LGreaterEqual (Arg0, Arg1))
                {
                    Return (0x01)
                }
                Else
                {
                    Return (0x00)
                }
            }
            Else
            {
                Return (0x01)
            }
        }
        Else
        {
            If (LLessEqual (Arg1, 0x7F))
            {
                Return (0x00)
            }
            Else
            {
                If (LGreaterEqual (Arg0, Arg1))
                {
                    Return (0x01)
                }
                Else
                {
                    Return (0x00)
                }
            }
        }
    }

    Method (SMFN, 0, NotSerialized)
    {
        WBYT (TSAD, 0x82, Zero)
        Store (RBYT (TSAD, 0x7C), Local0)
        And (Local0, 0xFB, Local0)
        WBYT (TSAD, 0x7C, Local0)
        Store (RBYT (TSAD, 0x27), Local0)
        Store (RBYT (TSAD, 0x53), Local1)
        Store (RBYT (TSAD, 0x52), Local2)
        If (LGreaterEqual (Local0, Local1))
        {
            Store (0x01, DBG1)
            Store (0x7F, Local0)
            WBYT (TSAD, 0x53, Local0)
            Store (RBYT (TSAD, 0x40), Local0)
            Or (Local0, 0x08, Local0)
            WBYT (TSAD, 0x40, Local0)
            WBYT (TSAD, 0x52, TP3L)
            WBYT (TSAD, 0x82, 0x09)
        }
        Else
        {
            If (LLessEqual (Local0, Local2))
            {
                Store (0x02, DBG1)
                Store (0x81, Local0)
                WBYT (TSAD, 0x52, Local0)
                Store (RBYT (TSAD, 0x40), Local0)
                And (Local0, 0xF7, Local0)
                WBYT (TSAD, 0x40, Local0)
                WBYT (TSAD, 0x53, TP3H)
                WBYT (TSAD, 0x82, 0x09)
            }
        }

        Store (RBYT (TSAD, 0x41), Local0)
        While (LNotEqual (Local0, Zero))
        {
            And (RBYT (TSAD, 0x41), 0x40, Local0)
        }

        Store (RBYT (TSAD, 0x7C), Local0)
        Or (Local0, 0x04, Local0)
        WBYT (TSAD, 0x7C, Local0)
    }

    Mutex (PSMX, 0x00)
    OperationRegion (SM00, SystemIO, 0x0B00, 0x08)
    Field (SM00, ByteAcc, NoLock, Preserve)
    {
        HSTS,   8, 
        SLVS,   8, 
        CTLR,   8, 
        CMDR,   8, 
        ADDR,   8, 
        DAT0,   8, 
        DAT1,   8, 
        DAT2,   8
    }

    Method (CSMS, 0, NotSerialized)
    {
        And (HSTS, 0x02, Local0)
        While (LNotEqual (Local0, 0x00))
        {
            Stall (0x01)
            Store (HSTS, HSTS)
            And (HSTS, 0x18, Local0)
        }
    }

    Method (SWFS, 0, NotSerialized)
    {
        And (HSTS, 0x01, Local0)
        While (LEqual (Local0, 0x01))
        {
            Stall (0x01)
            And (HSTS, 0x01, Local0)
        }

        Store (0xFF, HSTS)
    }

    Method (WBYT, 3, NotSerialized)
    {
        Acquire (PSMX, 0xFFFF)
        CSMS ()
        Store (Arg2, DAT0)
        Store (Arg0, ADDR)
        Store (Arg1, CMDR)
        Store (0x48, CTLR)
        SWFS ()
        CSMS ()
        Release (PSMX)
    }

    Method (WWRD, 4, NotSerialized)
    {
        Acquire (PSMX, 0xFFFF)
        CSMS ()
        Store (Arg2, DAT0)
        Store (Arg3, DAT1)
        Store (Arg0, ADDR)
        Store (Arg1, CMDR)
        Store (0x4C, CTLR)
        SWFS ()
        CSMS ()
        Release (PSMX)
    }

    Method (RBYT, 2, NotSerialized)
    {
        CSMS ()
        Store (Arg1, CMDR)
        Or (Arg0, 0x01, ADDR)
        Store (0x48, CTLR)
        SWFS ()
        Return (DAT0)
        CSMS ()
    }

    Method (RWRD, 2, NotSerialized)
    {
        CSMS ()
        Or (Arg0, 0x01, ADDR)
        Store (Arg1, CMDR)
        Store (0x4C, CTLR)
        SWFS ()
        Store (DAT0, Local0)
        ShiftLeft (DAT1, 0x08, Local1)
        Or (Local0, Local1, Local2)
        Return (Local2)
        CSMS ()
    }

    Scope (\_TZ)
    {
        Device (FAN)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Method (_INI, 0, NotSerialized)
            {
                Store (TP1H, CTOS)
                Store (TP1L, CTHY)
            }
        }

        ThermalZone (THRM)
        {
            Name (_AL0, Package (0x01)
            {
                FAN
            })
            Method (_INI, 0, NotSerialized)
            {
            }

            Method (_AC0, 0, NotSerialized)
            {
                If (Or (PLCY, PLCY, Local7))
                {
                    Return (KELA (TP2H))
                }
                Else
                {
                    Return (KELA (TP1H))
                }
            }

            Name (_PSL, Package (0x01)
            {
                \_PR.CPU0
            })
            Name (_TSP, 0x3C)
            Name (_TC1, 0x04)
            Name (_TC2, 0x03)
            Method (_PSV, 0, NotSerialized)
            {
                If (Or (PLCY, PLCY, Local7))
                {
                    Return (KELA (TP1H))
                }
                Else
                {
                    Return (KELA (TP2H))
                }
            }

            Method (KELA, 1, NotSerialized)
            {
                If (LGreater (Arg0, 0x01F4))
                {
                    Return (Arg0)
                }
                Else
                {
                    Store (Arg0, Local1)
                    Multiply (Local1, 0x0A, Local1)
                    Add (Local1, 0x0AAC, Local1)
                    Return (Local1)
                }
            }

            Method (_CRT, 0, NotSerialized)
            {
                Return (TRPC)
            }

            Method (_TMP, 0, NotSerialized)
            {
                And (SENF, 0x01, Local6)
                If (LEqual (Local6, 0x01))
                {
                    Return (RTMP ())
                }
                Else
                {
                    Return (0x0B86)
                }
            }

            Method (_SCP, 1, NotSerialized)
            {
                If (Arg0)
                {
                    Store (One, PLCY)
                }
                Else
                {
                    Store (Zero, PLCY)
                }

                Notify (\_TZ.THRM, 0x81)
            }

            Method (STMP, 2, NotSerialized)
            {
                Store (Arg1, DW00)
                If (Arg0)
                {
                    STHY (DB00, DB01, DW00)
                }
                Else
                {
                    STOS (DB00, DB01, DW00)
                }
            }
        }
    }

    Scope (\_GPE)
    {
        Method (_L04, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.P2P, 0x02)
        }

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

        Method (_L0B, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB0, 0x02)
            Notify (\_SB.PCI0.USB1, 0x02)
            Notify (\_SB.PCI0.USB2, 0x02)
        }

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

        Method (_L09, 0, NotSerialized)
        {
            SMFN ()
            Store (0x09, Local0)
            Store (0x01, Local1)
            If (LGreater (Local0, 0x00))
            {
                ShiftLeft (Local1, Local0, Local1)
            }

            Store (Local1, GPE1)
        }
    }

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

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            OperationRegion (BAR1, PCI_Config, 0x14, 0x04)
            Field (BAR1, ByteAcc, NoLock, Preserve)
            {
                MMIO,   32
            }

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

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

            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    WordBusNumber (ResourceConsumer, MinNotFixed, MaxNotFixed, PosDecode,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x00FF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0100,             // Length
                        ,, )
                    IO (Decode16,
                        0x0CF8,             // Range Minimum
                        0x0CF8,             // Range Maximum
                        0x01,               // Alignment
                        0x08,               // Length
                        )
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x0CF7,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0CF8,             // Length
                        ,, , TypeStatic)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0D00,             // Range Minimum
                        0xFFFF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0xF300,             // Length
                        ,, , TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000A0000,         // Range Minimum
                        0x000BFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00020000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000C0000,         // Range Minimum
                        0x000DFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00020000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x00100000,         // Range Minimum
                        0xFEBFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0xFFF00000,         // Length
                        ,, _Y00, AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y00._MIN, TCMM)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y00._LEN, TOMM)
                Add (AMEM, 0x00010000, TCMM)
                Subtract (0xFEC00000, TCMM, TOMM)
                Add (TCMM, SMEM, TCMM)
                Add (TCMM, 0x00100000, TCMM)
                Return (BUF0)
            }

            Name (PICM, Package (0x20)
            {
                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0011FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKH, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0011FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKH, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0011FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKH, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0011FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKH, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKG, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKG, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    0x02, 
                    \_SB.PCI0.LPC0.LNKG, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    0x03, 
                    \_SB.PCI0.LPC0.LNKG, 
                    0x00
                }
            })
            Name (APIC, Package (0x1A)
            {
                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    0x00, 
                    0x12
                }, 

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

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

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

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

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

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

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x03, 
                    0x00, 
                    0x10
                }, 

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

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

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

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

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

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x01, 
                    0x00, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x02, 
                    0x00, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x03, 
                    0x00, 
                    0x12
                }, 

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

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x0011FFFF, 
                    0x00, 
                    0x00, 
                    0x17
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    0x00, 
                    0x00, 
                    0x16
                }
            })
            Method (_PRT, 0, NotSerialized)
            {
                If (LNot (PICF))
                {
                    Return (PICM)
                }
                Else
                {
                    Return (APIC)
                }
            }

            Device (SMB0)
            {
                Name (_ADR, 0x00140000)
                OperationRegion (SMCF, PCI_Config, 0x90, 0x02)
                Field (SMCF, WordAcc, NoLock, Preserve)
                {
                    SB1,    16
                }

                Method (SMBB, 0, NotSerialized)
                {
                    And (SB1, 0xFFFE, Local0)
                    Return (Local0)
                }
            }

            Device (USB0)
            {
                Name (_ADR, 0x00130000)
                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x03
                })
                Name (_PSW, 0x01)
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x00130001)
                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x03
                })
                Name (_PSW, 0x01)
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x00130002)
                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x03
                })
                Name (_PSW, 0x01)
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

            Device (AUDO)
            {
                Name (_ADR, 0x00140005)
                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x03
                })
            }

            Device (MODM)
            {
                Name (_ADR, 0x00140006)
                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x03
                })
            }

            Device (LPC0)
            {
                Name (_ADR, 0x00140003)
                Device (PMIO)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x03)
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IO (Decode16,
                                0x0228,             // Range Minimum
                                0x0228,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x040B,             // Range Minimum
                                0x040B,             // Range Maximum
                                0x01,               // Alignment
                                0x01,               // Length
                                )
                            IO (Decode16,
                                0x04D6,             // Range Minimum
                                0x04D6,             // Range Maximum
                                0x01,               // Alignment
                                0x01,               // Length
                                )
                            IO (Decode16,
                                0x0C00,             // Range Minimum
                                0x0C00,             // Range Maximum
                                0x01,               // Alignment
                                0x02,               // Length
                                )
                            IO (Decode16,
                                0x0C14,             // Range Minimum
                                0x0C14,             // Range Maximum
                                0x01,               // Alignment
                                0x01,               // Length
                                )
                            IO (Decode16,
                                0x0C50,             // Range Minimum
                                0x0C50,             // Range Maximum
                                0x01,               // Alignment
                                0x03,               // Length
                                )
                            IO (Decode16,
                                0x0C6C,             // Range Minimum
                                0x0C6C,             // Range Maximum
                                0x01,               // Alignment
                                0x02,               // Length
                                )
                            IO (Decode16,
                                0x0C6F,             // Range Minimum
                                0x0C6F,             // Range Maximum
                                0x01,               // Alignment
                                0x01,               // Length
                                )
                            IO (Decode16,
                                0x0CD4,             // Range Minimum
                                0x0CD4,             // Range Maximum
                                0x01,               // Alignment
                                0x0C,               // Length
                                )
                            IO (Decode16,
                                0x4000,             // Range Minimum
                                0x4000,             // Range Maximum
                                0x01,               // Alignment
                                0xFF,               // Length
                                )
                            IO (Decode16,
                                0x4210,             // Range Minimum
                                0x4210,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                                0x00000000,         // Granularity
                                0xE0000000,         // Range Minimum
                                0xE0000000,         // Range Maximum
                                0x00000000,         // Translation Offset
                                0x00000000,         // Length
                                ,, _Y01, AddressRangeMemory, TypeStatic)
                            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                                0x00000000,         // Granularity
                                0xFEE00400,         // Range Minimum
                                0xFEE00FFF,         // Range Maximum
                                0x00000000,         // Translation Offset
                                0x00000BFF,         // Length
                                ,, , AddressRangeMemory, TypeStatic)
                        })
                        CreateDWordField (BUF0, \_SB.PCI0.LPC0.PMIO._CRS._Y01._MIN, BARX)
                        CreateDWordField (BUF0, \_SB.PCI0.LPC0.PMIO._CRS._Y01._LEN, GALN)
                        CreateDWordField (BUF0, \_SB.PCI0.LPC0.PMIO._CRS._Y01._MAX, GAMX)
                        Store (0x1000, GALN)
                        Store (\_SB.PCI0.MMIO, Local0)
                        And (Local0, 0xFFFFFFF0, BARX)
                        Add (Local0, GALN, GAMX)
                        Subtract (GAMX, 0x01, GAMX)
                        Return (BUF0)
                    }
                }

                OperationRegion (PIRQ, SystemIO, 0x0C00, 0x02)
                Field (PIRQ, ByteAcc, NoLock, Preserve)
                {
                    PIID,   8, 
                    PIDA,   8
                }

                Name (IPRS, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {3,4,5,6,7,10,11}
                })
                IndexField (PIID, PIDA, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8, 
                    PIRS,   8, 
                            Offset (0x09), 
                    PIRE,   8, 
                    PIRF,   8, 
                    PIRG,   8, 
                    PIRH,   8
                }

                Method (DSPI, 0, NotSerialized)
                {
                    Store (0x00, PIRA)
                    Store (0x00, PIRB)
                    Store (0x00, PIRC)
                    Store (0x00, PIRD)
                }

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRA, IRQ0)
                        Return (Local0)
                    }

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

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRB, IRQ0)
                        Return (Local0)
                    }

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

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRC, IRQ0)
                        Return (Local0)
                    }

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

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRD, IRQ0)
                        Return (Local0)
                    }

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

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRE, IRQ0)
                        Return (Local0)
                    }

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

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRF, IRQ0)
                        Return (Local0)
                    }

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

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRG, IRQ0)
                        Return (Local0)
                    }

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

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

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

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRH, IRQ0)
                        Return (Local0)
                    }

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

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

                Device (DMA1)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        DMA (Compatibility, BusMaster, Transfer8, )
                            {4}
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0080,             // Range Minimum
                            0x0080,             // Range Maximum
                            0x01,               // Alignment
                            0x11,               // Length
                            )
                        IO (Decode16,
                            0x0094,             // Range Minimum
                            0x0094,             // Range Maximum
                            0x01,               // Alignment
                            0x0C,               // Length
                            )
                        IO (Decode16,
                            0x00C0,             // Range Minimum
                            0x00C0,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                    })
                }

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

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

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

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

            Device (P2P)
            {
                Name (_ADR, 0x00140004)
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Method (_PRW, 0, NotSerialized)
                {
                    Return (Package (0x02)
                    {
                        0x04, 
                        0x05
                    })
                }

                Name (PICM, Package (0x1C)
                {
                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKE, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKF, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNK0, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKF, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNK0, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKE, 
                        0x00
                    }
                })
                Name (APIC, Package (0x1C)
                {
                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x00, 
                        0x00, 
                        0x10
                    }, 

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

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

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

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

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

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

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x03, 
                        0x00, 
                        0x10
                    }, 

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

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

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

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

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

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x01, 
                        0x00, 
                        0x10
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x02, 
                        0x00, 
                        0x11
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x03, 
                        0x00, 
                        0x12
                    }, 

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

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

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

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

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

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x02, 
                        0x00, 
                        0x16
                    }, 

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

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

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

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

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x03, 
                        0x00, 
                        0x14
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (PICM)
                    }
                    Else
                    {
                        Return (APIC)
                    }
                }
            }

            Device (IDE)
            {
                Name (_ADR, 0x00140001)
                Name (UDMT, Package (0x08)
                {
                    0x78, 
                    0x5A, 
                    0x3C, 
                    0x2D, 
                    0x1E, 
                    0x14, 
                    0x0F, 
                    0x00
                })
                Name (PIOT, Package (0x06)
                {
                    0x0258, 
                    0x0186, 
                    0x010E, 
                    0xB4, 
                    0x78, 
                    0x00
                })
                Name (PITR, Package (0x06)
                {
                    0x99, 
                    0x47, 
                    0x34, 
                    0x22, 
                    0x20, 
                    0x99
                })
                Name (MDMT, Package (0x04)
                {
                    0x01E0, 
                    0x96, 
                    0x78, 
                    0x00
                })
                Name (MDTR, Package (0x04)
                {
                    0x77, 
                    0x21, 
                    0x20, 
                    0xFF
                })
                OperationRegion (IDE, PCI_Config, 0x40, 0x20)
                Field (IDE, AnyAcc, NoLock, Preserve)
                {
                    PPIT,   16, 
                    SPIT,   16, 
                    PMDT,   16, 
                    SMDT,   16, 
                    PPIC,   8, 
                    SPIC,   8, 
                    PPIM,   8, 
                    SPIM,   8, 
                            Offset (0x14), 
                    PUDC,   2, 
                    SUDC,   2, 
                            Offset (0x16), 
                    PUDM,   8, 
                    SUDM,   8
                }

                Method (GETT, 1, NotSerialized)
                {
                    Store (And (Arg0, 0x0F), Local0)
                    Store (ShiftRight (Arg0, 0x04), Local1)
                    Return (Multiply (0x1E, Add (Add (Local0, 0x01), Add (Local1, 
                        0x01))))
                }

                Method (GTM, 1, NotSerialized)
                {
                    If (LNot (FLFG))
                    {
                        HDSF ()
                        Store (0x01, FLFG)
                    }

                    CreateByteField (Arg0, 0x00, PIT1)
                    CreateByteField (Arg0, 0x01, PIT0)
                    CreateByteField (Arg0, 0x02, MDT1)
                    CreateByteField (Arg0, 0x03, MDT0)
                    CreateByteField (Arg0, 0x04, PICX)
                    CreateByteField (Arg0, 0x05, UDCX)
                    CreateByteField (Arg0, 0x06, UDMX)
                    Name (BUF, Buffer (0x14)
                    {
                        /* 0000 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x00, 0x00, 0x00, 0x00
                    })
                    CreateDWordField (BUF, 0x00, PIO0)
                    CreateDWordField (BUF, 0x04, DMA0)
                    CreateDWordField (BUF, 0x08, PIO1)
                    CreateDWordField (BUF, 0x0C, DMA1)
                    CreateDWordField (BUF, 0x10, FLAG)
                    If (And (PICX, 0x01))
                    {
                        Return (BUF)
                    }

                    Store (GETT (PIT0), PIO0)
                    Store (GETT (PIT1), PIO1)
                    If (And (UDCX, 0x01))
                    {
                        Or (FLAG, 0x01, FLAG)
                        Store (DerefOf (Index (^UDMT, And (UDMX, 0x0F))), DMA0)
                    }
                    Else
                    {
                        Store (GETT (MDT0), DMA0)
                    }

                    If (And (UDCX, 0x02))
                    {
                        Or (FLAG, 0x04, FLAG)
                        Store (DerefOf (Index (^UDMT, ShiftRight (UDMX, 0x04))), DMA1)
                    }
                    Else
                    {
                        Store (GETT (MDT1), DMA1)
                    }

                    Or (FLAG, 0x1A, FLAG)
                    Return (BUF)
                }

                Method (STM, 3, NotSerialized)
                {
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Name (BUF, Buffer (0x07)
                    {
                        0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                    })
                    CreateByteField (BUF, 0x00, PIT1)
                    CreateByteField (BUF, 0x01, PIT0)
                    CreateByteField (BUF, 0x02, MDT1)
                    CreateByteField (BUF, 0x03, MDT0)
                    CreateByteField (BUF, 0x04, PIMX)
                    CreateByteField (BUF, 0x05, UDCX)
                    CreateByteField (BUF, 0x06, UDMX)
                    Store (Match (^PIOT, MLE, PIO0, MTR, 0x00, 0x00), Local0)
                    Divide (Local0, 0x05, Local0)
                    Store (Match (^PIOT, MLE, PIO1, MTR, 0x00, 0x00), Local1)
                    Divide (Local1, 0x05, Local1)
                    Store (Or (ShiftLeft (Local1, 0x04), Local0), PIMX)
                    Store (DerefOf (Index (^PITR, Local0)), PIT0)
                    Store (DerefOf (Index (^PITR, Local1)), PIT1)
                    If (And (FLAG, 0x01))
                    {
                        Store (Match (^UDMT, MLE, DMA0, MTR, 0x00, 0x00), Local0)
                        Divide (Local0, 0x06, Local0)
                        Or (UDMX, Local0, UDMX)
                        Or (UDCX, 0x01, UDCX)
                    }
                    Else
                    {
                        If (LNotEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (Match (^MDMT, MLE, DMA0, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^MDTR, Local0)), MDT0)
                        }
                    }

                    If (And (FLAG, 0x04))
                    {
                        Store (Match (^UDMT, MLE, DMA1, MTR, 0x00, 0x00), Local0)
                        Divide (Local0, 0x06, Local0)
                        Or (UDMX, ShiftLeft (Local0, 0x04), UDMX)
                        Or (UDCX, 0x02, UDCX)
                    }
                    Else
                    {
                        If (LNotEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (Match (^MDMT, MLE, DMA1, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^MDTR, Local0)), MDT1)
                        }
                    }

                    Return (BUF)
                }

                Method (GTF, 2, NotSerialized)
                {
                    CreateByteField (Arg1, 0x00, MDT1)
                    CreateByteField (Arg1, 0x01, MDT0)
                    CreateByteField (Arg1, 0x02, PIMX)
                    CreateByteField (Arg1, 0x03, UDCX)
                    CreateByteField (Arg1, 0x04, UDMX)
                    If (LEqual (Arg0, 0xA0))
                    {
                        Store (And (PIMX, 0x0F), Local0)
                        Store (MDT0, Local1)
                        And (UDCX, 0x01, Local2)
                        Store (And (UDMX, 0x0F), Local3)
                    }
                    Else
                    {
                        Store (ShiftRight (PIMX, 0x04), Local0)
                        Store (MDT1, Local1)
                        And (UDCX, 0x02, Local2)
                        Store (ShiftRight (UDMX, 0x04), Local3)
                    }

                    Name (BUF, Buffer (0x0E)
                    {
                        /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF, 0x03, 
                        /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF
                    })
                    CreateByteField (BUF, 0x01, PMOD)
                    CreateByteField (BUF, 0x08, DMOD)
                    CreateByteField (BUF, 0x05, CMDA)
                    CreateByteField (BUF, 0x0C, CMDB)
                    Store (Arg0, CMDA)
                    Store (Arg0, CMDB)
                    Or (Local0, 0x08, PMOD)
                    If (Local2)
                    {
                        Or (Local3, 0x40, DMOD)
                    }
                    Else
                    {
                        Store (Match (^MDMT, MLE, GETT (Local1), MTR, 0x00, 0x00), Local4)
                        If (LLess (Local4, 0x03))
                        {
                            Or (0x20, Local4, DMOD)
                        }
                    }

                    Return (BUF)
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIC)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (^^PPIT, VPIT)
                        Store (^^PMDT, VMDT)
                        Store (^^PPIC, VPIC)
                        Store (^^PUDC, VUDC)
                        Store (^^PUDM, VUDM)
                        Return (GTM (BUF))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIM)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (STM (Arg0, Arg1, Arg2), BUF)
                        Store (VPIT, ^^PPIT)
                        Store (VMDT, ^^PMDT)
                        Store (VPIM, ^^PPIM)
                        Store (VUDC, ^^PUDC)
                        Store (VUDM, ^^PUDM)
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, 0x00, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (^^^PMDT, VMDT)
                            Store (^^^PPIM, VPIM)
                            Store (^^^PUDC, VUDC)
                            Store (^^^PUDM, VUDM)
                            Return (GTF (0xA0, BUF))
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, 0x00, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (^^^PMDT, VMDT)
                            Store (^^^PPIM, VPIM)
                            Store (^^^PUDC, VUDC)
                            Store (^^^PUDM, VUDM)
                            Return (GTF (0xB0, BUF))
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIC)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (^^SPIT, VPIT)
                        Store (^^SMDT, VMDT)
                        Store (^^SPIC, VPIC)
                        Store (^^SUDC, VUDC)
                        Store (^^SUDM, VUDM)
                        Return (GTM (BUF))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIM)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (STM (Arg0, Arg1, Arg2), BUF)
                        Store (VPIT, ^^SPIT)
                        Store (VMDT, ^^SMDT)
                        Store (VPIM, ^^SPIM)
                        Store (VUDC, ^^SUDC)
                        Store (VUDM, ^^SUDM)
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, 0x00, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (^^^SMDT, VMDT)
                            Store (^^^SPIM, VPIM)
                            Store (^^^SUDC, VUDC)
                            Store (^^^SUDM, VUDM)
                            Return (GTF (0xA0, BUF))
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, 0x00, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (^^^SMDT, VMDT)
                            Store (^^^SPIM, VPIM)
                            Store (^^^SUDC, VUDC)
                            Store (^^^SUDM, VUDM)
                            Return (GTF (0xB0, BUF))
                        }
                    }
                }
            }

            Mutex (FLMX, 0x00)
            OperationRegion (SECF, SystemMemory, 0x000F97E0, 0x01)
            Field (SECF, WordAcc, NoLock, Preserve)
            {
                SCFN,   8
            }

            OperationRegion (HFAD, SystemMemory, 0x000FFE8C, 0x04)
            Field (HFAD, WordAcc, NoLock, Preserve)
            {
                IDET,   16, 
                FDPE,   16
            }

            Method (GIDT, 0, NotSerialized)
            {
                Add (0x000F0000, IDET, Local0)
                Return (Local0)
            }

            Method (GFPT, 0, NotSerialized)
            {
                Add (0x000F0000, FDPE, Local0)
                Return (Local0)
            }

            OperationRegion (IDTT, SystemMemory, GIDT (), 0x08)
            Field (IDTT, ByteAcc, NoLock, Preserve)
            {
                IDT0,   8, 
                IDT1,   8, 
                IDT2,   8, 
                IDT3,   8, 
                IDT4,   8, 
                IDT5,   8, 
                IDT6,   8, 
                IDT7,   8
            }

            OperationRegion (FDPT, SystemMemory, GFPT (), 0x80)
            Field (FDPT, WordAcc, NoLock, Preserve)
            {
                FTP0,   16, 
                FTD0,   112, 
                FTP1,   16, 
                FTD1,   112, 
                FTP2,   16, 
                FTD2,   112, 
                FTP3,   16, 
                FTD3,   112, 
                FTP4,   16, 
                FTD4,   112, 
                FTP5,   16, 
                FTD5,   112, 
                FTP6,   16, 
                FTD6,   112, 
                FTP7,   16, 
                FTD7,   112
            }

            Method (PPS0, 0, NotSerialized)
            {
                Return (FTP0)
            }

            Method (PPS1, 0, NotSerialized)
            {
                Return (FTP1)
            }

            Method (PPS2, 0, NotSerialized)
            {
                Return (FTP2)
            }

            Method (PPS3, 0, NotSerialized)
            {
                Return (FTP3)
            }

            OperationRegion (HDP0, SystemIO, PPS0 (), 0x08)
            Field (HDP0, ByteAcc, NoLock, Preserve)
            {
                P1F0,   8, 
                P1F1,   8, 
                P1F2,   8, 
                P1F3,   8, 
                P1F4,   8, 
                P1F5,   8, 
                P1F6,   8, 
                P1F7,   8
            }

            OperationRegion (HDP1, SystemIO, PPS1 (), 0x08)
            Field (HDP1, ByteAcc, NoLock, Preserve)
            {
                P170,   8, 
                P171,   8, 
                P172,   8, 
                P173,   8, 
                P174,   8, 
                P175,   8, 
                P176,   8, 
                P177,   8
            }

            OperationRegion (HDP2, SystemIO, PPS2 (), 0x08)
            Field (HDP2, ByteAcc, NoLock, Preserve)
            {
                S1F0,   8, 
                S1F1,   8, 
                S1F2,   8, 
                S1F3,   8, 
                S1F4,   8, 
                S1F5,   8, 
                S1F6,   8, 
                S1F7,   8
            }

            OperationRegion (HDP3, SystemIO, PPS3 (), 0x08)
            Field (HDP3, ByteAcc, NoLock, Preserve)
            {
                S170,   8, 
                S171,   8, 
                S172,   8, 
                S173,   8, 
                S174,   8, 
                S175,   8, 
                S176,   8, 
                S177,   8
            }

            Method (SPS0, 0, NotSerialized)
            {
                Return (FTP4)
            }

            Method (SPS1, 0, NotSerialized)
            {
                Return (FTP5)
            }

            Method (SPS2, 0, NotSerialized)
            {
                Return (FTP6)
            }

            Method (SPS3, 0, NotSerialized)
            {
                Return (FTP7)
            }

            OperationRegion (SDP0, SystemIO, SPS0 (), 0x08)
            Field (SDP0, ByteAcc, NoLock, Preserve)
            {
                SPA0,   8, 
                SPA1,   8, 
                SPA2,   8, 
                SPA3,   8, 
                SPA4,   8, 
                SPA5,   8, 
                SPA6,   8, 
                SPA7,   8
            }

            OperationRegion (SDP1, SystemIO, SPS1 (), 0x08)
            Field (SDP1, ByteAcc, NoLock, Preserve)
            {
                SPB0,   8, 
                SPB1,   8, 
                SPB2,   8, 
                SPB3,   8, 
                SPB4,   8, 
                SPB5,   8, 
                SPB6,   8, 
                SPB7,   8
            }

            OperationRegion (SDP3, SystemIO, SPS2 (), 0x08)
            Field (SDP3, ByteAcc, NoLock, Preserve)
            {
                SPC0,   8, 
                SPC1,   8, 
                SPC2,   8, 
                SPC3,   8, 
                SPC4,   8, 
                SPC5,   8, 
                SPC6,   8, 
                SPC7,   8
            }

            OperationRegion (SDP4, SystemIO, SPS3 (), 0x08)
            Field (SDP4, ByteAcc, NoLock, Preserve)
            {
                SPD0,   8, 
                SPD1,   8, 
                SPD2,   8, 
                SPD3,   8, 
                SPD4,   8, 
                SPD5,   8, 
                SPD6,   8, 
                SPD7,   8
            }

            Method (OPHP, 3, NotSerialized)
            {
                If (LEqual (Arg2, 0x00))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, P1F0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, P1F1)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, P1F2)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, P1F3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, P1F4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, P1F5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, P1F6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, P1F7)
                    }
                }

                If (LEqual (Arg2, 0x01))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, P170)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, P171)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, P172)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, P173)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, P174)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, P175)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, P176)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, P177)
                    }
                }

                If (LEqual (Arg2, 0x02))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, S1F0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, S1F1)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, S1F2)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, S1F3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, S1F4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, S1F5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, S1F6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, S1F7)
                    }
                }

                If (LEqual (Arg2, 0x03))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, S170)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, S171)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, S172)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, S173)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, S174)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, S175)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, S176)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, S177)
                    }
                }

                If (LEqual (Arg2, 0x04))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, SPA0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, SPA1)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, SPA2)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, SPA3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, SPA4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, SPA5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, SPA6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, SPA7)
                    }
                }

                If (LEqual (Arg2, 0x05))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, SPB0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, SPB1)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, SPB2)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, SPB3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, SPB4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, SPB5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, SPB6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, SPB7)
                    }
                }

                If (LEqual (Arg2, 0x06))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, SPC0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, SPC1)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, SPC2)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, SPC3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, SPC4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, SPC5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, SPC6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, SPC7)
                    }
                }

                If (LEqual (Arg2, 0x07))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, SPD0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, SPD1)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, SPD2)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Store (Arg1, SPD3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Store (Arg1, SPD4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Store (Arg1, SPD5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Store (Arg1, SPD6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Store (Arg1, SPD7)
                    }
                }
            }

            Method (IPHP, 2, NotSerialized)
            {
                If (LEqual (Arg1, 0x00))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (P1F0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (P1F1)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (P1F3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (P1F4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (P1F5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (P1F6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (P1F7)
                    }
                }

                If (LEqual (Arg1, 0x01))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (P170)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (P171)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (P173)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (P174)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (P175)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (P176)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (P177)
                    }
                }

                If (LEqual (Arg1, 0x02))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (S1F0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (S1F1)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (S1F3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (S1F4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (S1F5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (S1F6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (S1F7)
                    }
                }

                If (LEqual (Arg1, 0x03))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (S170)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (S171)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (S173)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (S174)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (S175)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (S176)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (S177)
                    }
                }

                If (LEqual (Arg1, 0x04))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (SPA0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (SPA1)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (SPA3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (SPA4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (SPA5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (SPA6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (SPA7)
                    }
                }

                If (LEqual (Arg1, 0x05))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (SPB0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (SPB1)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (SPB3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (SPB4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (SPB5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (SPB6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (SPB7)
                    }
                }

                If (LEqual (Arg1, 0x06))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (SPC0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (SPC1)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (SPC3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (SPC4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (SPC5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (SPC6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (SPC7)
                    }
                }

                If (LEqual (Arg1, 0x07))
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (SPD0)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (SPD1)
                    }

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

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (SPD3)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (SPD4)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (SPD5)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (SPD6)
                    }

                    If (LEqual (Arg0, 0x07))
                    {
                        Return (SPD7)
                    }
                }
            }

            Method (HDSF, 0, NotSerialized)
            {
                Acquire (FLMX, 0xFFFF)
                Store (0x00, Local1)
                Multiply (0x02, 0x04, Local0)
                While (Local0)
                {
                    If (LEqual (HGDT (Local1), 0x01))
                    {
                        ShiftLeft (0x01, Local1, Local2)
                        And (Local2, SCFN, Local2)
                        If (LNotEqual (Local2, 0x00))
                        {
                            Divide (Local1, 0x02, Local3, Local4)
                            If (LEqual (Local3, 0x01))
                            {
                                Store (0xB0, Local3)
                            }
                            Else
                            {
                                Store (0xA0, Local3)
                            }

                            Store (0x01, Local5)
                            While (Local5)
                            {
                                If (LEqual (WSSC (Local1, 0x80, 0x1000), 0x00))
                                {
                                    OPHP (0x06, Local3, Local1)
                                    If (LEqual (WSSC (Local1, 0x80, 0x1000), 0x00))
                                    {
                                        If (LEqual (IPHP (0x06, Local1), Local3))
                                        {
                                            If (LEqual (WSSC (Local1, 0x80, 0x1000), 0x00))
                                            {
                                                OPHP (0x07, 0xF5, Local1)
                                                If (LEqual (WSSC (Local1, 0x80, 0x1000), 0x00)) {}
                                                Store (0x00, Local5)
                                            }
                                            Else
                                            {
                                                Store (0x00, Local5)
                                            }
                                        }
                                    }
                                    Else
                                    {
                                        Store (0x00, Local5)
                                    }
                                }
                                Else
                                {
                                    Store (0x00, Local5)
                                }
                            }
                        }
                    }

                    Decrement (Local0)
                    Increment (Local1)
                }

                Release (FLMX)
            }

            Method (HGDT, 1, NotSerialized)
            {
                If (LEqual (Arg0, 0x00))
                {
                    Return (IDT0)
                }

                If (LEqual (Arg0, 0x01))
                {
                    Return (IDT1)
                }

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

                If (LEqual (Arg0, 0x03))
                {
                    Return (IDT3)
                }

                If (LEqual (Arg0, 0x04))
                {
                    Return (IDT4)
                }

                If (LEqual (Arg0, 0x05))
                {
                    Return (IDT5)
                }

                If (LEqual (Arg0, 0x06))
                {
                    Return (IDT6)
                }

                If (LEqual (Arg0, 0x07))
                {
                    Return (IDT7)
                }
            }

            Method (WSSC, 3, NotSerialized)
            {
                Store (Arg2, Local0)
                While (Local0)
                {
                    And (IPHP (0x07, Arg0), Arg1, Local2)
                    Sleep (0x01)
                    If (LEqual (Local2, 0x00))
                    {
                        Return (0x00)
                    }

                    Decrement (Local0)
                }

                Return (0x01)
            }

            Scope (\)
            {
                Method (DISD, 1, NotSerialized)
                {
                }

                Method (CKIO, 2, NotSerialized)
                {
                }

                Method (SLDM, 2, NotSerialized)
                {
                }
            }

            Scope (\)
            {
                OperationRegion (\SCPP, SystemIO, 0xB0, 0x01)
                Field (\SCPP, ByteAcc, NoLock, Preserve)
                {
                    SMIP,   8
                }
            }

            Method (\_SB.PCI0._INI, 0, NotSerialized)
            {
                If (STRC (\_OS, "Microsoft Windows"))
                {
                    Store (0x56, SMIP)
                }
                Else
                {
                    If (STRC (\_OS, "Microsoft Windows NT"))
                    {
                        If (CondRefOf (\_OSI, Local0))
                        {
                            If (\_OSI ("Windows 2001"))
                            {
                                Store (0x59, SMIP)
                                Store (0x00, OSFL)
                                Store (0x03, OSFX)
                            }
                        }
                        Else
                        {
                            Store (0x58, SMIP)
                            Store (0x00, OSFX)
                            Store (0x00, OSFL)
                        }
                    }
                    Else
                    {
                        Store (0x57, SMIP)
                        Store (0x02, OSFX)
                        Store (0x02, OSFL)
                    }
                }
            }

            Scope (\)
            {
                Method (OSTP, 0, NotSerialized)
                {
                    If (LEqual (OSFX, 0x01))
                    {
                        Store (0x56, SMIP)
                    }

                    If (LEqual (OSFX, 0x02))
                    {
                        Store (0x57, SMIP)
                    }

                    If (LEqual (OSFX, 0x00))
                    {
                        Store (0x58, SMIP)
                    }

                    If (LEqual (OSFX, 0x03))
                    {
                        Store (0x59, SMIP)
                    }
                }
            }

            Device (SYSR)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x01)
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0010,             // Range Minimum
                        0x0010,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x0022,             // Range Minimum
                        0x0022,             // Range Maximum
                        0x01,               // Alignment
                        0x1E,               // Length
                        )
                    IO (Decode16,
                        0x0044,             // Range Minimum
                        0x0044,             // Range Maximum
                        0x01,               // Alignment
                        0x1C,               // Length
                        )
                    IO (Decode16,
                        0x0062,             // Range Minimum
                        0x0062,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0065,             // Range Minimum
                        0x0065,             // Range Maximum
                        0x01,               // Alignment
                        0x0B,               // Length
                        )
                    IO (Decode16,
                        0x0074,             // Range Minimum
                        0x0074,             // Range Maximum
                        0x01,               // Alignment
                        0x0C,               // Length
                        )
                    IO (Decode16,
                        0x0091,             // Range Minimum
                        0x0091,             // Range Maximum
                        0x01,               // Alignment
                        0x03,               // Length
                        )
                    IO (Decode16,
                        0x00A2,             // Range Minimum
                        0x00A2,             // Range Maximum
                        0x01,               // Alignment
                        0x1E,               // Length
                        )
                    IO (Decode16,
                        0x00E0,             // Range Minimum
                        0x00E0,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x04D0,             // Range Minimum
                        0x04D0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0800,             // Range Minimum
                        0x0800,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                })
            }

            Scope (\)
            {
                OperationRegion (SMGP, SystemIO, 0x0800, 0x80)
                Field (SMGP, ByteAcc, NoLock, Preserve)
                {
                    P3SG,   8, 
                    P5SG,   8, 
                    PM3E,   8, 
                    PM5E,   8, 
                    P3S1,   8, 
                    P3S3,   8, 
                    P3S5,   8, 
                    P3S6,   8, 
                    P3E1,   8, 
                    P3E3,   8, 
                    P3E5,   8, 
                    P3E6,   8, 
                    P5S1,   8, 
                    P5S3,   8, 
                    P5S5,   8, 
                    P5S6,   8, 
                    P5E1,   8, 
                    P5E3,   8, 
                    P5E5,   8, 
                    P5E6,   8, 
                    SMS1,   8, 
                    SMS2,   8, 
                    SMS3,   8, 
                    SMS4,   8, 
                    SME1,   8, 
                    SME2,   8, 
                    SME3,   8, 
                    SME4,   8, 
                    MSST,   8, 
                            Offset (0x1E), 
                    FDC,    8, 
                    FDRS,   8, 
                    UAF1,   8, 
                    UAF2,   8, 
                    DDR,    8, 
                    SG10,   8, 
                    SG11,   8, 
                    SG12,   8, 
                    SG13,   8, 
                    SG14,   8, 
                            Offset (0x29), 
                            Offset (0x2A), 
                            Offset (0x2B), 
                            Offset (0x2C), 
                    SG21,   8, 
                    SG22,   8, 
                            Offset (0x2F), 
                            Offset (0x30), 
                            Offset (0x31), 
                            Offset (0x32), 
                    SG27,   8, 
                            Offset (0x34), 
                            Offset (0x35), 
                    SG32,   8, 
                    SG33,   8, 
                            Offset (0x38), 
                            Offset (0x39), 
                    SG36,   8, 
                    SG37,   8, 
                    SG40,   8, 
                            Offset (0x3D), 
                    SG42,   8, 
                    SG43,   8, 
                    SG50,   8, 
                    SG51,   8, 
                    SG52,   8, 
                    SG53,   8, 
                    SG54,   8, 
                    SG55,   8, 
                    SG56,   8, 
                    SG57,   8, 
                    SG60,   8, 
                    SG61,   8, 
                    PWRC,   8, 
                    SLP3,   8, 
                    SG01,   8, 
                    SG02,   8, 
                    SG03,   8, 
                    SG04,   8, 
                    SG05,   8, 
                    SG06,   8, 
                            Offset (0x52), 
                            Offset (0x53), 
                    SLPP,   8, 
                            Offset (0x55), 
                            Offset (0x56), 
                            Offset (0x57), 
                            Offset (0x58), 
                            Offset (0x59), 
                            Offset (0x5A), 
                            Offset (0x5B), 
                    CBLC,   8, 
                    MOSW,   8, 
                    LED1,   8, 
                    LED2,   8, 
                    KBSC,   8, 
                    HWRI,   8, 
                    HWRD,   8, 
                    KBB2,   8, 
                    KBB3,   8, 
                    PRBT,   8, 
                    WDTO,   8, 
                    WDVA,   8, 
                    WDCF,   8, 
                    WDCO,   8, 
                    SPK1,   8, 
                    SMIS,   8, 
                            Offset (0x6C), 
                            Offset (0x6D), 
                            Offset (0x6E), 
                            Offset (0x6F), 
                            Offset (0x70), 
                            Offset (0x71)
                }

                Method (LEDL, 0, NotSerialized)
                {
                    ACTL (0x00, SG06, 0x02)
                    Store (0x00, LED1)
                }

                Method (LEDB, 0, NotSerialized)
                {
                    If (\_SB.OBT0)
                    {
                        ACTL (0x01, SG06, 0x02)
                        Store (0x03, LED1)
                    }
                    Else
                    {
                        ACTL (0x00, SG06, 0x01)
                        Store (0x01, LED1)
                    }
                }

                Method (ACTL, 3, NotSerialized)
                {
                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Arg1, Local1)
                        Or (Local1, Arg2, Local1)
                        Store (Local1, SG06)
                    }
                    Else
                    {
                        Store (Arg1, Local1)
                        Not (Arg2, Local2)
                        And (Local1, Local2, Local1)
                        Store (Local1, SG06)
                    }
                }
            }

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

            IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x02), 
                CFG,    8, 
                        Offset (0x07), 
                LDN,    8, 
                        Offset (0x20), 
                IDHI,   8, 
                IDLO,   8, 
                POWC,   8, 
                        Offset (0x30), 
                ACTR,   8, 
                        Offset (0x60), 
                IOAH,   8, 
                IOAL,   8, 
                        Offset (0x70), 
                INTR,   8, 
                        Offset (0x72), 
                INT1,   8, 
                        Offset (0x74), 
                DMCH,   8, 
                        Offset (0xC0), 
                GP40,   8, 
                        Offset (0xF0), 
                OPT1,   8, 
                OPT2,   8, 
                OPT3,   8
            }

            Method (ENFG, 0, NotSerialized)
            {
                Store (0x55, INDX)
            }

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

            Device (FDC0)
            {
                Name (_HID, EisaId ("PNP0700"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (Zero, LDN)
                    If (ACTR)
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    Else
                    {
                        If (LOr (IOAH, IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (Zero, LDN)
                    Store (Zero, ACTR)
                    SLDM (DMCH, 0x04)
                    EXFG ()
                    DISD (0x03)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x03F0,             // Range Minimum
                            0x03F0,             // Range Maximum
                            0x01,               // Alignment
                            0x06,               // Length
                            _Y02)
                        IO (Decode16,
                            0x03F7,             // Range Minimum
                            0x03F7,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {6}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {2}
                    })
                    CreateByteField (BUF0, \_SB.PCI0.FDC0._CRS._Y02._MIN, IOLO)
                    CreateByteField (BUF0, 0x03, IOHI)
                    CreateByteField (BUF0, \_SB.PCI0.FDC0._CRS._Y02._MAX, IORL)
                    CreateByteField (BUF0, 0x05, IORH)
                    Return (BUF0)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F0,             // Range Minimum
                            0x03F0,             // Range Maximum
                            0x00,               // Alignment
                            0x06,               // Length
                            )
                        IO (Decode16,
                            0x03F7,             // Range Minimum
                            0x03F7,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {6}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {2}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x19, IRQW)
                    CreateByteField (Arg0, 0x1C, DMAV)
                    ENFG ()
                    Store (Zero, LDN)
                    Store (One, ACTR)
                    SLDM (DMCH, DMCH)
                    EXFG ()
                    CKIO (IOAD, 0x03)
                }
            }

            Device (UAR1)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x04, LDN)
                    If (ACTR)
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    Else
                    {
                        If (LOr (IOAH, IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }

                    EXFG ()
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x04, LDN)
                    Store (Zero, ACTR)
                    EXFG ()
                    DISD (0x00)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y03)
                        IRQNoFlags (_Y04)
                            {}
                    })
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y03._MIN, IOLO)
                    CreateByteField (BUF1, 0x03, IOHI)
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y03._MAX, IORL)
                    CreateByteField (BUF1, 0x05, IORH)
                    CreateWordField (BUF1, \_SB.PCI0.UAR1._CRS._Y04._INT, IRQW)
                    ENFG ()
                    Store (0x04, LDN)
                    Store (IOAL, IOLO)
                    Store (IOAL, IORL)
                    Store (IOAH, IOHI)
                    Store (IOAH, IORH)
                    Store (Zero, IRQW)
                    If (LNotEqual (INTR, Zero))
                    {
                        ShiftLeft (One, INTR, IRQW)
                    }

                    EXFG ()
                    Return (BUF1)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                    }
                    EndDependentFn ()
                    IRQNoFlags ()
                        {3,4,5,7,9,10,11,12}
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x04, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetLeftBit (IRQW, Local0)
                    If (LNotEqual (Local0, Zero))
                    {
                        Subtract (Local0, 0x01, Local0)
                    }

                    EXFG ()
                    CKIO (IOAD, 0x00)
                }
            }

            Device (LPT1)
            {
                Name (_HID, EisaId ("PNP0400"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    And (OPT1, 0x02, Local0)
                    If (LNotEqual (Local0, 0x02))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        Else
                        {
                            If (LOr (IOAH, IOAL))
                            {
                                EXFG ()
                                Return (0x0D)
                            }
                            Else
                            {
                                EXFG ()
                                Return (0x00)
                            }
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    Store (Zero, ACTR)
                    EXFG ()
                    DISD (0x02)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF5, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y05)
                        IRQNoFlags (_Y06)
                            {}
                    })
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y05._MIN, IOLO)
                    CreateByteField (BUF5, 0x03, IOHI)
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y05._MAX, IORL)
                    CreateByteField (BUF5, 0x05, IORH)
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y05._LEN, IOLE)
                    CreateWordField (BUF5, \_SB.PCI0.LPT1._CRS._Y06._INT, IRQW)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (IOAL, IOLO)
                    Store (IOLO, IORL)
                    Store (IOAH, IOHI)
                    Store (IOHI, IORH)
                    If (LEqual (IOLO, 0xBC))
                    {
                        Store (0x04, IOLE)
                    }
                    Else
                    {
                        Store (0x08, IOLE)
                    }

                    Store (Zero, IRQW)
                    If (LNotEqual (INTR, Zero))
                    {
                        ShiftLeft (One, INTR, IRQW)
                    }

                    EXFG ()
                    Return (BUF5)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                    }
                    EndDependentFn ()
                    IRQNoFlags ()
                        {3,4,5,7,9,10,11,12}
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateByteField (Arg0, 0x04, IORL)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateByteField (Arg0, 0x05, IORH)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetLeftBit (IRQW, Local0)
                    If (LNotEqual (Local0, Zero))
                    {
                        Subtract (Local0, 0x01, Local0)
                    }

                    Store (Local0, INTR)
                    EXFG ()
                    CKIO (IOAD, 0x02)
                }
            }

            Device (ECP1)
            {
                Name (_HID, EisaId ("PNP0401"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    And (OPT1, 0x02, Local0)
                    If (LEqual (Local0, 0x02))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        Else
                        {
                            If (LOr (IOAH, IOAL))
                            {
                                EXFG ()
                                Return (0x0D)
                            }
                            Else
                            {
                                EXFG ()
                                Return (0x00)
                            }
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    Store (Zero, ACTR)
                    SLDM (DMCH, 0x04)
                    EXFG ()
                    DISD (0x02)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF6, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y07)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            _Y08)
                        IRQNoFlags (_Y09)
                            {}
                        DMA (Compatibility, NotBusMaster, Transfer8, _Y0A)
                            {}
                    })
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y07._MIN, IOLO)
                    CreateByteField (BUF6, 0x03, IOHI)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y07._MAX, IORL)
                    CreateByteField (BUF6, 0x05, IORH)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y07._LEN, IOLE)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y08._MIN, IOEL)
                    CreateByteField (BUF6, 0x0B, IOEH)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y08._MAX, IOML)
                    CreateByteField (BUF6, 0x0D, IOMH)
                    CreateWordField (BUF6, \_SB.PCI0.ECP1._CRS._Y09._INT, IRQW)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y0A._DMA, DMAC)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (One, ACTR)
                    Store (IOAL, Local2)
                    Store (Local2, IOLO)
                    Store (IOAH, Local3)
                    Store (Local3, IOHI)
                    Or (Local3, 0x04, Local3)
                    Store (Local3, IOEH)
                    Store (Local3, IOMH)
                    Store (IOLO, IORL)
                    Store (IOLO, IOEL)
                    Store (IOLO, IOML)
                    Store (IOHI, IORH)
                    If (LEqual (IOLO, 0xBC))
                    {
                        Store (0x04, IOLE)
                    }
                    Else
                    {
                        Store (0x08, IOLE)
                    }

                    Store (Zero, IRQW)
                    If (LNotEqual (INTR, Zero))
                    {
                        ShiftLeft (One, INTR, IRQW)
                    }

                    Store (One, Local0)
                    Store (DMCH, Local5)
                    ShiftLeft (Local0, Local5, DMAC)
                    EXFG ()
                    Return (BUF6)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x00,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x00,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x07BC,             // Range Minimum
                            0x07BC,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                    }
                    EndDependentFn ()
                    IRQNoFlags ()
                        {3,4,5,7,9,10,11,12}
                    DMA (Compatibility, NotBusMaster, Transfer8, )
                        {0,1,3}
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x11, IRQW)
                    CreateByteField (Arg0, 0x14, DMAC)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetLeftBit (IRQW, Local0)
                    If (LNotEqual (Local0, Zero))
                    {
                        Subtract (Local0, 0x01, Local0)
                    }

                    Store (Local0, INTR)
                    FindSetLeftBit (DMAC, Local1)
                    Store (DMCH, Local0)
                    Subtract (Local1, 0x01, DMCH)
                    SLDM (Local0, DMCH)
                    EXFG ()
                    CKIO (IOAD, 0x02)
                }
            }

            OperationRegion (KBCT, SystemIO, 0x60, 0x05)
            Field (KBCT, ByteAcc, NoLock, Preserve)
            {
                P060,   8, 
                        Offset (0x04), 
                P064,   8
            }

            Device (PS2M)
            {
                Name (_HID, EisaId ("PNP0F13"))
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (PS2F, 0x00))
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {12}
                    })
                    Name (BUF2, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Range Minimum
                            0x0060,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0064,             // Range Minimum
                            0x0064,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {12}
                    })
                    If (LEqual (KBDI, 0x01))
                    {
                        If (LEqual (OSFL, 0x02))
                        {
                            Return (BUF1)
                        }

                        If (LEqual (OSFL, 0x01))
                        {
                            Return (BUF1)
                        }
                        Else
                        {
                            Return (BUF2)
                        }
                    }
                    Else
                    {
                        Return (BUF1)
                    }
                }
            }

            Device (PS2K)
            {
                Name (_HID, EisaId ("PNP0303"))
                Name (_CID, EisaId ("PNP030B"))
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (KBDI, 0x01))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

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

            Device (PSMR)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x03)
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (KBDI, 0x00))
                    {
                        Return (0x00)
                    }

                    If (LEqual (PS2F, 0x00))
                    {
                        If (LEqual (OSFL, 0x02))
                        {
                            Return (0x0F)
                        }

                        If (LEqual (OSFL, 0x01))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Return (0x00)
                }

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

            Method (\_SB.PCI0.PS2M._PSW, 1, NotSerialized)
            {
                And (PM3E, 0xFE, PM3E)
                If (Arg0)
                {
                    Or (P3E1, 0x10, P3E1)
                }
                Else
                {
                    And (P3E1, 0xEF, P3E1)
                }

                Notify (\_SB.PCI0.PS2M, 0x02)
            }

            Method (\_SB.PCI0.PS2K._PSW, 1, NotSerialized)
            {
                And (PM3E, 0xFE, PM3E)
                If (Arg0)
                {
                    Or (P3E1, 0x08, P3E1)
                }
                Else
                {
                    And (P3E1, 0xF7, P3E1)
                }

                Notify (\_SB.PCI0.PS2K, 0x02)
            }

            Method (\_SB.PCI0.PS2M._PRW, 0, NotSerialized)
            {
                Return (Package (0x02)
                {
                    0x03, 
                    0x05
                })
            }

            Method (\_SB.PCI0.PS2K._PRW, 0, NotSerialized)
            {
                Return (Package (0x02)
                {
                    0x03, 
                    0x05
                })
            }

            Method (_PRW, 0, NotSerialized)
            {
                Return (Package (0x02)
                {
                    0x04, 
                    0x05
                })
            }

            Device (AGP)
            {
                Name (_ADR, 0x00010000)
                Name (PICM, Package (0x04)
                {
                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }
                })
                Name (APIC, Package (0x04)
                {
                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x00, 
                        0x00, 
                        0x11
                    }, 

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

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x03, 
                        0x00, 
                        0x14
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (PICM)
                    }
                    Else
                    {
                        Return (APIC)
                    }
                }
            }
        }

        OperationRegion (OEMR, SystemMemory, 0x000FD530, 0x01)
        Field (OEMR, ByteAcc, NoLock, Preserve)
        {
            OBT0,   1, 
            OBT1,   1, 
            OBT2,   1, 
            OBT3,   1, 
            OBT4,   1, 
            OBT5,   1, 
            OBT6,   1, 
            OBT7,   1
        }

        OperationRegion (SXTM, SystemMemory, 0x000FFF34, 0x04)
        Field (SXTM, WordAcc, NoLock, Preserve)
        {
            SMEM,   32
        }

        Device (MEM)
        {
            Name (_HID, EisaId ("PNP0C01"))
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0x000F0000,         // Address Base
                        0x00004000,         // Address Length
                        _Y0C)
                    Memory32Fixed (ReadWrite,
                        0x000F4000,         // Address Base
                        0x00004000,         // Address Length
                        _Y0D)
                    Memory32Fixed (ReadWrite,
                        0x000F8000,         // Address Base
                        0x00004000,         // Address Length
                        _Y0E)
                    Memory32Fixed (ReadWrite,
                        0x000FC000,         // Address Base
                        0x00004000,         // Address Length
                        _Y0F)
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00200000,         // Address Length
                        _Y10)
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00010000,         // Address Length
                        _Y0B)
                    Memory32Fixed (ReadWrite,
                        0xFFFF0000,         // Address Base
                        0x00010000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x000A0000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00100000,         // Address Base
                        0x00000000,         // Address Length
                        _Y11)
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00000000,         // Address Length
                        _Y12)
                    Memory32Fixed (ReadWrite,
                        0xFEC00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEE00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFFF80000,         // Address Base
                        0x00070000,         // Address Length
                        )
                })
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0B._BAS, ACMM)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0C._BAS, RMA1)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0C._LEN, RSS1)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0D._BAS, RMA2)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0D._LEN, RSS2)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0E._BAS, RMA3)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0E._LEN, RSS3)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0F._BAS, RMA4)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0F._LEN, RSS4)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y10._BAS, RMA5)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y10._LEN, RSS5)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y11._LEN, EXTM)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y12._BAS, SXT1)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y12._LEN, SXT2)
                If (LNotEqual (SMEM, Zero))
                {
                    Add (AMEM, 0x00010000, SXT1)
                    Add (SXT1, 0x00100000, SXT1)
                }
                Else
                {
                    Store (Zero, SXT1)
                }

                Store (SMEM, SXT2)
                Add (AMEM, 0x00010000, RMA5)
                Store (0x00100000, RSS5)
                Subtract (AMEM, 0x00100000, EXTM)
                If (LNotEqual (ROM1, Zero))
                {
                    Store (RMA1, RMA2)
                    ShiftLeft (ROM1, 0x08, Local0)
                    Store (Local0, RMA1)
                    ShiftLeft (RMS1, 0x08, Local0)
                    Store (Local0, RSS1)
                    Store (0x8000, RSS2)
                }

                If (LNotEqual (ROM2, Zero))
                {
                    Store (RMA2, RMA3)
                    ShiftLeft (ROM2, 0x08, Local0)
                    Store (Local0, RMA2)
                    ShiftLeft (RMS2, 0x08, Local0)
                    Store (Local0, RSS2)
                    Store (0xC000, RSS3)
                }

                If (LNotEqual (ROM3, Zero))
                {
                    Store (RMA3, RMA4)
                    ShiftLeft (ROM3, 0x08, Local0)
                    Store (Local0, RMA3)
                    ShiftLeft (RMS3, 0x08, Local0)
                    Store (Local0, RSS3)
                    Store (0x00010000, RSS4)
                }

                Store (AMEM, ACMM)
                Return (BUF0)
            }
        }

        Device (\_SB.PCI0.EXPL)
        {
            Name (_HID, EisaId ("PNP0C02"))
            Name (_UID, 0x04)
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0xE0000000,         // Address Base
                        0x10000000,         // Address Length
                        )
                })
                Return (BUF0)
            }
        }
    }
}