DSDT.dsl corrected for errors

DSDT.dsl.1 (text/plain), 233.20 KB, created by Stuart Shelton on 2010-05-06 13:25:17 UTC

/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20100428
 *
 * Disassembly of DSDT, Thu May  6 11:42:15 2010
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x000061E9 (25065)
 *     Revision         0x01 **** ACPI 1.0, no 64-bit math support
 *     Checksum         0x03
 *     OEM ID           "CX700 "
 *     OEM Table ID     "AWRDACPI"
 *     OEM Revision     0x00001000 (4096)
 *     Compiler ID      "MSFT"
 *     Compiler Version 0x03000000 (50331648)
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "CX700 ", "AWRDACPI", 0x00001000)
{
    External (\_SB_.PCI0.LNK9)

    Scope (\_PR)
    {
        Processor (\_PR.CPU0, 0x00, 0x00000410, 0x06) {}
    }

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

    OperationRegion (\DEB2, SystemIO, 0x84, 0x01)
    Field (\DEB2, ByteAcc, NoLock, Preserve)
    {
        DBG2,   8
    }

    OperationRegion (\DEB3, SystemIO, 0x88, 0x01)
    Field (\DEB3, ByteAcc, NoLock, Preserve)
    {
        DBG3,   8
    }

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

    OperationRegion (\GPST, SystemIO, 0x0420, 0x02)
    Field (\GPST, ByteAcc, NoLock, Preserve)
    {
        GS00,   1, 
        GS01,   1, 
        GS02,   1, 
        GS03,   1, 
        GS04,   1, 
        GS05,   1, 
        GS06,   1, 
        GS07,   1, 
        GS08,   1, 
        GS09,   1, 
        GS10,   1, 
        GS11,   1, 
        GS12,   1, 
        GS13,   1, 
        GS14,   1, 
        GS15,   1
    }

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

    OperationRegion (\PMS, SystemIO, 0x0400, 0x02)
    Field (\PMS, ByteAcc, NoLock, Preserve)
    {
        AITS,   1, 
                Offset (0x01), 
        PBTS,   1, 
            ,   6, 
        WAKE,   1
    }

    OperationRegion (\GPSE, SystemIO, 0x0424, 0x02)
    Field (\GPSE, ByteAcc, NoLock, Preserve)
    {
        GPS0,   1, 
        GPS1,   1, 
        KBCE,   1, 
        LANE,   1, 
        EXTE,   1, 
        PME,    1, 
                Offset (0x01), 
        RING,   1, 
            ,   5, 
        USBE,   1, 
                Offset (0x02)
    }

    OperationRegion (\GLOS, SystemIO, 0x0428, 0x02)
    Field (\GLOS, ByteAcc, NoLock, Preserve)
    {
            ,   6, 
        SSMI,   1, 
        PRII,   1, 
            ,   2, 
        SLPE,   1, 
        SIRS,   1, 
                Offset (0x02)
    }

    OperationRegion (\WIRQ, SystemIO, 0x042A, 0x01)
    Field (\WIRQ, ByteAcc, NoLock, Preserve)
    {
        IRQR,   8
    }

    OperationRegion (\GPNB, SystemIO, 0x042D, 0x01)
    Field (\GPNB, ByteAcc, NoLock, Preserve)
    {
            ,   5, 
        G89E,   1
    }

    OperationRegion (\SMIC, SystemIO, 0x042F, 0x01)
    Field (\SMIC, ByteAcc, NoLock, Preserve)
    {
        SCP,    8
    }

    OperationRegion (\STUS, SystemIO, 0x0430, 0x01)
    Field (\STUS, ByteAcc, NoLock, Preserve)
    {
            ,   1, 
        PADS,   7
    }

    OperationRegion (GPOB, SystemIO, 0x044C, 0x04)
    Field (GPOB, ByteAcc, NoLock, Preserve)
    {
        GP00,   1, 
        GP01,   1, 
        GP02,   1, 
        GP03,   1, 
        GP04,   1, 
        GP05,   1, 
        GP06,   1, 
        GP07,   1, 
        GP08,   1, 
        GP09,   1, 
        GP10,   1, 
        GP11,   1, 
        GP12,   1, 
        GP13,   1, 
        GP14,   1, 
        GP15,   1, 
        GP16,   1, 
        GP17,   1, 
        GP18,   1, 
        GP19,   1, 
        GP20,   1, 
        GP21,   1, 
        GP22,   1, 
        GP23,   1, 
        GP24,   1, 
        GP25,   1, 
        GP26,   1, 
        GP27,   1, 
        GP28,   1, 
        GP29,   1, 
        GP30,   1, 
        GPXX,   1
    }

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

    Scope (\)
    {
        Name (PICF, 0x00)
        Method (_PIC, 1, NotSerialized)
        {
            Store (Arg0, PICF)
        }
    }

    Name (HPFL, 0x00)
    Name (PMFL, 0x00)
    Name (SBFL, 0x00)
    Name (ATFL, 0x00)
    Name (SMB1, 0x00)
    Name (SMB2, 0x00)
    Name (SMB3, 0x00)
    Name (SMB4, 0x00)
    Method (\_PTS, 1, NotSerialized)
    {
        Or (Arg0, 0xF0, Local0)
        Store (Local0, DBG1)
        OSTP ()
        If (LEqual (Arg0, 0x01))
        {
            While (PRII)
            {
                Store (One, PRII)
            }

            While (LNotEqual (PADS, 0x00))
            {
                Store (PADS, PADS)
            }

            Or (IRQR, 0x80, IRQR)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (0x4D, SCP)
        }

        If (LEqual (Arg0, 0x04)) {}
        If (LEqual (Arg0, 0x05)) {}
        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x03)) {}
        If (LEqual (Arg0, 0x04)) {}
        If (LEqual (Arg0, 0x05)) {}
    }

    Method (\_WAK, 1, NotSerialized)
    {
        Store (0xFF, DBG1)
        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x01))
        {
            And (IRQR, 0x7F, IRQR)
            While (PRII)
            {
                Store (One, PRII)
            }

            While (LNotEqual (PADS, 0x00))
            {
                Store (PADS, PADS)
            }
        }

        If (OSFL)
        {
            Notify (\_SB.PWRB, 0x02)
        }
        Else
        {
            If (LEqual (RTCW, 0x00))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }
        Return (Package (0x02) {0x00, 0x00})
    }

    Scope (\_SI)
    {
        Method (_MSG, 1, NotSerialized)
        {
            /* Store (Local0, Local0) */
        }

        Method (_SST, 1, NotSerialized)
        {
            /* Store (Local0, Local0) */
        }
    }

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

    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)
    OperationRegion (IP, SystemIO, 0x0295, 0x02)
    Field (IP, ByteAcc, NoLock, Preserve)
    {
        INDX,   8, 
        DAT0,   8
    }

    Method (SCFG, 1, NotSerialized)
    {
        SBYT (0x40, Arg0)
    }

    Method (STOS, 3, NotSerialized)
    {
        Divide (Arg2, 0x0A, Local0)
        If (LGreater (Local0, 0x0111))
        {
            Subtract (Local0, 0x0111, Local0)
        }
        Else
        {
            Subtract (0x0111, Local0, Local0)
            Or (Local0, 0x80, Local0)
        }

        SBYT (0x54, Local0)
    }

    Method (STHY, 3, NotSerialized)
    {
        Divide (Arg2, 0x0A, Local0)
        If (LGreater (Local0, 0x0111))
        {
            Subtract (Local0, 0x0111, Local0)
        }
        Else
        {
            Subtract (0x0111, Local0, Local0)
            Or (Local0, 0x80, Local0)
        }

        SBYT (0x55, Local0)
    }

    Method (RTMP, 0, NotSerialized)
    {
        Store (GBYT (0x1B), Local0)
        FindSetLeftBit (Local0, Local1)
        If (LEqual (Local1, 0x08))
        {
            And (Local0, 0x7F, Local0)
            Multiply (Local0, 0x0A, Local0)
            Subtract (0x0AAC, Local0, Local0)
        }
        Else
        {
            Multiply (Local0, 0x0A, Local0)
            Add (0x0AAC, Local0, Local0)
        }

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

    Method (SBYT, 2, NotSerialized)
    {
        Store (Arg0, INDX)
        Store (Arg1, DAT0)
    }

    Method (GBYT, 1, NotSerialized)
    {
        Store (Arg0, INDX)
        Store (DAT0, Local0)
        Return (Local0)
    }

    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 (_AC0, 0, NotSerialized)
            {
                If (Or (PLCY, PLCY, Local7))
                {
                    Return (TP2H)
                }
                Else
                {
                    Return (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 (TP1H)
                }
                Else
                {
                    Return (TP2H)
                }
            }

            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 (_L02, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.PS2K, 0x02)
        }

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

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

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

        Method (_L0D, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.P2PE.AZAC, 0x02)
            Notify (\_SB.PCI1.AZAC, 0x02)
        }

        Method (_L0E, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
            Notify (\_SB.PCI0.USB2, 0x02)
            Notify (\_SB.PCI0.USB3, 0x02)
            Notify (\_SB.PCI0.EHCI, 0x02)
        }

        Method (_L12, 0, NotSerialized)
        {
            If (LEqual (PMFL, 0x00))
            {
                Notify (\_SB.PCI0.P2PE.PE5C, 0x02)
                Notify (\_SB.PCI0.P2PE.PE6C, 0x02)
                Notify (\_SB.PCI1.PE5C, 0x02)
                Notify (\_SB.PCI1.PE6C, 0x02)
            }
        }

        Method (_L13, 0, NotSerialized)
        {
            If (LEqual (HPFL, 0x00))
            {
                Notify (\_SB.PCI0.P2PE.PE5C.S5F0, 0x01)
                Notify (\_SB.PCI0.P2PE.PE5C.S5F1, 0x01)
                Notify (\_SB.PCI0.P2PE.PE5C.S5F2, 0x01)
                Notify (\_SB.PCI0.P2PE.PE5C.S5F3, 0x01)
                Notify (\_SB.PCI0.P2PE.PE5C.S5F4, 0x01)
                Notify (\_SB.PCI0.P2PE.PE5C.S5F5, 0x01)
                Notify (\_SB.PCI0.P2PE.PE5C.S5F6, 0x01)
                Notify (\_SB.PCI0.P2PE.PE5C.S5F7, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F0, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F1, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F2, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F3, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F4, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F5, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F6, 0x01)
                Notify (\_SB.PCI0.P2PE.PE6C.S6F7, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F0, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F1, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F2, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F3, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F4, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F5, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F6, 0x01)
                Notify (\_SB.PCI1.PE5C.S5F7, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F0, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F1, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F2, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F3, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F4, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F5, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F6, 0x01)
                Notify (\_SB.PCI1.PE6C.S6F7, 0x01)
            }
        }
    }

    Scope (\_PR.CPU0)
    {
        Name (PDCT, 0x00)
        Name (PDCR, 0x01)
        Name (PDCM, 0x01)
        Method (_PDC, 1, NotSerialized)
        {
            Store (SizeOf (Arg0), Local0)
            Name (PDCB, Buffer (0x14) {})
            Store (Arg0, PDCB)
            CreateDWordField (PDCB, 0x00, REV)
            CreateDWordField (PDCB, 0x04, SIZE)
            If (LNotEqual (REV, PDCR))
            {
                Return (0x00)
            }

            If (LLess (SIZE, 0x01))
            {
                Return (0x00)
            }

            CreateDWordField (PDCB, 0x08, DAT0)
            If (And (DAT0, PDCM))
            {
                Store (0x01, PDCT)
            }

            Return (0x01)
        }

        Name (PCT1, Package (0x02)
        {
            ResourceTemplate ()
            {
                Register (FFixedHW, 
                    0x00,               // Bit Width
                    0x00,               // Bit Offset
                    0x0000000000000000, // Address
                    ,)
            }, 

            ResourceTemplate ()
            {
                Register (FFixedHW, 
                    0x00,               // Bit Width
                    0x00,               // Bit Offset
                    0x0000000000000000, // Address
                    ,)
            }
        })
        Name (PCT2, Package (0x02)
        {
            ResourceTemplate ()
            {
                Register (SystemIO, 
                    0x08,               // Bit Width
                    0x00,               // Bit Offset
                    0x000000000000042F, // Address
                    ,)
            }, 

            ResourceTemplate ()
            {
                Register (SystemIO, 
                    0x08,               // Bit Width
                    0x00,               // Bit Offset
                    0x0000000000000084, // Address
                    ,)
            }
        })
        Method (_PCT, 0, NotSerialized)
        {
            If (LEqual (PDCT, 0x00))
            {
                Return (PCT2)
            }
            Else
            {
                Return (PCT1)
            }
        }

        Method (_PPC, 0, NotSerialized)
        {
            Return (0x00)
        }

        Name (PPS1, Package (0x08)
        {
            Package (0x06)
            {
                0x07D0, 
                0x4E20, 
                0x0A, 
                0x0A, 
                0x141F, 
                0x141F
            }, 

            Package (0x06)
            {
                0x0320, 
                0x1F40, 
                0x0A, 
                0x0A, 
                0x0810, 
                0x0810
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }
        })
        Name (PPS2, Package (0x08)
        {
            Package (0x06)
            {
                0x07D0, 
                0x4E20, 
                0x0A, 
                0x0A, 
                0x00B0, 
                0x00B0
            }, 

            Package (0x06)
            {
                0x0320, 
                0x1F40, 
                0x0A, 
                0x0A, 
                0x00B1, 
                0x00B1
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }, 

            Package (0x06)
            {
                0xFFFF, 
                0xFFFF, 
                0xFF, 
                0xFF, 
                0xFFFF, 
                0xFFFF
            }
        })
        Method (_PSS, 0, NotSerialized)
        {
            If (LEqual (PDCT, 0x00))
            {
                Return (PPS2)
            }
            Else
            {
                Return (PPS1)
            }
        }
    }

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

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_UID, 0x01)
            Name (_BBN, 0x00)
            Method (_S3D, 0, NotSerialized)
            {
                If (LEqual (OSFL, 0x02))
                {
                    Return (0x02)
                }
                Else
                {
                    Return (0x03)
                }
            }

            OperationRegion (GART, PCI_Config, 0x80, 0x01)
            Scope (\)
            {
                Field (\_SB.PCI0.GART, ByteAcc, NoLock, Preserve)
                {
                    GAR1,   8
                }
            }

            OperationRegion (GARA, PCI_Config, 0x88, 0x01)
            Scope (\)
            {
                Field (\_SB.PCI0.GARA, ByteAcc, NoLock, Preserve)
                {
                    GAR2,   8
                }
            }

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

            Name (_PRW, Package (0x02)
            {
                0x05, 
                0x05
            })
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    WordBusNumber (ResourceConsumer, MinNotFixed, MaxNotFixed, PosDecode,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x007F,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0080,             // Length
                        ,, _Y03)
                    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
                        ,, _Y04, TypeStatic)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0D00,             // Range Minimum
                        0xFFFF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0xF300,             // Length
                        ,, _Y05, 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
                        0xFEB00000,         // Length
                        ,, _Y00, AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x00100000,         // Range Minimum
                        0xFEBFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0xFEB00000,         // Length
                        ,, _Y01, AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x00100000,         // Range Minimum
                        0xFEBFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0xFEB00000,         // Length
                        ,, _Y02, AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y00._MIN, TCMM)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y00._MAX, TAMM)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y00._LEN, TOMM)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y01._MAX, EM2X)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y01._MIN, EM2I)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y01._LEN, EM2L)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y02._MAX, EM3X)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y02._MIN, EM3I)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y02._LEN, EM3L)
                CreateWordField (BUF0, \_SB.PCI0._CRS._Y03._MAX, BNX1)
                CreateWordField (BUF0, \_SB.PCI0._CRS._Y03._LEN, BNO1)
                CreateWordField (BUF0, \_SB.PCI0._CRS._Y04._MAX, EI1X)
                CreateWordField (BUF0, \_SB.PCI0._CRS._Y04._LEN, EI1L)
                CreateWordField (BUF0, \_SB.PCI0._CRS._Y05._MIN, EI2I)
                CreateWordField (BUF0, \_SB.PCI0._CRS._Y05._LEN, EI2L)
                Add (AMEM, 0x00010000, TCMM)
                Add (TCMM, 0x00010000, TCMM)
                Subtract (SMB1, 0x01, TAMM)
                Subtract (SMB1, TCMM, TOMM)
                Add (SMB2, 0x01, EM2I)
                If (LEqual (OSFX, 0x04))
                {
                    Subtract (0xE0000000, EM2I, EM2L)
                    Subtract (0xE0000000, 0x01, EM2X)
                    Add (0xE0000000, 0x10000000, EM3I)
                    Subtract (0xFEC00000, 0x01, EM3X)
                    Subtract (0xFEC00000, EM3I, EM3L)
                }
                Else
                {
                    Subtract (0xFEC00000, EM2I, EM2L)
                    Subtract (0xFEC00000, 0x01, EM2X)
                    Store (0x00, EM3X)
                    Store (0x00, EM3I)
                    Store (0x00, EM3L)
                }

                Subtract (SMB3, 0x01, EI1X)
                Subtract (SMB3, 0x0D00, EI1L)
                Add (SMB4, 0x01, EI2I)
                Subtract (0x00010000, EI2I, EI2L)
                If (LEqual (\_SB.PCI0.P2PE.SCLS, 0x04))
                {
                    Store (0xFF, BNX1)
                    Store (0x0100, BNO1)
                }

                Return (BUF0)
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x0011FFFF, 
                    0x03, 
                    \_SB.PCI0.LNKD, 
                    0x00
                }
            })
            Name (APIC, Package (0x28)
            {
                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, 
                    0x12
                }, 

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

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

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

                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)
                {
                    0x000BFFFF, 
                    0x00, 
                    0x00, 
                    0x13
                }, 

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

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

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

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

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

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

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

                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)
                {
                    0x0001FFFF, 
                    0x00, 
                    0x00, 
                    0x10
                }, 

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

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

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

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

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

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x02, 
                    0x00, 
                    0x15
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x03, 
                    0x00, 
                    0x15
                }, 

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

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

                Package (0x04)
                {
                    0x0010FFFF, 
                    0x02, 
                    0x00, 
                    0x15
                }, 

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

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

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

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

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

            Device (PMIO)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x02)
                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0400,             // Range Minimum
                            0x0400,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x0500,             // Range Minimum
                            0x0500,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                    })
                    Return (BUF0)
                }
            }

            Device (WDRT)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x03)
                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0xFEA00000,         // Address Base
                            0x00000100,         // Address Length
                            )
                    })
                    Return (BUF0)
                }
            }

            Device (VT86)
            {
                Name (_ADR, 0x00110000)
                OperationRegion (BDRE, PCI_Config, 0xF6, 0x01)
                Field (BDRE, ByteAcc, NoLock, Preserve)
                {
                    REBD,   8
                }

                OperationRegion (USBC, PCI_Config, 0x50, 0x02)
                Scope (\)
                {
                    Field (\_SB.PCI0.VT86.USBC, ByteAcc, NoLock, Preserve)
                    {
                        IDEB,   8
                    }
                }

                OperationRegion (VTSB, PCI_Config, 0x00, 0x0100)
                Scope (\)
                {
                    Field (\_SB.PCI0.VT86.VTSB, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x02), 
                        DEID,   16, 
                                Offset (0x2C), 
                        ID2C,   8, 
                        ID2D,   8, 
                        ID2E,   8, 
                        ID2F,   8, 
                                Offset (0x44), 
                        PIRE,   4, 
                        PIRF,   4, 
                        PIRG,   4, 
                        PIRH,   4, 
                        POLE,   1, 
                        POLF,   1, 
                        POLG,   1, 
                        POLH,   1, 
                        ENR8,   1, 
                                Offset (0x50), 
                        ESB4,   1, 
                        ESB3,   1, 
                        ESB2,   1, 
                        EIDE,   1, 
                        EUSB,   1, 
                        ESB1,   1, 
                        EAMC,   2, 
                        EKBC,   1, 
                        KBCC,   1, 
                        EPS2,   1, 
                        ERTC,   1, 
                        ELAN,   1, 
                            ,   2, 
                        USBD,   1, 
                        SIRQ,   8, 
                                Offset (0x55), 
                        PIRA,   8, 
                        PIBC,   8, 
                        PIRD,   8, 
                                Offset (0x68), 
                            ,   7, 
                        HPTF,   1, 
                                Offset (0x7B), 
                            ,   6, 
                        BSAT,   1, 
                                Offset (0x94), 
                        PWC1,   2, 
                        GPO1,   1, 
                        GPO2,   1, 
                        GPO3,   1, 
                        PLLD,   1, 
                                Offset (0xEC), 
                        ENWT,   3
                    }
                }

                OperationRegion (SBPR, PCI_Config, 0x00, 0xE8)
                Field (SBPR, ByteAcc, NoLock, Preserve)
                {
                            Offset (0xE2), 
                        ,   1, 
                    SBPM,   1, 
                    SBHP,   1
                }

                Scope (\)
                {
                    Method (DISD, 1, NotSerialized)
                    {
                        /* Store (Local0, Local0) */
                    }

                    Method (CKIO, 2, NotSerialized)
                    {
                        /* Store (Local0, Local0) */
                    }

                    Method (SLDM, 2, NotSerialized)
                    {
                        /* Store (Local0, Local0) */
                    }
                }
            }

            Device (SBF7)
            {
                Name (_ADR, 0x00110007)
                OperationRegion (SBVL, PCI_Config, 0xFC, 0x01)
                Field (SBVL, ByteAcc, NoLock, Preserve)
                {
                        ,   2, 
                    P2PC,   1
                }
            }

            Device (IDEC)
            {
                Name (_ADR, 0x000F0000)
                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI0.IDEC.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        PMEX ()
                        If (LEqual (\_SB.PCI0.IDEC.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }

                OperationRegion (SAPR, PCI_Config, 0x00, 0xC2)
                Field (SAPR, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x3C), 
                    IDEI,   8, 
                            Offset (0x40), 
                        ,   1, 
                    PCEN,   1, 
                            Offset (0x48), 
                    SSPT,   8, 
                    SMPT,   8, 
                            Offset (0x50), 
                    SSUT,   4, 
                    SSCT,   1, 
                    SSUE,   3, 
                    SMUT,   4, 
                    SMCT,   1, 
                    SMUE,   3, 
                            Offset (0x89), 
                        ,   7, 
                    SCEN,   1
                }

                Name (REGF, 0x01)
                Method (_REG, 2, NotSerialized)
                {
                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, REGF)
                    }
                }

                Name (TIM0, Package (0x07)
                {
                    Package (0x05)
                    {
                        0x78, 
                        0xB4, 
                        0xF0, 
                        0x017F, 
                        0x0258
                    }, 

                    Package (0x05)
                    {
                        0x20, 
                        0x22, 
                        0x33, 
                        0x47, 
                        0x5D
                    }, 

                    Package (0x05)
                    {
                        0x04, 
                        0x03, 
                        0x02, 
                        0x01, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x02, 
                        0x01, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x07)
                    {
                        0x78, 
                        0x50, 
                        0x3C, 
                        0x2D, 
                        0x1E, 
                        0x14, 
                        0x0F
                    }, 

                    Package (0x0F)
                    {
                        0x06, 
                        0x05, 
                        0x04, 
                        0x04, 
                        0x03, 
                        0x03, 
                        0x02, 
                        0x02, 
                        0x01, 
                        0x01, 
                        0x01, 
                        0x01, 
                        0x01, 
                        0x01, 
                        0x00
                    }, 

                    Package (0x07)
                    {
                        0x0E, 
                        0x08, 
                        0x06, 
                        0x04, 
                        0x02, 
                        0x01, 
                        0x00
                    }
                })
                Name (TMD0, Buffer (0x14) {})
                CreateDWordField (TMD0, 0x00, PIO0)
                CreateDWordField (TMD0, 0x04, DMA0)
                CreateDWordField (TMD0, 0x08, PIO1)
                CreateDWordField (TMD0, 0x0C, DMA1)
                CreateDWordField (TMD0, 0x10, CHNF)
                Name (PMPT, 0x20)
                Name (PMUE, 0x07)
                Name (PMUT, 0x00)
                Name (PSPT, 0x20)
                Name (PSUE, 0x07)
                Name (PSUT, 0x00)
                Name (GMPT, 0x00)
                Name (GMUE, 0x00)
                Name (GMUT, 0x00)
                Name (GSPT, 0x00)
                Name (GSUE, 0x00)
                Name (GSUT, 0x00)
                Device (CHN0)
                {
                    Name (_ADR, 0x00)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.IDEC.PCEN, 0x01))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (GTM (PMPT, PMUE, PMUT, PSPT, PSUE, PSUT))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, TMD0)
                        Store (PMPT, GMPT)
                        Store (PMUE, GMUE)
                        Store (PMUT, GMUT)
                        Store (PSPT, GSPT)
                        Store (PSUE, GSUE)
                        Store (PSUT, GSUT)
                        If (REGF)
                        {
                            STM ()
                            Store (GMPT, PMPT)
                            Store (GMUE, PMUE)
                            Store (GMUT, PMUT)
                            Store (GSPT, PSPT)
                            Store (GSUE, PSUE)
                            Store (GSUT, PSUT)
                        }
                        Else
                        {
                            Store ("Trying to access IDE HWIF registers when not allowed", Debug)
                        }
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x02, PMUE, PMUT, PMPT))
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x03, PSUE, PSUT, PSPT))
                        }
                    }
                }

                Device (CHN1)
                {
                    Name (_ADR, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.IDEC.SCEN, 0x01))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (GTM (SMPT, SMUE, SMUT, SSPT, SSUE, SSUT))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, TMD0)
                        Store (SMPT, GMPT)
                        Store (SMUE, GMUE)
                        Store (SMUT, GMUT)
                        Store (SSPT, GSPT)
                        Store (SSUE, GSUE)
                        Store (SSUT, GSUT)
                        If (REGF)
                        {
                            STM ()
                            Store (GMPT, SMPT)
                            Store (GMUE, SMUE)
                            Store (GMUT, SMUT)
                            Store (GSPT, SSPT)
                            Store (GSUE, SSUE)
                            Store (GSUT, SSUT)
                        }
                        Else
                        {
                            Store ("Trying to access IDE HWIF registers when not allowed", Debug)
                        }
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x02, SMUE, SMUT, SMPT))
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x03, SSUE, SSUT, SSPT))
                        }
                    }
                }

                Method (PMEX, 0, Serialized)
                {
                    If (REGF)
                    {
                        If (LEqual (SMPT, 0xA8))
                        {
                            Store (0x5D, SMPT)
                        }

                        If (LEqual (SMPT, 0x65))
                        {
                            Store (0x33, SMPT)
                        }

                        If (LEqual (SMPT, 0x31))
                        {
                            Store (0x22, SMPT)
                        }

                        If (LEqual (SSPT, 0xA8))
                        {
                            Store (0x5D, SSPT)
                        }

                        If (LEqual (SSPT, 0x65))
                        {
                            Store (0x33, SSPT)
                        }

                        If (LEqual (SSPT, 0x31))
                        {
                            Store (0x22, SSPT)
                        }
                    }
                }

                Method (GTF, 4, Serialized)
                {
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                        }, Local1)
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                        }, Local2)
                    CreateByteField (Local1, 0x01, MODE)
                    CreateByteField (Local2, 0x01, UMOD)
                    CreateByteField (Local1, 0x05, PCHA)
                    CreateByteField (Local2, 0x05, UCHA)
                    And (Arg0, 0x03, Local3)
                    If (LEqual (And (Local3, 0x01), 0x01))
                    {
                        Store (0xB0, PCHA)
                        Store (0xB0, UCHA)
                    }

                    If (Arg1)
                    {
                        Store (DerefOf (Index (DerefOf (Index (TIM0, 0x05)), Arg2)), 
                            UMOD)
                        Or (UMOD, 0x40, UMOD)
                    }
                    Else
                    {
                        Store (Match (DerefOf (Index (TIM0, 0x01)), MEQ, Arg3, MTR, 
                            0x00, 0x00), Local0)
                        Or (0x20, DerefOf (Index (DerefOf (Index (TIM0, 0x03)), Local0
                            )), UMOD)
                    }

                    Store (Match (DerefOf (Index (TIM0, 0x01)), MEQ, Arg3, MTR, 
                        0x00, 0x00), Local0)
                    Or (0x08, DerefOf (Index (DerefOf (Index (TIM0, 0x02)), Local0
                        )), MODE)
                    Concatenate (Local1, Local2, Local6)
                    Return (Local6)
                }

                Method (GTM, 6, Serialized)
                {
                    Store (Ones, PIO0)
                    Store (Ones, PIO1)
                    Store (Ones, DMA0)
                    Store (Ones, DMA1)
                    Store (0x10, CHNF)
                    If (REGF) {}
                    Else
                    {
                        Return (TMD0)
                    }

                    Store (Match (DerefOf (Index (TIM0, 0x01)), MEQ, Arg0, MTR, 
                        0x00, 0x00), Local6)
                    Store (DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local6)), 
                        Local7)
                    Store (Local7, DMA0)
                    Store (Local7, PIO0)
                    Store (Match (DerefOf (Index (TIM0, 0x01)), MEQ, Arg3, MTR, 
                        0x00, 0x00), Local6)
                    Store (DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local6)), 
                        Local7)
                    Store (Local7, DMA1)
                    Store (Local7, PIO1)
                    If (Arg1)
                    {
                        Store (DerefOf (Index (DerefOf (Index (TIM0, 0x05)), Arg2)), 
                            Local5)
                        Store (DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local5)), 
                            DMA0)
                        Or (CHNF, 0x01, CHNF)
                    }

                    If (Arg4)
                    {
                        Store (DerefOf (Index (DerefOf (Index (TIM0, 0x05)), Arg5)), 
                            Local5)
                        Store (DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local5)), 
                            DMA1)
                        Or (CHNF, 0x04, CHNF)
                    }

                    Return (TMD0)
                }

                Method (STM, 0, Serialized)
                {
                    /*  If (REGF) {}
                     *  Else
                     *  {
                     *      Return (TMD0)
                     *  }
                     */

                    Store (0x00, GMUE)
                    Store (0x00, GSUE)
                    Store (0x07, GMUT)
                    Store (0x07, GSUT)
                    If (And (CHNF, 0x01))
                    {
                        Store (Match (DerefOf (Index (TIM0, 0x04)), MLE, DMA0, MTR, 
                            0x00, 0x00), Local0)
                        Store (DerefOf (Index (DerefOf (Index (TIM0, 0x06)), Local0)), 
                            GMUT)
                        Or (GMUE, 0x07, GMUE)
                    }
                    Else
                    {
                        If (Or (LEqual (PIO0, Ones), LEqual (PIO0, 0x00)))
                        {
                            If (And (LLess (DMA0, Ones), LGreater (DMA0, 0x00)))
                            {
                                Store (DMA0, PIO0)
                            }
                        }
                    }

                    If (And (CHNF, 0x04))
                    {
                        Store (Match (DerefOf (Index (TIM0, 0x04)), MLE, DMA1, MTR, 
                            0x00, 0x00), Local0)
                        Store (DerefOf (Index (DerefOf (Index (TIM0, 0x06)), Local0)), 
                            GSUT)
                        Or (GSUE, 0x07, GSUE)
                    }
                    Else
                    {
                        If (Or (LEqual (PIO1, Ones), LEqual (PIO1, 0x00)))
                        {
                            If (And (LLess (DMA1, Ones), LGreater (DMA1, 0x00)))
                            {
                                Store (DMA1, PIO1)
                            }
                        }
                    }

                    And (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIO0, MTR, 
                        0x00, 0x00), 0x03, Local0)
                    Store (DerefOf (Index (DerefOf (Index (TIM0, 0x01)), Local0)), 
                        Local1)
                    Store (Local1, GMPT)
                    And (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIO1, MTR, 
                        0x00, 0x00), 0x03, Local0)
                    Store (DerefOf (Index (DerefOf (Index (TIM0, 0x01)), Local0)), 
                        Local1)
                    Store (Local1, GSPT)
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x00100000)
                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                OperationRegion (U2F0, PCI_Config, 0x00, 0xC2)
                Field (U2F0, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x3C), 
                    U3IR,   4, 
                            Offset (0x84), 
                    ECDX,   2
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI0.USB1.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        If (LEqual (\_SB.PCI0.USB1.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x00100001)
                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                OperationRegion (U2F1, PCI_Config, 0x00, 0xC2)
                Field (U2F1, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x3C), 
                    U4IR,   4, 
                            Offset (0x84), 
                    ECDX,   2
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI0.USB2.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        If (LEqual (\_SB.PCI0.USB2.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }
            }

            Device (USB3)
            {
                Name (_ADR, 0x00100002)
                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                OperationRegion (U2F2, PCI_Config, 0x00, 0xC2)
                Field (U2F2, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x3C), 
                    U5IR,   4, 
                            Offset (0x84), 
                    ECDX,   2
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI0.USB3.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        If (LEqual (\_SB.PCI0.USB3.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }
            }

            Device (EHCI)
            {
                Name (_ADR, 0x00100004)
                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                OperationRegion (U2F4, PCI_Config, 0x00, 0xC2)
                Field (U2F4, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x3C), 
                    U7IR,   4, 
                            Offset (0x84), 
                    ECDX,   2
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI0.EHCI.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        If (LEqual (\_SB.PCI0.EHCI.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }
            }

            Device (P2PE)
            {
                Name (_ADR, 0x00130000)
                OperationRegion (P2ER, PCI_Config, 0x00, 0x0100)
                Field (P2ER, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x0A), 
                    SCLS,   8, 
                            Offset (0x1C), 
                    SIOB,   8, 
                    SIOL,   8, 
                            Offset (0x20), 
                    SBAS,   16, 
                    SLIM,   16
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI0.P2PE.SCLS, 0x04))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                Name (PICE, Package (0x08)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x01, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

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

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

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

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x03, 
                        \_SB.PCI0.LNKB, 
                        0x00
                    }
                })
                Name (APIE, Package (0x08)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x01, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        0x00, 
                        0x00
                    }, 

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

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

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

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x03, 
                        0x00, 
                        0x11
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (PICE)
                    }
                    Else
                    {
                        Return (APIE)
                    }
                }

                Device (SBRC)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x77)
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            Memory32Fixed (ReadWrite,
                                0xF0000000,         // Address Base
                                0x00001000,         // Address Length
                                )
                        })
                        Return (BUF0)
                    }
                }

                Device (PE5C)
                {
                    Name (_ADR, 0x00)
                    OperationRegion (PE5R, PCI_Config, 0x00, 0x0100)
                    Field (PE5R, ByteAcc, NoLock, Preserve)
                    {
                        VID,    16, 
                                Offset (0x04), 
                        CMDR,   3
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNotEqual (\_SB.PCI0.P2PE.PE5C.VID, 0x1106))
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            If (LEqual (\_SB.PCI0.P2PE.PE5C.CMDR, 0x00))
                            {
                                Return (0x0D)
                            }
                            Else
                            {
                                Return (0x0F)
                            }
                        }
                    }

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

                    Name (PIC5, Package (0x04)
                    {
                        Package (0x04)
                        {
                            0xFFFF, 
                            0x00, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x01, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x02, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x03, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }
                    })
                    Name (API5, Package (0x04)
                    {
                        Package (0x04)
                        {
                            0xFFFF, 
                            0x00, 
                            0x00, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x01, 
                            0x00, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x02, 
                            0x00, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x03, 
                            0x00, 
                            0x00
                        }
                    })
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (LNot (PICF))
                        {
                            Return (PIC5)
                        }
                        Else
                        {
                            Return (API5)
                        }
                    }

                    Device (S5F0)
                    {
                        Name (_ADR, 0x00)
                        Name (_SUN, 0x05)
                    }

                    Device (S5F1)
                    {
                        Name (_ADR, 0x01)
                        Name (_SUN, 0x05)
                    }

                    Device (S5F2)
                    {
                        Name (_ADR, 0x02)
                        Name (_SUN, 0x05)
                    }

                    Device (S5F3)
                    {
                        Name (_ADR, 0x03)
                        Name (_SUN, 0x05)
                    }

                    Device (S5F4)
                    {
                        Name (_ADR, 0x04)
                        Name (_SUN, 0x05)
                    }

                    Device (S5F5)
                    {
                        Name (_ADR, 0x05)
                        Name (_SUN, 0x05)
                    }

                    Device (S5F6)
                    {
                        Name (_ADR, 0x06)
                        Name (_SUN, 0x05)
                    }

                    Device (S5F7)
                    {
                        Name (_ADR, 0x07)
                        Name (_SUN, 0x05)
                    }
                }

                Device (PE6C)
                {
                    Name (_ADR, 0x01)
                    OperationRegion (PE6R, PCI_Config, 0x00, 0x0100)
                    Field (PE6R, ByteAcc, NoLock, Preserve)
                    {
                        VID,    16, 
                                Offset (0x04), 
                        CMDR,   3
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNotEqual (\_SB.PCI0.P2PE.PE6C.VID, 0x1106))
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            If (LEqual (\_SB.PCI0.P2PE.PE6C.CMDR, 0x00))
                            {
                                Return (0x0D)
                            }
                            Else
                            {
                                Return (0x0F)
                            }
                        }
                    }

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

                    Name (PIC6, Package (0x04)
                    {
                        Package (0x04)
                        {
                            0xFFFF, 
                            0x00, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x01, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x02, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x03, 
                            \_SB.PCI0.LNK9, 
                            0x00
                        }
                    })
                    Name (API6, Package (0x04)
                    {
                        Package (0x04)
                        {
                            0xFFFF, 
                            0x00, 
                            0x00, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x01, 
                            0x00, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x02, 
                            0x00, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0xFFFF, 
                            0x03, 
                            0x00, 
                            0x00
                        }
                    })
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (LNot (PICF))
                        {
                            Return (PIC6)
                        }
                        Else
                        {
                            Return (API6)
                        }
                    }

                    Device (S6F0)
                    {
                        Name (_ADR, 0x00)
                        Name (_SUN, 0x06)
                    }

                    Device (S6F1)
                    {
                        Name (_ADR, 0x01)
                        Name (_SUN, 0x06)
                    }

                    Device (S6F2)
                    {
                        Name (_ADR, 0x02)
                        Name (_SUN, 0x06)
                    }

                    Device (S6F3)
                    {
                        Name (_ADR, 0x03)
                        Name (_SUN, 0x06)
                    }

                    Device (S6F4)
                    {
                        Name (_ADR, 0x04)
                        Name (_SUN, 0x06)
                    }

                    Device (S6F5)
                    {
                        Name (_ADR, 0x05)
                        Name (_SUN, 0x06)
                    }

                    Device (S6F6)
                    {
                        Name (_ADR, 0x06)
                        Name (_SUN, 0x06)
                    }

                    Device (S6F7)
                    {
                        Name (_ADR, 0x07)
                        Name (_SUN, 0x06)
                    }
                }

                Device (AZAC)
                {
                    Name (_ADR, 0x00010000)
                    OperationRegion (AZAR, PCI_Config, 0x00, 0x0100)
                    Field (AZAR, ByteAcc, NoLock, Preserve)
                    {
                        VID,    16, 
                                Offset (0x04), 
                        CMDR,   3
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNotEqual (\_SB.PCI0.P2PE.AZAC.VID, 0x1106))
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            If (LEqual (\_SB.PCI0.P2PE.AZAC.CMDR, 0x00))
                            {
                                Return (0x0D)
                            }
                            Else
                            {
                                Return (0x0F)
                            }
                        }
                    }

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

            Device (P2PB)
            {
                Name (_ADR, 0x00130001)
                OperationRegion (P2PR, PCI_Config, 0x00, 0x0100)
                Field (P2PR, ByteAcc, NoLock, Preserve)
                {
                    VID,    16
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI0.P2PB.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x05
                })
                Name (PICM, Package (0x1C)
                {
                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x00, 
                        \_SB.PCI0.LNKA, 
                        0x00
                    }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Package (0x04)
                    {
                        0x000FFFFF, 
                        0x03, 
                        \_SB.PCI0.LNKD, 
                        0x00
                    }
                })
                Name (APIC, Package (0x1C)
                {
                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x00, 
                        0x00, 
                        0x10
                    }, 

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

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

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

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

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

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

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

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

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

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        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)
                    {
                        0x0008FFFF, 
                        0x00, 
                        0x00, 
                        0x11
                    }, 

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

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

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

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

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

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

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

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

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFB, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFB)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    And (PIRA, 0x0F, PIRA)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFB, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y06)
                            {}
                    })
                    CreateByteField (BUFB, \_SB.PCI0.LNKA._CRS._Y06._INT, IRB1)
                    CreateByteField (BUFB, 0x02, IRB2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIRA, 0xF0, Local1)
                    ShiftRight (Local1, 0x04, Local1)
                    If (LNotEqual (Local1, 0x00))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

                        Store (Local3, IRB1)
                        Store (Local4, IRB2)
                    }

                    Return (BUFB)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x01, IRB1)
                    CreateByteField (Arg0, 0x02, IRB2)
                    ShiftLeft (IRB2, 0x08, Local0)
                    Or (Local0, IRB1, Local0)
                    Store (0x00, Local1)
                    ShiftRight (Local0, 0x01, Local0)
                    While (LGreater (Local0, 0x00))
                    {
                        Increment (Local1)
                        ShiftRight (Local0, 0x01, Local0)
                    }

                    And (PIRA, 0x0F, PIRA)
                    ShiftLeft (Local1, 0x04, Local1)
                    Or (PIRA, Local1, PIRA)
                }
            }

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

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFA, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    And (PIBC, 0xF0, PIBC)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFA, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y07)
                            {}
                    })
                    CreateByteField (BUFA, \_SB.PCI0.LNKB._CRS._Y07._INT, IRA1)
                    CreateByteField (BUFA, 0x02, IRA2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIBC, 0x0F, Local1)
                    If (LNotEqual (Local1, 0x00))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

                        Store (Local3, IRA1)
                        Store (Local4, IRA2)
                    }

                    Return (BUFA)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x01, IRA1)
                    CreateByteField (Arg0, 0x02, IRA2)
                    ShiftLeft (IRA2, 0x08, Local0)
                    Or (Local0, IRA1, Local0)
                    Store (0x00, Local1)
                    ShiftRight (Local0, 0x01, Local0)
                    While (LGreater (Local0, 0x00))
                    {
                        Increment (Local1)
                        ShiftRight (Local0, 0x01, Local0)
                    }

                    And (PIBC, 0xF0, PIBC)
                    Or (PIBC, Local1, PIBC)
                }
            }

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

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFC)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    And (PIBC, 0x0F, PIBC)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y08)
                            {}
                    })
                    CreateByteField (BUFC, \_SB.PCI0.LNKC._CRS._Y08._INT, IRC1)
                    CreateByteField (BUFC, 0x02, IRC2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIBC, 0xF0, Local1)
                    ShiftRight (Local1, 0x04, Local1)
                    If (LNotEqual (Local1, 0x00))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

                        Store (Local3, IRC1)
                        Store (Local4, IRC2)
                    }

                    Return (BUFC)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x01, IRC1)
                    CreateByteField (Arg0, 0x02, IRC2)
                    ShiftLeft (IRC2, 0x08, Local0)
                    Or (Local0, IRC1, Local0)
                    Store (0x00, Local1)
                    ShiftRight (Local0, 0x01, Local0)
                    While (LGreater (Local0, 0x00))
                    {
                        Increment (Local1)
                        ShiftRight (Local0, 0x01, Local0)
                    }

                    And (PIBC, 0x0F, PIBC)
                    ShiftLeft (Local1, 0x04, Local1)
                    Or (PIBC, Local1, PIBC)
                }
            }

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

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFD, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFD)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    And (PIRD, 0x0F, PIRD)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFD, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y09)
                            {}
                    })
                    CreateByteField (BUFD, \_SB.PCI0.LNKD._CRS._Y09._INT, IRD1)
                    CreateByteField (BUFD, 0x02, IRD2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIRD, 0xF0, Local1)
                    ShiftRight (Local1, 0x04, Local1)
                    If (LNotEqual (Local1, 0x00))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

                        Store (Local3, IRD1)
                        Store (Local4, IRD2)
                    }

                    Return (BUFD)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x01, IRD1)
                    CreateByteField (Arg0, 0x02, IRD2)
                    ShiftLeft (IRD2, 0x08, Local0)
                    Or (Local0, IRD1, Local0)
                    Store (0x00, Local1)
                    ShiftRight (Local0, 0x01, Local0)
                    While (LGreater (Local0, 0x00))
                    {
                        Increment (Local1)
                        ShiftRight (Local0, 0x01, Local0)
                    }

                    And (PIRD, 0x0F, PIRD)
                    ShiftLeft (Local1, 0x04, Local1)
                    Or (PIRD, Local1, PIRD)
                }
            }

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

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFE, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFE)
                }

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFE, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y0A)
                            {}
                    })
                    CreateByteField (BUFE, \_SB.PCI0.LNKE._CRS._Y0A._INT, IRE1)
                    CreateByteField (BUFE, 0x02, IRE2)
                    Store (Zero, IRE1)
                    Store (Zero, IRE2)
                    Store (PIRE, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        If (LGreater (Local0, 0x07))
                        {
                            Subtract (Local0, 0x08, Local1)
                            ShiftLeft (One, Local1, IRE2)
                        }
                        Else
                        {
                            Store (Local0, Local1)
                            ShiftLeft (One, Local1, IRE1)
                        }
                    }

                    Return (BUFE)
                }

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

                    Store (One, ENR8)
                    Store (Zero, POLE)
                    Store (Local0, PIRE)
                }
            }

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

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFF, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFF)
                }

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFF, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y0B)
                            {}
                    })
                    CreateByteField (BUFF, \_SB.PCI0.LNKF._CRS._Y0B._INT, IRF1)
                    CreateByteField (BUFF, 0x02, IRF2)
                    Store (Zero, IRF1)
                    Store (Zero, IRF2)
                    Store (PIRF, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        If (LGreater (Local0, 0x07))
                        {
                            Subtract (Local0, 0x08, Local1)
                            ShiftLeft (One, Local0, IRF2)
                        }
                        Else
                        {
                            Store (Local0, Local1)
                            ShiftLeft (One, Local1, IRF1)
                        }
                    }

                    Return (BUFF)
                }

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

                    Store (One, ENR8)
                    Store (Zero, POLF)
                    Store (Local0, PIRF)
                }
            }

            Device (LNK0)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x07)
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (PIRG, 0x00))
                    {
                        Return (0x09)
                    }
                    Else
                    {
                        Return (0x0B)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFG, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFG)
                }

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFG, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y0C)
                            {}
                    })
                    CreateByteField (BUFG, \_SB.PCI0.LNK0._CRS._Y0C._INT, IRG1)
                    CreateByteField (BUFG, 0x02, IRG2)
                    Store (Zero, IRG1)
                    Store (Zero, IRG2)
                    Store (PIRG, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        If (LGreater (Local0, 0x07))
                        {
                            Subtract (Local0, 0x08, Local0)
                            ShiftLeft (One, Local0, IRG2)
                        }
                        Else
                        {
                            Store (0x01, Local1)
                            ShiftLeft (Local1, Local0, IRG1)
                        }
                    }

                    Return (BUFG)
                }

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

                    Store (One, ENR8)
                    Store (Zero, POLG)
                    Store (Local0, PIRG)
                }
            }

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

                Method (_PRS, 0, NotSerialized)
                {
                    Name (BUFH, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,6,7,10,11,12}
                    })
                    Return (BUFH)
                }

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFH, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, _Y0D)
                            {}
                    })
                    CreateByteField (BUFH, \_SB.PCI0.LNK1._CRS._Y0D._INT, IRH1)
                    CreateByteField (BUFH, 0x02, IRH2)
                    Store (Zero, IRH1)
                    Store (Zero, IRH2)
                    Store (PIRH, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        If (LGreater (Local0, 0x07))
                        {
                            Subtract (Local0, 0x08, Local0)
                            ShiftLeft (One, Local0, IRH2)
                        }
                        Else
                        {
                            Store (0x01, Local1)
                            ShiftLeft (Local1, Local0, IRH1)
                        }
                    }

                    Return (BUFH)
                }

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

                    Store (One, ENR8)
                    Store (Zero, POLH)
                    Store (Local0, PIRH)
                }
            }

            Scope (\)
            {
                OperationRegion (\SCPP, SystemIO, 0x042F, 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)
                            }

                            If (\_OSI ("Windows 2006"))
                            {
                                Store (0x59, SMIP)
                                Store (0x00, OSFL)
                                Store (0x04, OSFX)
                            }
                        }
                        Else
                        {
                            Store (0x58, SMIP)
                            Store (0x00, OSFX)
                            Store (0x00, OSFL)
                        }
                    }
                    Else
                    {
                        Store (0x57, SMIP)
                        Store (0x02, OSFX)
                        Store (0x02, OSFL)
                    }
                }

                If (LNotEqual (\_SB.PCI0.P2PE.SCLS, 0x04))
                {
                    Store (Zero, \_SB.PCI0.SBF7.P2PC)
                    Store (\_SB.PCI0.P2PE.SBAS, SMB1)
                    ShiftLeft (SMB1, 0x10, SMB1)
                    And (SMB1, 0xFFF00000, SMB1)
                    Store (\_SB.PCI0.P2PE.SLIM, SMB2)
                    ShiftLeft (SMB2, 0x10, SMB2)
                    And (SMB2, 0xFFF00000, SMB2)
                    Or (SMB2, 0x000FFFFF, SMB2)
                    Store (\_SB.PCI0.P2PE.SIOB, SMB3)
                    ShiftLeft (SMB3, 0x08, SMB3)
                    And (SMB3, 0xF000, SMB3)
                    Store (\_SB.PCI0.P2PE.SIOL, SMB4)
                    ShiftLeft (SMB4, 0x08, SMB4)
                    Or (SMB4, 0x0FFF, SMB4)
                    Store (One, \_SB.PCI0.SBF7.P2PC)
                }
                Else
                {
                    Store (\_SB.PCI0.P2PE.SLIM, SMB1)
                    ShiftLeft (SMB1, 0x10, SMB1)
                    And (SMB1, 0xFFF00000, SMB1)
                    Or (SMB1, 0x000FFFFF, SMB1)
                    Add (SMB1, 0x01, SMB1)
                    Store (\_SB.PCI0.P2PE.SLIM, SMB2)
                    ShiftLeft (SMB2, 0x10, SMB2)
                    And (SMB2, 0xFFF00000, SMB2)
                    Or (SMB2, 0x000FFFFF, SMB2)
                    Store (\_SB.PCI0.P2PE.SIOB, SMB3)
                    ShiftLeft (SMB3, 0x08, SMB3)
                    And (SMB3, 0xF000, SMB3)
                    Store (\_SB.PCI0.P2PE.SIOL, SMB4)
                    ShiftLeft (SMB4, 0x08, SMB4)
                    Or (SMB4, 0x0FFF, SMB4)
                }
            }

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

                    If (LEqual (OSFX, 0x04))
                    {
                        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
                        0x06,               // Length
                        )
                    IO (Decode16,
                        0x0290,             // Range Minimum
                        0x0290,             // Range Maximum
                        0x01,               // Alignment
                        0x08,               // Length
                        )
                })
            }

            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 (ATT5, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                    IRQNoFlags ()
                        {0}
                })
                Name (ATT6, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                })
                Method (_CRS, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (ATT6)
                        }
                        Else
                        {
                            Return (ATT5)
                        }
                    }
                    Else
                    {
                        Return (ATT5)
                    }
                }
            }

            Device (HPET)
            {
                Name (_HID, EisaId ("PNP0103"))
                Name (ATT3, ResourceTemplate ()
                {
                    IRQNoFlags ()
                        {0}
                    IRQNoFlags ()
                        {8}
                    Memory32Fixed (ReadWrite,
                        0xFE800000,         // Address Base
                        0x00000400,         // Address Length
                        )
                })
                Name (ATT4, ResourceTemplate ()
                {
                })
                Method (_STA, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (ATT3)
                        }
                        Else
                        {
                            Return (ATT4)
                        }
                    }
                    Else
                    {
                        Return (ATT4)
                    }
                }
            }

            Device (RTC)
            {
                Name (_HID, EisaId ("PNP0B00"))
                Name (ATT0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                    IRQNoFlags ()
                        {8}
                })
                Name (ATT1, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                })
                Method (_CRS, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (ATT1)
                        }
                        Else
                        {
                            Return (ATT0)
                        }
                    }
                    Else
                    {
                        Return (ATT0)
                    }
                }
            }

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

            Scope (\)
            {
                OperationRegion (WIN1, SystemIO, 0x4E, 0x02)
                Field (WIN1, ByteAcc, NoLock, Preserve)
                {
                    INDP,   8, 
                    DATP,   8
                }

                IndexField (INDP, DATP, 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, 
                    IO2H,   8, 
                    IO2L,   8, 
                            Offset (0x70), 
                    INTR,   8, 
                            Offset (0x72), 
                    INT1,   8, 
                            Offset (0x74), 
                    DMCH,   8, 
                            Offset (0xF0), 
                    OPT1,   8, 
                    OPT2,   8, 
                    OPT3,   8
                }

                Method (ENFG, 0, NotSerialized)
                {
                    Store (0x87, INDP)
                    Store (0x87, INDP)
                    Or (POWC, 0x80, POWC)
                }

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

                OperationRegion (WIN2, SystemIO, 0x2E, 0x02)
                Field (WIN2, ByteAcc, NoLock, Preserve)
                {
                    INDS,   8, 
                    DATS,   8
                }

                IndexField (INDS, DATS, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x07), 
                    LDN2,   8, 
                            Offset (0x20), 
                    DEV2,   8, 
                            Offset (0x23), 
                    VEN2,   8, 
                            Offset (0x30), 
                    ACT2,   8, 
                            Offset (0x60), 
                    IOH2,   8, 
                    IOL2,   8, 
                            Offset (0x70), 
                    IRQ2,   8
                }

                Method (ENGS, 0, NotSerialized)
                {
                    Store (0x87, INDS)
                    Store (0x87, INDS)
                }

                Method (EXGS, 0, NotSerialized)
                {
                    Store (0xAA, INDS)
                }

                OperationRegion (WIN3, SystemIO, 0x4E, 0x02)
                Field (WIN3, ByteAcc, NoLock, Preserve)
                {
                    INDT,   8, 
                    DATT,   8
                }

                IndexField (INDT, DATT, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x07), 
                    LDN3,   8, 
                            Offset (0x20), 
                    DEV3,   8, 
                            Offset (0x23), 
                    VEN3,   8, 
                            Offset (0x30), 
                    ACT3,   8, 
                            Offset (0x60), 
                    IOH3,   8, 
                    IOL3,   8, 
                            Offset (0x70), 
                    IRQ3,   8
                }

                Method (ENGT, 0, NotSerialized)
                {
                    Store (0xAA, INDT)
                    Store (0x77, INDT)
                    Store (0x77, INDT)
                }

                Method (EXGT, 0, NotSerialized)
                {
                    Store (0xAA, INDT)
                }

                Method (GSRG, 1, NotSerialized)
                {
                    Store (Arg0, INDP)
                    Return (DATP)
                }

                Method (SSRG, 2, NotSerialized)
                {
                    Store (Arg0, INDP)
                    Store (Arg1, DATP)
                }
            }

            Device (UAR1)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x01, 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 (0x01, 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
                            _Y0E)
                        IRQ (Edge, ActiveLow, Shared, _Y0F)
                            {}
                    })
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y0E._MIN, IOLO)
                    CreateByteField (BUF1, 0x03, IOHI)
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y0E._MAX, IORL)
                    CreateByteField (BUF1, 0x05, IORH)
                    CreateWordField (BUF1, \_SB.PCI0.UAR1._CRS._Y0F._INT, IRQW)
                    ENFG ()
                    Store (0x01, LDN)
                    Store (IOAL, IOLO)
                    Store (IOAL, IORL)
                    Store (IOAH, IOHI)
                    Store (IOAH, IORH)
                    Store (One, Local0)
                    ShiftLeft (Local0, INTR, IRQW)
                    EXFG ()
                    Return (BUF1)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x01, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, INTR)
                    EXFG ()
                    CKIO (IOAD, 0x00)
                }
            }

            Device (UAR2)
            {
                Method (_HID, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x02, LDN)
                    EXFG ()
                    Return (0x0105D041)
                }

                Name (_UID, 0x02)
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x02, LDN)
                    And (OPT2, 0x10, Local0)
                    If (LNotEqual (Local0, 0x10))
                    {
                        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 (0x02, LDN)
                    Store (Zero, ACTR)
                    EXFG ()
                    DISD (0x01)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF2, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y10)
                        IRQ (Edge, ActiveLow, Shared, _Y11)
                            {4}
                    })
                    CreateByteField (BUF2, \_SB.PCI0.UAR2._CRS._Y10._MIN, IOLO)
                    CreateByteField (BUF2, 0x03, IOHI)
                    CreateByteField (BUF2, \_SB.PCI0.UAR2._CRS._Y10._MAX, IORL)
                    CreateByteField (BUF2, 0x05, IORH)
                    CreateWordField (BUF2, \_SB.PCI0.UAR2._CRS._Y11._INT, IRQW)
                    ENFG ()
                    Store (0x02, LDN)
                    Store (IOAL, IOLO)
                    Store (IOAL, IORL)
                    Store (IOAH, IOHI)
                    Store (IOAH, IORH)
                    Store (One, Local0)
                    ShiftLeft (Local0, INTR, IRQW)
                    EXFG ()
                    Return (BUF2)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x02, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, INTR)
                    EXFG ()
                    CKIO (IOAD, 0x01)
                }
            }

            Device (IRDA)
            {
                Name (_HID, EisaId ("PNP0510"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x02, LDN)
                    And (OPT2, 0x10, Local0)
                    If (LEqual (Local0, 0x10))
                    {
                        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)
                {
                    If (LEqual (DISE, 0x01))
                    {
                        ENFG ()
                        Store (0x02, LDN)
                        Store (Zero, ACTR)
                        EXFG ()
                        DISD (0x01)
                    }

                    /* Store (Local0, Local0) */
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF4, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y12)
                        IRQ (Edge, ActiveLow, Shared, _Y13)
                            {}
                    })
                    CreateByteField (BUF4, \_SB.PCI0.IRDA._CRS._Y12._MIN, IOLO)
                    CreateByteField (BUF4, 0x03, IOHI)
                    CreateByteField (BUF4, \_SB.PCI0.IRDA._CRS._Y12._MAX, IORL)
                    CreateByteField (BUF4, 0x05, IORH)
                    CreateWordField (BUF4, \_SB.PCI0.IRDA._CRS._Y13._INT, IRQW)
                    ENFG ()
                    Store (0x02, LDN)
                    Store (IOAL, IOLO)
                    Store (IOAL, IORL)
                    Store (IOAH, IOHI)
                    Store (IOAH, IORH)
                    ShiftLeft (0x01, INTR, IRQW)
                    EXFG ()
                    Return (BUF4)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x02, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, INTR)
                    EXFG ()
                    CKIO (IOAD, 0x01)
                }
            }

            Device (UAR3)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x03)
                Method (_STA, 0, NotSerialized)
                {
                    ENGS ()
                    Store (0x01, LDN2)
                    If (LEqual (VEN2, 0x19))
                    {
                        If (LGreaterEqual (DEV2, 0x03))
                        {
                            If (ACT2)
                            {
                                EXGS ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (IOH2, IOL2))
                                {
                                    EXGS ()
                                    Return (0x0D)
                                }
                                Else
                                {
                                    EXGS ()
                                    Return (0x00)
                                }
                            }
                        }
                        Else
                        {
                            EXGS ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXGS ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENGS ()
                    Store (0x01, LDN2)
                    Store (Zero, ACT2)
                    EXGS ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF3, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y14)
                        IRQ (Edge, ActiveLow, Shared, _Y15)
                            {}
                    })
                    CreateByteField (BUF3, \_SB.PCI0.UAR3._CRS._Y14._MIN, IOLO)
                    CreateByteField (BUF3, 0x03, IOHI)
                    CreateByteField (BUF3, \_SB.PCI0.UAR3._CRS._Y14._MAX, IORL)
                    CreateByteField (BUF3, 0x05, IORH)
                    CreateWordField (BUF3, \_SB.PCI0.UAR3._CRS._Y15._INT, IRQW)
                    ENGS ()
                    Store (0x01, LDN2)
                    Store (IOL2, IOLO)
                    Store (IOL2, IORL)
                    Store (IOH2, IOHI)
                    Store (IOH2, IORH)
                    Store (One, Local0)
                    ShiftLeft (Local0, IRQ2, IRQW)
                    EXGS ()
                    Return (BUF3)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENGS ()
                    Store (0x01, LDN2)
                    Store (One, ACT2)
                    Store (IOLO, IOL2)
                    Store (IOHI, IOH2)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, IRQ2)
                    EXGS ()
                }
            }

            Device (UAR4)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x04)
                Method (_STA, 0, NotSerialized)
                {
                    ENGS ()
                    Store (0x02, LDN2)
                    If (LEqual (VEN2, 0x19))
                    {
                        If (LGreaterEqual (DEV2, 0x03))
                        {
                            If (ACT2)
                            {
                                EXGS ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (IOH2, IOL2))
                                {
                                    EXGS ()
                                    Return (0x0D)
                                }
                                Else
                                {
                                    EXGS ()
                                    Return (0x00)
                                }
                            }
                        }
                        Else
                        {
                            EXGS ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXGS ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENGS ()
                    Store (0x02, LDN2)
                    Store (Zero, ACT2)
                    EXGS ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF4, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y16)
                        IRQ (Edge, ActiveLow, Shared, _Y17)
                            {}
                    })
                    CreateByteField (BUF4, \_SB.PCI0.UAR4._CRS._Y16._MIN, IOLO)
                    CreateByteField (BUF4, 0x03, IOHI)
                    CreateByteField (BUF4, \_SB.PCI0.UAR4._CRS._Y16._MAX, IORL)
                    CreateByteField (BUF4, 0x05, IORH)
                    CreateWordField (BUF4, \_SB.PCI0.UAR4._CRS._Y17._INT, IRQW)
                    ENGS ()
                    Store (0x02, LDN2)
                    Store (IOL2, IOLO)
                    Store (IOL2, IORL)
                    Store (IOH2, IOHI)
                    Store (IOH2, IORH)
                    Store (One, Local0)
                    ShiftLeft (Local0, IRQ2, IRQW)
                    EXGS ()
                    Return (BUF4)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENGS ()
                    Store (0x02, LDN2)
                    Store (One, ACT2)
                    Store (IOLO, IOL2)
                    Store (IOHI, IOH2)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, IRQ2)
                    EXGS ()
                }
            }

            Device (UAR5)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x05)
                Method (_STA, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x00, LDN3)
                    If (LEqual (VEN3, 0x19))
                    {
                        If (LEqual (DEV3, 0x02))
                        {
                            If (ACT3)
                            {
                                EXGT ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (IOH3, IOL3))
                                {
                                    EXGT ()
                                    Return (0x0D)
                                }
                                Else
                                {
                                    EXGT ()
                                    Return (0x00)
                                }
                            }
                        }
                        Else
                        {
                            EXGT ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXGT ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x00, LDN3)
                    Store (Zero, ACT3)
                    EXGT ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF5, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y18)
                        IRQ (Edge, ActiveLow, Shared, _Y19)
                            {}
                    })
                    CreateByteField (BUF5, \_SB.PCI0.UAR5._CRS._Y18._MIN, IOLO)
                    CreateByteField (BUF5, 0x03, IOHI)
                    CreateByteField (BUF5, \_SB.PCI0.UAR5._CRS._Y18._MAX, IORL)
                    CreateByteField (BUF5, 0x05, IORH)
                    CreateWordField (BUF5, \_SB.PCI0.UAR5._CRS._Y19._INT, IRQW)
                    ENGT ()
                    Store (0x00, LDN3)
                    Store (IOL3, IOLO)
                    Store (IOL3, IORL)
                    Store (IOH3, IOHI)
                    Store (IOH3, IORH)
                    Store (One, Local0)
                    And (IRQ3, 0x0F, IRQ3)
                    ShiftLeft (Local0, IRQ3, IRQW)
                    EXGT ()
                    Return (BUF5)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENGT ()
                    Store (0x00, LDN3)
                    Store (One, ACT3)
                    Store (IOLO, IOL3)
                    Store (IOHI, IOH3)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, Local0)
                    Or (Local0, 0x30, IRQ3)
                    EXGT ()
                }
            }

            Device (UAR6)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x06)
                Method (_STA, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x01, LDN3)
                    If (LEqual (VEN3, 0x19))
                    {
                        If (LEqual (DEV3, 0x02))
                        {
                            If (ACT3)
                            {
                                EXGT ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (IOH3, IOL3))
                                {
                                    EXGT ()
                                    Return (0x0D)
                                }
                                Else
                                {
                                    EXGT ()
                                    Return (0x00)
                                }
                            }
                        }
                        Else
                        {
                            EXGT ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXGT ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x01, LDN3)
                    Store (Zero, ACT3)
                    EXGT ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF6, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y1A)
                        IRQ (Edge, ActiveLow, Shared, _Y1B)
                            {}
                    })
                    CreateByteField (BUF6, \_SB.PCI0.UAR6._CRS._Y1A._MIN, IOLO)
                    CreateByteField (BUF6, 0x03, IOHI)
                    CreateByteField (BUF6, \_SB.PCI0.UAR6._CRS._Y1A._MAX, IORL)
                    CreateByteField (BUF6, 0x05, IORH)
                    CreateWordField (BUF6, \_SB.PCI0.UAR6._CRS._Y1B._INT, IRQW)
                    ENGT ()
                    Store (0x01, LDN3)
                    Store (IOL3, IOLO)
                    Store (IOL3, IORL)
                    Store (IOH3, IOHI)
                    Store (IOH3, IORH)
                    Store (One, Local0)
                    And (IRQ3, 0x0F, IRQ3)
                    ShiftLeft (Local0, IRQ3, IRQW)
                    EXGT ()
                    Return (BUF6)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENGT ()
                    Store (0x01, LDN3)
                    Store (One, ACT3)
                    Store (IOLO, IOL3)
                    Store (IOHI, IOH3)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, Local0)
                    Or (Local0, 0x30, IRQ3)
                    EXGT ()
                }
            }

            Device (UAR7)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x07)
                Method (_STA, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x02, LDN3)
                    If (LEqual (VEN3, 0x19))
                    {
                        If (LEqual (DEV3, 0x02))
                        {
                            If (ACT3)
                            {
                                EXGT ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (IOH3, IOL3))
                                {
                                    EXGT ()
                                    Return (0x0D)
                                }
                                Else
                                {
                                    EXGT ()
                                    Return (0x00)
                                }
                            }
                        }
                        Else
                        {
                            EXGT ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXGT ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x02, LDN3)
                    Store (Zero, ACT3)
                    EXGT ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF7, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y1C)
                        IRQ (Edge, ActiveLow, Shared, _Y1D)
                            {}
                    })
                    CreateByteField (BUF7, \_SB.PCI0.UAR7._CRS._Y1C._MIN, IOLO)
                    CreateByteField (BUF7, 0x03, IOHI)
                    CreateByteField (BUF7, \_SB.PCI0.UAR7._CRS._Y1C._MAX, IORL)
                    CreateByteField (BUF7, 0x05, IORH)
                    CreateWordField (BUF7, \_SB.PCI0.UAR7._CRS._Y1D._INT, IRQW)
                    ENGT ()
                    Store (0x02, LDN3)
                    Store (IOL3, IOLO)
                    Store (IOL3, IORL)
                    Store (IOH3, IOHI)
                    Store (IOH3, IORH)
                    Store (One, Local0)
                    And (IRQ3, 0x0F, IRQ3)
                    ShiftLeft (Local0, IRQ3, IRQW)
                    EXGT ()
                    Return (BUF7)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENGT ()
                    Store (0x02, LDN3)
                    Store (One, ACT3)
                    Store (IOLO, IOL3)
                    Store (IOHI, IOH3)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, Local0)
                    Or (Local0, 0x30, IRQ3)
                    EXGT ()
                }
            }

            Device (UAR8)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x08)
                Method (_STA, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x03, LDN3)
                    If (LEqual (VEN3, 0x19))
                    {
                        If (LEqual (DEV3, 0x02))
                        {
                            If (ACT3)
                            {
                                EXGT ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (IOH3, IOL3))
                                {
                                    EXGT ()
                                    Return (0x0D)
                                }
                                Else
                                {
                                    EXGT ()
                                    Return (0x00)
                                }
                            }
                        }
                        Else
                        {
                            EXGT ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXGT ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENGT ()
                    Store (0x03, LDN3)
                    Store (Zero, ACT3)
                    EXGT ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF8, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y1E)
                        IRQ (Edge, ActiveLow, Shared, _Y1F)
                            {}
                    })
                    CreateByteField (BUF8, \_SB.PCI0.UAR8._CRS._Y1E._MIN, IOLO)
                    CreateByteField (BUF8, 0x03, IOHI)
                    CreateByteField (BUF8, \_SB.PCI0.UAR8._CRS._Y1E._MAX, IORL)
                    CreateByteField (BUF8, 0x05, IORH)
                    CreateWordField (BUF8, \_SB.PCI0.UAR8._CRS._Y1F._INT, IRQW)
                    ENGT ()
                    Store (0x03, LDN3)
                    Store (IOL3, IOLO)
                    Store (IOL3, IORL)
                    Store (IOH3, IOHI)
                    Store (IOH3, IORH)
                    Store (One, Local0)
                    And (IRQ3, 0x0F, IRQ3)
                    ShiftLeft (Local0, IRQ3, IRQW)
                    EXGT ()
                    Return (BUF8)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04F8,             // Range Minimum
                            0x04F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x04E8,             // Range Minimum
                            0x04E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQ (Edge, ActiveLow, Shared, )
                            {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENGT ()
                    Store (0x03, LDN3)
                    Store (One, ACT3)
                    Store (IOLO, IOL3)
                    Store (IOHI, IOH3)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, Local0)
                    Or (Local0, 0x30, IRQ3)
                    EXGT ()
                }
            }

            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, 0x04)
                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._PRW, 0, NotSerialized)
            {
                Return (Package (0x02)
                {
                    0x09, 
                    0x05
                })
            }

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

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

            Device (SRCM)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x88)
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (\_SB.PCI0.P2PE.SCLS, 0x04))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0xF0000000,         // Address Base
                            0x00001000,         // Address Length
                            )
                    })
                    Return (BUF0)
                }
            }
        }

        Device (PCI1)
        {
            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, EisaId ("PNP0A03"))
            Name (_UID, 0x04)
            Name (_BBN, 0x80)
            Name (_SEG, 0x00)
            Name (UIDB, Buffer (0x10) {})
            CreateDWordField (UIDB, 0x00, UID0)
            CreateDWordField (UIDB, 0x04, UID1)
            CreateDWordField (UIDB, 0x08, UID2)
            CreateDWordField (UIDB, 0x0C, UID3)
            Name (OSCB, Buffer (0x0C) {})
            CreateDWordField (OSCB, 0x00, CAP0)
            CreateDWordField (OSCB, 0x04, CAP1)
            CreateDWordField (OSCB, 0x08, CAP2)
            Name (CHKU, 0x00)
            Name (PNHP, 0x00)
            Name (PNPM, 0x00)
            Method (_OSC, 4, NotSerialized)
            {
                Store (Arg0, UIDB)
                If (LNotEqual (UID0, 0x33DB4D5B))
                {
                    Store (One, CHKU)
                }

                If (LNotEqual (UID1, 0x401C1FF7))
                {
                    Store (One, CHKU)
                }

                If (LNotEqual (UID2, 0x41745796))
                {
                    Store (One, CHKU)
                }

                If (LNotEqual (UID3, 0x66D73DC0))
                {
                    Store (One, CHKU)
                }

                Store (Arg3, OSCB)
                If (LEqual (CHKU, 0x00))
                {
                    And (CAP2, 0x01, PNHP)
                    And (CAP2, 0x04, PNPM)
                    If (LNotEqual (PNHP, 0x00))
                    {
                        Store (0x00, \_SB.PCI0.VT86.SBHP)
                        Store (0x00, G89E)
                        Store (0x01, HPFL)
                    }
                    Else
                    {
                        Store (0x01, \_SB.PCI0.VT86.SBHP)
                        Store (0x01, G89E)
                        Store (0x00, HPFL)
                    }

                    If (LNotEqual (PNPM, 0x00))
                    {
                        Store (0x00, \_SB.PCI0.VT86.SBPM)
                        Store (0x00, G89E)
                        Store (0x01, PMFL)
                    }
                    Else
                    {
                        Store (0x01, \_SB.PCI0.VT86.SBPM)
                        Store (0x01, G89E)
                        Store (0x00, PMFL)
                    }

                    And (CAP2, 0xFFFFFFFD, CAP2)
                    And (CAP0, 0x00, CAP0)
                    Return (OSCB)
                }
                Else
                {
                    Or (CAP0, 0x04, CAP0)
                    Return (OSCB)
                }
            }

            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF1, ResourceTemplate ()
                {
                    WordBusNumber (ResourceProducer, MinNotFixed, MaxNotFixed, PosDecode,
                        0x0000,             // Granularity
                        0x0080,             // Range Minimum
                        0x00FF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0080,             // 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
                        ,, _Y21, 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
                        0x00100000,         // Range Minimum
                        0xFEBFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0xFEB00000,         // Length
                        ,, _Y20, AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (BUF1, \_SB.PCI1._CRS._Y20._MAX, EMAX)
                CreateDWordField (BUF1, \_SB.PCI1._CRS._Y20._MIN, EMAI)
                CreateDWordField (BUF1, \_SB.PCI1._CRS._Y20._LEN, EMAL)
                CreateWordField (BUF1, \_SB.PCI1._CRS._Y21._MAX, EIAX)
                CreateWordField (BUF1, \_SB.PCI1._CRS._Y21._MIN, EIAI)
                CreateWordField (BUF1, \_SB.PCI1._CRS._Y21._LEN, EIAL)
                Store (SMB1, EMAI)
                Store (SMB2, EMAX)
                Subtract (EMAX, EMAI, EMAL)
                Add (EMAL, 0x01, EMAL)
                Store (SMB3, EIAI)
                Store (SMB4, EIAX)
                Subtract (EIAX, EIAI, EIAL)
                Add (EIAL, 0x01, EIAL)
                Return (BUF1)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (LNotEqual (\_SB.PCI0.P2PE.SCLS, 0x04))
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (0x00)
                }
            }

            Name (PICE, Package (0x08)
            {
                Package (0x04)
                {
                    0xFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK9, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK9, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK9, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK9, 
                    0x00
                }, 

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

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

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

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x03, 
                    \_SB.PCI0.LNKB, 
                    0x00
                }
            })
            Name (APIE, Package (0x08)
            {
                Package (0x04)
                {
                    0xFFFF, 
                    0x00, 
                    0x00, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x01, 
                    0x00, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x02, 
                    0x00, 
                    0x00
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x03, 
                    0x00, 
                    0x00
                }, 

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

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

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

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x03, 
                    0x00, 
                    0x11
                }
            })
            Name (APXE, Package (0x08)
            {
                Package (0x04)
                {
                    0xFFFF, 
                    0x00, 
                    0x00, 
                    0x14
                }, 

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

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

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

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

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

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

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x03, 
                    0x00, 
                    0x11
                }
            })
            Method (_PRT, 0, NotSerialized)
            {
                If (LNot (PICF))
                {
                    Return (PICE)
                }
                Else
                {
                    If (LNotEqual (\_SB.PCI0.VT86.REBD, 0x00))
                    {
                        Return (APXE)
                    }
                    Else
                    {
                        Return (APIE)
                    }
                }
            }

            Device (PE5C)
            {
                Name (_ADR, 0x00)
                OperationRegion (PE5R, PCI_Config, 0x00, 0x0100)
                Field (PE5R, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x22), 
                    R0ML,   16, 
                            Offset (0x26), 
                    R0PL,   16
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI1.PE5C.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        If (LEqual (\_SB.PCI1.PE5C.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }

                Name (UIDB, Buffer (0x10) {})
                CreateDWordField (UIDB, 0x00, UID0)
                CreateDWordField (UIDB, 0x04, UID1)
                CreateDWordField (UIDB, 0x08, UID2)
                CreateDWordField (UIDB, 0x0C, UID3)
                Name (OSCB, Buffer (0x14) {})
                CreateDWordField (OSCB, 0x00, CAP0)
                CreateDWordField (OSCB, 0x04, CAP1)
                CreateDWordField (OSCB, 0x08, CAP2)
                CreateDWordField (OSCB, 0x0C, CAP3)
                CreateDWordField (OSCB, 0x10, CAP4)
                Name (CHKU, 0x00)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (Package (0x02)
                    {
                        0x12, 
                        0x05
                    })
                }

                Name (PIC5, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x01, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }
                })
                Name (API5, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x01, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        0x00, 
                        0x00
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (PIC5)
                    }
                    Else
                    {
                        Return (API5)
                    }
                }

                Device (S5F0)
                {
                    Name (_ADR, 0x00)
                    Name (_SUN, 0x05)
                }

                Device (S5F1)
                {
                    Name (_ADR, 0x01)
                    Name (_SUN, 0x05)
                }

                Device (S5F2)
                {
                    Name (_ADR, 0x02)
                    Name (_SUN, 0x05)
                }

                Device (S5F3)
                {
                    Name (_ADR, 0x03)
                    Name (_SUN, 0x05)
                }

                Device (S5F4)
                {
                    Name (_ADR, 0x04)
                    Name (_SUN, 0x05)
                }

                Device (S5F5)
                {
                    Name (_ADR, 0x05)
                    Name (_SUN, 0x05)
                }

                Device (S5F6)
                {
                    Name (_ADR, 0x06)
                    Name (_SUN, 0x05)
                }

                Device (S5F7)
                {
                    Name (_ADR, 0x07)
                    Name (_SUN, 0x05)
                }
            }

            Device (PE6C)
            {
                Name (_ADR, 0x01)
                OperationRegion (PE6R, PCI_Config, 0x00, 0x0100)
                Field (PE6R, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x22), 
                    R1ML,   16, 
                            Offset (0x26), 
                    R1PL,   16
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI1.PE6C.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        If (LEqual (\_SB.PCI1.PE6C.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }

                Name (UIDB, Buffer (0x10) {})
                CreateDWordField (UIDB, 0x00, UID0)
                CreateDWordField (UIDB, 0x04, UID1)
                CreateDWordField (UIDB, 0x08, UID2)
                CreateDWordField (UIDB, 0x0C, UID3)
                Name (OSCB, Buffer (0x14) {})
                CreateDWordField (OSCB, 0x00, CAP0)
                CreateDWordField (OSCB, 0x04, CAP1)
                CreateDWordField (OSCB, 0x08, CAP2)
                CreateDWordField (OSCB, 0x0C, CAP3)
                CreateDWordField (OSCB, 0x10, CAP4)
                Name (CHKU, 0x00)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (Package (0x02)
                    {
                        0x12, 
                        0x05
                    })
                }

                Name (PIC6, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x01, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        \_SB.PCI0.LNK9, 
                        0x00
                    }
                })
                Name (API6, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x01, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        0x00, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        0x00, 
                        0x00
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (PIC6)
                    }
                    Else
                    {
                        Return (API6)
                    }
                }

                Device (S6F0)
                {
                    Name (_ADR, 0x00)
                    Name (_SUN, 0x06)
                }

                Device (S6F1)
                {
                    Name (_ADR, 0x01)
                    Name (_SUN, 0x06)
                }

                Device (S6F2)
                {
                    Name (_ADR, 0x02)
                    Name (_SUN, 0x06)
                }

                Device (S6F3)
                {
                    Name (_ADR, 0x03)
                    Name (_SUN, 0x06)
                }

                Device (S6F4)
                {
                    Name (_ADR, 0x04)
                    Name (_SUN, 0x06)
                }

                Device (S6F5)
                {
                    Name (_ADR, 0x05)
                    Name (_SUN, 0x06)
                }

                Device (S6F6)
                {
                    Name (_ADR, 0x06)
                    Name (_SUN, 0x06)
                }

                Device (S6F7)
                {
                    Name (_ADR, 0x07)
                    Name (_SUN, 0x06)
                }
            }

            Device (AZAC)
            {
                Name (_ADR, 0x00010000)
                OperationRegion (AZAR, PCI_Config, 0x00, 0x0100)
                Field (AZAR, ByteAcc, NoLock, Preserve)
                {
                    VID,    16, 
                            Offset (0x04), 
                    CMDR,   3, 
                            Offset (0x12), 
                    NPMX,   16
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LNotEqual (\_SB.PCI1.AZAC.VID, 0x1106))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        If (LEqual (\_SB.PCI1.AZAC.CMDR, 0x00))
                        {
                            Return (0x0D)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                }

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

        Device (MEM)
        {
            Name (_HID, EisaId ("PNP0C01"))
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    Memory32Fixed (ReadOnly,
                        0x000F0000,         // Address Base
                        0x00010000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFE800000,         // Address Base
                        0x00000100,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEA00000,         // Address Base
                        0x00000100,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00010000,         // Address Length
                        _Y22)
                    Memory32Fixed (ReadWrite,
                        0xFFFF0000,         // Address Base
                        0x00010000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x000A0000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00100000,         // Address Base
                        0x00000000,         // Address Length
                        _Y23)
                    Memory32Fixed (ReadWrite,
                        0xFEC00000,         // Address Base
                        0x00100000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEE00000,         // Address Base
                        0x00100000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFFF80000,         // Address Base
                        0x00070000,         // Address Length
                        )
                })
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y22._BAS, ACMM)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y22._LEN, ASSM)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y23._LEN, EXTM)
                Subtract (AMEM, 0x00100000, EXTM)
                Store (AMEM, ACMM)
                And (AMEM, 0x000FFFFF, Local0)
                Subtract (0x00100000, Local0, ASSM)
                Return (BUF0)
            }
        }

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