/*
 * Intel ACPI Component Architecture
 * AML/ASL+ Disassembler version 20210930 (32-bit version)
 * Copyright (c) 2000 - 2021 Intel Corporation
 * 
 * Disassembling to symbolic ASL+ operators
 *
 * Disassembly of DSDT.bin, Sun Oct 31 00:48:53 2021
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00004C22 (19490)
 *     Revision         0x01 **** 32-bit table (V1), no 64-bit math support
 *     Checksum         0x8C
 *     OEM ID           "NVIDIA"
 *     OEM Table ID     "AWRDACPI"
 *     OEM Revision     0x00001000 (4096)
 *     Compiler ID      "MSFT"
 *     Compiler Version 0x0100000E (16777230)
 */
DefinitionBlock ("", "DSDT", 1, "NVIDIA", "AWRDACPI", 0x00001000)
{
    Scope (\_PR)
    {
        Processor (\_PR.CPU0, 0x00, 0x00000000, 0x00){}
    }

    Name (\_S0, Package (0x04)  // _S0_: S0 System State
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S1, Package (0x04)  // _S1_: S1 System State
    {
        0x01, 
        0x01, 
        0x00, 
        0x00
    })
    Name (\_S4, Package (0x04)  // _S4_: S4 System State
    {
        0x06, 
        0x06, 
        0x00, 
        0x00
    })
    Name (\_S5, Package (0x04)  // _S5_: S5 System State
    {
        0x07, 
        0x07, 
        0x00, 
        0x00
    })
    OperationRegion (\DEBG, SystemIO, 0x80, 0x01)
    Field (\DEBG, ByteAcc, NoLock, Preserve)
    {
        DBG1,   8
    }

    OperationRegion (Z002, SystemIO, 0x21, 0x01)
    Field (Z002, ByteAcc, NoLock, Preserve)
    {
        Z000,   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 (\PM1S, SystemIO, 0x4000, 0x02)
    Field (\PM1S, ByteAcc, NoLock, Preserve)
    {
        Offset (0x01), 
        PBTS,   1, 
            ,   1, 
        RTCS,   1, 
            ,   4, 
        WAKS,   1
    }

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

    OperationRegion (\STUS, SystemIO, 0x4400, 0x04)
    Field (\STUS, ByteAcc, NoLock, Preserve)
    {
        G_ST,   32
    }

    OperationRegion (\SMIS, SystemIO, 0x4020, 0x04)
    Field (\SMIS, ByteAcc, NoLock, Preserve)
    {
        P_20,   32
    }

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

    OperationRegion (\GP1, SystemIO, 0x44C0, 0x32)
    Field (\GP1, ByteAcc, NoLock, Preserve)
    {
        GP00,   8, 
        GP01,   8, 
        GP02,   8, 
        GP03,   8, 
        GP04,   8, 
        GP05,   8, 
        GP06,   8, 
        GP07,   8, 
        GP08,   8, 
        GP09,   8, 
        GP10,   8, 
        GP11,   8, 
        GP12,   8, 
        GP13,   8, 
        GP14,   8, 
        GP15,   8, 
        GP16,   8, 
        GP17,   8, 
        GP18,   8, 
        GP19,   8, 
        GP20,   8, 
        GP21,   8, 
        GP22,   8, 
        Offset (0x18), 
        GP24,   8, 
        GP25,   8, 
        GP26,   8, 
        GP27,   8, 
        GP28,   8, 
        GP29,   8, 
        GP30,   8, 
        GP31,   8, 
        GP32,   8, 
        GP33,   8, 
        GP34,   8, 
        GP35,   8, 
        GP36,   8, 
        GP37,   8, 
        GP38,   8, 
        GP39,   8, 
        GP40,   8, 
        GP41,   8, 
        GP42,   8, 
        GP43,   8, 
        GP44,   8, 
        GP45,   8, 
        GP46,   8, 
        GP47,   8, 
        GP48,   8, 
        GP49,   8
    }

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

        Local0 = (SizeOf (Arg0) + 0x01)
        Name (BUF0, Buffer (Local0){})
        Name (BUF1, Buffer (Local0){})
        BUF0 = Arg0
        BUF1 = Arg1
        While (Local0)
        {
            Local0--
            If ((DerefOf (BUF0 [Local0]) != DerefOf (BUF1 [Local0]
                )))
            {
                Return (Zero)
            }
        }

        Return (One)
    }

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

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

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

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

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

    Method (SPKR, 1, NotSerialized)
    {
        Local0 = S1B /* \S1B_ */
        CTRL = 0xB6
        CNT2 = 0x55
        CNT2 = 0x03
        Local2 = Arg0
        While ((Local2 > 0x00))
        {
            S1B |= 0x03
            Local3 = 0x5FFF
            While ((Local3 > 0x00))
            {
                Local3--
            }

            S1B &= 0xFC
            Local3 = 0x0EFF
            While ((Local3 > 0x00))
            {
                Local3--
            }

            Local2--
        }

        S1B = Local0
    }

    Scope (\)
    {
        Name (PICF, 0x00)
        Method (_PIC, 1, NotSerialized)  // _PIC: Interrupt Model
        {
            PICF = Arg0
        }
    }

    Name (SID4, 0x00)
    Name (SLG0, 0x00)
    Name (SLG1, 0x00)
    Name (SLG2, 0x00)
    Name (SLG3, 0x00)
    Name (SLG4, 0x00)
    Name (SLG5, 0x00)
    Name (SLG6, 0x00)
    Name (SLG7, 0x00)
    Name (SLG8, 0x00)
    Name (SLG9, 0x00)
    Name (SLGA, 0x00)
    Name (SID5, 0x00)
    Name (SSM0, 0x00)
    Name (SSM1, 0x00)
    Name (SSM2, 0x00)
    Name (SSM3, 0x00)
    Name (SSM4, 0x00)
    Name (SUA0, 0x00)
    Name (SUB0, 0x00)
    Name (SX, 0x00)
    Name (SFLG, 0x00)
    Name (SID0, 0x00)
    Name (SID1, 0x00)
    Name (SID2, 0x00)
    Name (SID3, 0x00)
    Method (\_PTS, 1, NotSerialized)  // _PTS: Prepare To Sleep
    {
        Local0 = Arg0
        SALD (Local0)
        Local0 = Arg0
        SX = Local0
        Local0 = (Arg0 | 0xF0)
        DBG1 = Local0
        OSTP ()
        SID0 = \_SB.PCI0.IDE0.ID20
        SID1 = \_SB.PCI0.IDE0.IDTS
        SID2 = \_SB.PCI0.IDE0.IDTP
        SID3 = \_SB.PCI0.IDE0.ID22
        SID4 = \_SB.PCI0.IDE0.UMSS
        SID5 = \_SB.PCI0.IDE0.UMSP
        If ((Arg0 == 0x01))
        {
            Local0 = \_SB.PCI0.CTL0
            Local0 |= 0x04000000
            \_SB.PCI0.CTL0 = Local0
        }

        If ((Arg0 == 0x03))
        {
            Local0 = \_SB.PCI0.CTL0
            Local0 |= 0x04000000
            \_SB.PCI0.CTL0 = Local0
        }

        If ((Arg0 == 0x05))
        {
            If ((OSFL != 0x00))
            {
                Sleep (0x01F4)
            }
        }
    }

    Method (\_WAK, 1, NotSerialized)  // _WAK: Wake
    {
        SALD (0x00)
        DBG1 = 0xFF
        SFLG = 0x00
        If ((RTCW == 0x00))
        {
            Notify (\_SB.PWRB, 0x02) // Device Wake
        }

        Notify (\_SB.PCI0.USB0, 0x00) // Bus Check
        Notify (\_SB.PCI0.USB1, 0x00) // Bus Check
        Local0 = \_SB.PCI0.CTL0
        Local0 &= 0xFBFFFFFF
        \_SB.PCI0.CTL0 = Local0
        If ((OSFL >= 0x01))
        {
            \_SB.PCI0.SMB0.SMPM = 0x00
            \_SB.PCI0.SMB0.SB1 = 0x5000
            \_SB.PCI0.SMB0.SB2 = 0x5100
        }
    }

    Scope (\_SI)
    {
        Method (_MSG, 1, NotSerialized)  // _MSG: Message
        {
            Debug = "==== MSG Working ===="
        }

        Method (_SST, 1, NotSerialized)  // _SST: System Status
        {
            Debug = "==== SST Working ===="
        }
    }

    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)
    {
        INDS,   8, 
        DATS,   8
    }

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

    Method (STOS, 3, NotSerialized)
    {
        Local0 = GBYT (0x4E)
        Local1 = (Local0 | 0x01)
        SBYT (0x4E, Local1)
        SBYT (0x55, Arg1)
        SBYT (0x56, Arg0)
        SBYT (0x4E, Local0)
    }

    Method (STHY, 3, NotSerialized)
    {
        Local0 = GBYT (0x4E)
        Local1 = (Local0 | 0x01)
        SBYT (0x4E, Local1)
        SBYT (0x53, Arg1)
        SBYT (0x54, Arg0)
        SBYT (0x4E, Local0)
    }

    Method (RTMP, 0, NotSerialized)
    {
        Local0 = GBYT (0x4E)
        Local1 = (Local0 | 0x01)
        SBYT (0x4E, Local1)
        Local1 = GBYT (0x50)
        Local2 = GBYT (0x51)
        Local1 <<= 0x08
        Local3 = (Local1 | Local2)
        Local3 >>= 0x07
        Local1 = (Local3 << 0x02)
        Local3 += Local1
        Local3 += 0x0AAC
        If ((Local3 > 0x0E8A))
        {
            Local3 = 0x0AAC
        }

        SBYT (0x4E, Local0)
        Return (Local3)
    }

    Method (SBYT, 2, NotSerialized)
    {
        INDS = Arg0
        DATS = Arg1
    }

    Method (GBYT, 1, NotSerialized)
    {
        INDS = Arg0
        Local7 = DATS /* \DATS */
        Return (Local7)
    }

    Scope (\_TZ)
    {
        Device (FAN)
        {
            Name (_HID, EisaId ("PNP0C0B") /* Fan (Thermal Solution) */)  // _HID: Hardware ID
            Method (_INI, 0, NotSerialized)  // _INI: Initialize
            {
                CTOS = TP1H /* \TP1H */
                CTHY = TP1L /* \TP1L */
            }
        }

        ThermalZone (THRM)
        {
            Name (_AL0, Package (0x01)  // _ALx: Active List, x=0-9
            {
                FAN
            })
            Method (_AC0, 0, NotSerialized)  // _ACx: Active Cooling, x=0-9
            {
                If (Local7 = (PLCY | PLCY) /* \PLCY */)
                {
                    Return (TP2H) /* \TP2H */
                }
                Else
                {
                    Return (TP1H) /* \TP1H */
                }
            }

            Name (_PSL, Package (0x01)  // _PSL: Passive List
            {
                \_PR.CPU0
            })
            Name (_TSP, 0x3C)  // _TSP: Thermal Sampling Period
            Name (_TC1, 0x04)  // _TC1: Thermal Constant 1
            Name (_TC2, 0x03)  // _TC2: Thermal Constant 2
            Method (_PSV, 0, NotSerialized)  // _PSV: Passive Temperature
            {
                If (Local7 = (PLCY | PLCY) /* \PLCY */)
                {
                    Return (TP1H) /* \TP1H */
                }
                Else
                {
                    Return (TP2H) /* \TP2H */
                }
            }

            Method (_CRT, 0, NotSerialized)  // _CRT: Critical Temperature
            {
                Return (TRPC) /* \TRPC */
            }

            Method (_TMP, 0, NotSerialized)  // _TMP: Temperature
            {
                Local6 = (SENF & 0x01)
                If ((Local6 == 0x01))
                {
                    Return (RTMP ())
                }
                Else
                {
                    Return (0x0B86)
                }
            }

            Method (_SCP, 1, NotSerialized)  // _SCP: Set Cooling Policy
            {
                If (Arg0)
                {
                    PLCY = One
                }
                Else
                {
                    PLCY = Zero
                }

                Notify (\_TZ.THRM, 0x81) // Thermal Trip Point Change
            }

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

    Scope (\_GPE)
    {
        Method (_L00, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.HUB0, 0x02) // Device Wake
        }

        Method (_L03, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.UAR1, 0x02) // Device Wake
        }

        Method (_L0B, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.MMAC, 0x02) // Device Wake
        }

        Method (_L0D, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.USB0, 0x02) // Device Wake
        }

        Method (_L0C, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.USB1, 0x02) // Device Wake
        }

        Method (_L05, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.USB2, 0x02) // Device Wake
        }

        Method (_L0F, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.F139, 0x02) // Device Wake
        }

        Method (_L0A, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.HUB1, 0x02) // Device Wake
        }

        Method (_L07, 0, NotSerialized)  // _Lxx: Level-Triggered GPE, xx=0x00-0xFF
        {
            Notify (\_SB.PCI0.MMCI, 0x02) // Device Wake
        }
    }

    Scope (\_SB)
    {
        Device (PMIO)
        {
            Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
            Name (_UID, 0x03)  // _UID: Unique ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (IODM, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x00,               // Alignment
                        0x00,               // Length
                        )
                })
                Name (IORT, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        _Y00)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        _Y01)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        _Y02)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        _Y03)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        _Y04)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        _Y05)
                })
                CreateWordField (IORT, \_SB.PMIO._CRS._Y00._MIN, I1MN)  // _MIN: Minimum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y00._MAX, I1MX)  // _MAX: Maximum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y01._MIN, I2MN)  // _MIN: Minimum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y01._MAX, I2MX)  // _MAX: Maximum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y02._MIN, I3MN)  // _MIN: Minimum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y02._MAX, I3MX)  // _MAX: Maximum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y03._MIN, I4MN)  // _MIN: Minimum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y03._MAX, I4MX)  // _MAX: Maximum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y04._MIN, I5MN)  // _MIN: Minimum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y04._MAX, I5MX)  // _MAX: Maximum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y05._MIN, I6MN)  // _MIN: Minimum Base Address
                CreateWordField (IORT, \_SB.PMIO._CRS._Y05._MAX, I6MX)  // _MAX: Maximum Base Address
                I1MN = (PMBR & 0xFFFC)
                I1MX = I1MN /* \_SB_.PMIO._CRS.I1MN */
                Local0 = (I1MN + 0x80)
                I2MN = Local0
                I2MX = Local0
                I3MN = (NVSB & 0xFFFC)
                I3MX = I3MN /* \_SB_.PMIO._CRS.I3MN */
                Local0 = (I3MN + 0x80)
                I4MN = Local0
                I4MX = Local0
                I5MN = (ANLG & 0xFFFC)
                I5MX = I5MN /* \_SB_.PMIO._CRS.I5MN */
                Local0 = (I5MN + 0x80)
                I6MN = Local0
                I6MX = Local0
                If (I1MN)
                {
                    Local0 = IORT /* \_SB_.PMIO._CRS.IORT */
                }
                Else
                {
                    Local0 = IODM /* \_SB_.PMIO._CRS.IODM */
                }

                Return (Local0)
            }
        }

        Device (SMIO)
        {
            Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
            Name (_UID, 0x04)  // _UID: Unique ID
            Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
            {
                IO (Decode16,
                    0x5000,             // Range Minimum
                    0x5000,             // Range Maximum
                    0x01,               // Alignment
                    0x40,               // Length
                    )
                IO (Decode16,
                    0x5100,             // Range Minimum
                    0x5100,             // Range Maximum
                    0x01,               // Alignment
                    0x40,               // Length
                    )
            })
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */)  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Return (0x0B)
            }
        }

        Device (MEM)
        {
            Name (_HID, EisaId ("PNP0C01") /* System Board */)  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (BUF0, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0x000F0000,         // Address Base
                        0x00004000,         // Address Length
                        _Y07)
                    Memory32Fixed (ReadWrite,
                        0x000F4000,         // Address Base
                        0x00004000,         // Address Length
                        _Y08)
                    Memory32Fixed (ReadWrite,
                        0x000F8000,         // Address Base
                        0x00004000,         // Address Length
                        _Y09)
                    Memory32Fixed (ReadWrite,
                        0x000FC000,         // Address Base
                        0x00004000,         // Address Length
                        _Y0A)
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00010000,         // Address Length
                        _Y06)
                    Memory32Fixed (ReadWrite,
                        0xFFFF0000,         // Address Base
                        0x00010000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x000A0000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00100000,         // Address Base
                        0x00000000,         // Address Length
                        _Y0B)
                    Memory32Fixed (ReadWrite,
                        0xFEC00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEE00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                })
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y06._BAS, ACMM)  // _BAS: Base Address
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y07._BAS, RMA1)  // _BAS: Base Address
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y07._LEN, RSS1)  // _LEN: Length
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y08._BAS, RMA2)  // _BAS: Base Address
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y08._LEN, RSS2)  // _LEN: Length
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y09._BAS, RMA3)  // _BAS: Base Address
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y09._LEN, RSS3)  // _LEN: Length
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0A._BAS, RMA4)  // _BAS: Base Address
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0A._LEN, RSS4)  // _LEN: Length
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0B._LEN, EXTM)  // _LEN: Length
                EXTM = (AMEM - 0x00100000)
                If ((ROM1 != Zero))
                {
                    RMA2 = RMA1 /* \_SB_.MEM_._CRS.RMA1 */
                    Local0 = (ROM1 << 0x08)
                    RMA1 = Local0
                    Local0 = (RMS1 << 0x08)
                    RSS1 = Local0
                    RSS2 = 0x8000
                }

                If ((ROM2 != Zero))
                {
                    RMA3 = RMA2 /* \_SB_.MEM_._CRS.RMA2 */
                    Local0 = (ROM2 << 0x08)
                    RMA2 = Local0
                    Local0 = (RMS2 << 0x08)
                    RSS2 = Local0
                    RSS3 = 0xC000
                }

                If ((ROM3 != Zero))
                {
                    RMA4 = RMA3 /* \_SB_.MEM_._CRS.RMA3 */
                    Local0 = (ROM3 << 0x08)
                    RMA3 = Local0
                    Local0 = (RMS3 << 0x08)
                    RSS3 = Local0
                    RSS4 = 0x00010000
                }

                ACMM = AMEM /* \AMEM */
                Return (BUF0) /* \_SB_.MEM_._CRS.BUF0 */
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03") /* PCI Bus */)  // _HID: Hardware ID
            Name (_ADR, 0x00)  // _ADR: Address
            Name (_UID, 0x01)  // _UID: Unique ID
            Name (_BBN, 0x00)  // _BBN: BIOS Bus Number
            Name (NATA, Package (0x01)
            {
                0x00090000
            })
            Method (_S3D, 0, NotSerialized)  // _S3D: S3 Device State
            {
                If ((OSFL == 0x02))
                {
                    Return (0x02)
                }
                Else
                {
                    Return (0x03)
                }
            }

            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Return (0x0F)
            }

            OperationRegion (LDT3, PCI_Config, 0x6C, 0x04)
            Field (LDT3, DWordAcc, NoLock, Preserve)
            {
                UCFG,   32
            }

            OperationRegion (S2KC, PCI_Config, 0xE4, 0x04)
            Field (S2KC, DWordAcc, NoLock, Preserve)
            {
                CTL0,   32
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (BUF0, ResourceTemplate ()
                {
                    WordBusNumber (ResourceConsumer, MinNotFixed, MaxNotFixed, PosDecode,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x00FF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0100,             // Length
                        ,, )
                    IO (Decode16,
                        0x0CF8,             // Range Minimum
                        0x0CF8,             // Range Maximum
                        0x01,               // Alignment
                        0x08,               // Length
                        )
                    IO (Decode16,
                        0x0CF0,             // Range Minimum
                        0x0CF0,             // Range Maximum
                        0x01,               // Alignment
                        0x04,               // Length
                        )
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x0CFE,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0CF8,             // Length
                        ,, , TypeStatic, DenseTranslation)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0D00,             // Range Minimum
                        0xFFFF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0xF300,             // Length
                        ,, , TypeStatic, DenseTranslation)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000A0000,         // Range Minimum
                        0x000BFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00020000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x000C0000,         // Range Minimum
                        0x000DFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00020000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x00100000,         // Range Minimum
                        0xFEBFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0xFFF00000,         // Length
                        ,, _Y0C, AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y0C._MIN, TCMM)  // _MIN: Minimum Base Address
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y0C._LEN, TOMM)  // _LEN: Length
                TCMM = (AMEM + 0x00010000)
                TOMM = (0xFEC00000 - TCMM) /* \_SB_.PCI0._CRS.TCMM */
                Return (BUF0) /* \_SB_.PCI0._CRS.BUF0 */
            }

            Name (PICM, Package (0x14)
            {
                Package (0x04)
                {
                    0x0001FFFF, 
                    0x00, 
                    LSMB, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.LUBA, 
                    0x00
                }, 

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

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

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

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

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

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

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x00, 
                    \_SB.PCI0.LFIR, 
                    0x00
                }, 

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

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

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

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

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

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

                Package (0x04)
                {
                    0x001EFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001EFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001EFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001EFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }
            })
            Name (APIC, Package (0x0C)
            {
                Package (0x04)
                {
                    0x0001FFFF, 
                    0x00, 
                    \_SB.PCI0.APCS, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.APCF, 
                    0x00
                }, 

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

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

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

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

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

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

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x00, 
                    \_SB.PCI0.APCM, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x00, 
                    \_SB.PCI0.APCZ, 
                    0x00
                }
            })
            Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
            {
                If (!PICF)
                {
                    Return (PICM) /* \_SB_.PCI0.PICM */
                }
                Else
                {
                    Return (APIC) /* \_SB_.PCI0.APIC */
                }
            }

            Device (HUB0)
            {
                Name (_ADR, 0x00080000)  // _ADR: Address
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    Return (0x0F)
                }

                Name (PICM, Package (0x1C)
                {
                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x00, 
                        \_SB.PCI0.LNK3, 
                        0x00
                    }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Package (0x04)
                    {
                        0x000CFFFF, 
                        0x03, 
                        \_SB.PCI0.LNK4, 
                        0x00
                    }
                })
                Name (APIC, Package (0x1C)
                {
                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x00, 
                        \_SB.PCI0.APC3, 
                        0x00
                    }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Package (0x04)
                    {
                        0x000CFFFF, 
                        0x03, 
                        \_SB.PCI0.APC4, 
                        0x00
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    If (!PICF)
                    {
                        Return (PICM) /* \_SB_.PCI0.HUB0.PICM */
                    }
                    Else
                    {
                        Return (APIC) /* \_SB_.PCI0.HUB0.APIC */
                    }
                }

                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x00, 
                    0x05
                })
            }

            Device (IDE0)
            {
                Name (_ADR, 0x00090000)  // _ADR: Address
                OperationRegion (A090, PCI_Config, 0x50, 0x18)
                Field (A090, DWordAcc, NoLock, Preserve)
                {
                    ID20,   16, 
                    Offset (0x08), 
                    IDTS,   16, 
                    IDTP,   16, 
                    ID22,   32, 
                    UMSS,   16, 
                    UMSP,   16
                }

                Name (IDEP, Buffer (0x14){})
                Name (IDES, Buffer (0x14){})
                Method (GTM, 1, NotSerialized)
                {
                    If ((SX == 0x01))
                    {
                        If (OSFL)
                        {
                            Z000 |= 0x01
                        }
                    }

                    If ((Arg0 == 0x00))
                    {
                        Local0 = IDTP /* \_SB_.PCI0.IDE0.IDTP */
                        Local1 = UMSP /* \_SB_.PCI0.IDE0.UMSP */
                        Local2 = IDEP /* \_SB_.PCI0.IDE0.IDEP */
                    }
                    Else
                    {
                        Local0 = IDTS /* \_SB_.PCI0.IDE0.IDTS */
                        Local1 = UMSS /* \_SB_.PCI0.IDE0.UMSS */
                        Local2 = IDES /* \_SB_.PCI0.IDE0.IDES */
                    }

                    CreateDWordField (Local2, 0x00, PIO0)
                    CreateDWordField (Local2, 0x04, DMA0)
                    CreateDWordField (Local2, 0x08, PIO1)
                    CreateDWordField (Local2, 0x0C, DMA1)
                    CreateDWordField (Local2, 0x10, FLAG)
                    FLAG = 0x10
                    Local3 = (Local0 & 0x0F00)
                    Local4 = (Local0 & 0xF000)
                    Local3 >>= 0x08
                    Local4 >>= 0x0C
                    Local3 += Local4
                    PIO0 = ((Local3 + 0x02) * 0x1E)
                    If ((PIO0 <= 0xB4))
                    {
                        FLAG |= 0x02
                    }

                    If ((Local1 & 0x4000))
                    {
                        FLAG |= 0x01
                        Local3 = (Local1 & 0x0700)
                        Local3 >>= 0x08
                        DMA0 = U2T (Local3)
                    }
                    Else
                    {
                        DMA0 = PIO0 /* \_SB_.PCI0.IDE0.GTM_.PIO0 */
                    }

                    Local3 = (Local0 & 0x0F)
                    Local4 = (Local0 & 0xF0)
                    Local4 >>= 0x04
                    Local3 += Local4
                    PIO1 = ((Local3 + 0x02) * 0x1E)
                    If ((PIO1 <= 0xB4))
                    {
                        FLAG |= 0x08
                    }

                    If ((Local1 & 0x40))
                    {
                        FLAG |= 0x04
                        Local3 = (Local1 & 0x07)
                        DMA1 = U2T (Local3)
                    }
                    Else
                    {
                        DMA1 = PIO1 /* \_SB_.PCI0.IDE0.GTM_.PIO1 */
                    }

                    If ((Arg0 == 0x00))
                    {
                        IDEP = Local2
                        Return (IDEP) /* \_SB_.PCI0.IDE0.IDEP */
                    }
                    Else
                    {
                        IDES = Local2
                        Return (IDES) /* \_SB_.PCI0.IDE0.IDES */
                    }
                }

                Method (U2T, 1, NotSerialized)
                {
                    If ((Arg0 == 0x00))
                    {
                        Return (0x3C)
                    }

                    If ((Arg0 == 0x01))
                    {
                        Return (0x5A)
                    }

                    If ((Arg0 == 0x02))
                    {
                        Return (0x78)
                    }

                    If ((Arg0 == 0x03))
                    {
                        Return (0x96)
                    }

                    If ((Arg0 == 0x04))
                    {
                        Return (0x2D)
                    }

                    If ((Arg0 == 0x05))
                    {
                        Return (0x1E)
                    }

                    If ((Arg0 == 0x06))
                    {
                        Return (0x14)
                    }

                    Return (0x0F)
                }

                Method (T2U, 1, NotSerialized)
                {
                    If ((Arg0 > 0x78))
                    {
                        Return (0x03)
                    }

                    If ((Arg0 > 0x5A))
                    {
                        Return (0x02)
                    }

                    If ((Arg0 > 0x3C))
                    {
                        Return (0x01)
                    }

                    If ((Arg0 > 0x2D))
                    {
                        Return (0x00)
                    }

                    If ((Arg0 > 0x1E))
                    {
                        Return (0x04)
                    }

                    If ((Arg0 > 0x14))
                    {
                        Return (0x05)
                    }

                    If ((Arg0 > 0x0F))
                    {
                        Return (0x06)
                    }

                    Return (0x07)
                }

                Method (T2D, 1, NotSerialized)
                {
                    If ((Arg0 > 0x01E0))
                    {
                        Return (0xA8)
                    }

                    If ((Arg0 > 0x0186))
                    {
                        Return (0x77)
                    }

                    If ((Arg0 > 0xF0))
                    {
                        Return (0x47)
                    }

                    If ((Arg0 > 0xB4))
                    {
                        Return (0x33)
                    }

                    If ((Arg0 > 0x96))
                    {
                        Return (0x22)
                    }

                    If ((Arg0 > 0x78))
                    {
                        Return (0x21)
                    }

                    Return (0x20)
                }

                Method (STM, 4, NotSerialized)
                {
                    If (SX)
                    {
                        ID20 = SID0 /* \SID0 */
                        IDTS = SID1 /* \SID1 */
                        IDTP = SID2 /* \SID2 */
                        ID22 = SID3 /* \SID3 */
                        UMSS = SID4 /* \SID4 */
                        UMSP = SID5 /* \SID5 */
                    }
                    Else
                    {
                        SID0 = ID20 /* \_SB_.PCI0.IDE0.ID20 */
                        SID1 = IDTS /* \_SB_.PCI0.IDE0.IDTS */
                        SID2 = IDTP /* \_SB_.PCI0.IDE0.IDTP */
                        SID3 = ID22 /* \_SB_.PCI0.IDE0.ID22 */
                        SID4 = UMSS /* \_SB_.PCI0.IDE0.UMSS */
                        SID5 = UMSP /* \_SB_.PCI0.IDE0.UMSP */
                    }

                    SX = 0x00
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    If ((Arg3 == 0x00))
                    {
                        Local0 = SID2 /* \SID2 */
                        Local1 = SID5 /* \SID5 */
                    }
                    Else
                    {
                        Local0 = SID1 /* \SID1 */
                        Local1 = SID4 /* \SID4 */
                    }

                    If ((PIO0 != 0xFFFFFFFF))
                    {
                        Local0 &= 0xFF
                        Local2 = (T2D (PIO0) << 0x08)
                        Local0 |= Local2
                    }

                    If ((PIO1 != 0xFFFFFFFF))
                    {
                        Local0 &= 0xFF00
                        Local0 |= T2D (PIO1)
                    }

                    If ((FLAG & 0x01))
                    {
                        Local1 &= 0xFF
                        Local2 = (T2U (DMA0) << 0x08)
                        Local2 |= 0xC000
                        Local1 |= Local2
                    }
                    ElseIf ((DMA0 != 0xFFFFFFFF))
                    {
                        Local0 &= 0xFF
                        Local2 = (T2D (DMA0) << 0x08)
                        Local0 |= Local2
                    }

                    If ((FLAG & 0x04))
                    {
                        Local1 &= 0xFF00
                        Local2 = (0xC0 | T2U (DMA1))
                        Local1 |= Local2
                    }
                    ElseIf ((DMA1 != 0xFFFFFFFF))
                    {
                        Local0 &= 0xFF00
                        Local0 |= T2D (DMA1)
                    }

                    If ((Arg3 == 0x00))
                    {
                        IDTP = Local0
                        UMSP = Local1
                    }
                    Else
                    {
                        IDTS = Local0
                        UMSS = Local1
                    }
                }

                Method (GTF, 2, NotSerialized)
                {
                    Local0 = Buffer (0x07)
                        {
                             0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF         // .......
                        }
                    CreateByteField (Local0, 0x01, MODE)
                    CreateByteField (Local0, 0x05, DRIV)
                    DRIV = Arg1
                    If ((Arg0 == 0x00))
                    {
                        Local1 = IDEP /* \_SB_.PCI0.IDE0.IDEP */
                    }
                    Else
                    {
                        Local1 = IDES /* \_SB_.PCI0.IDE0.IDES */
                    }

                    CreateDWordField (Local1, 0x00, PIO0)
                    CreateDWordField (Local1, 0x04, DMA0)
                    CreateDWordField (Local1, 0x08, PIO1)
                    CreateDWordField (Local1, 0x0C, DMA1)
                    CreateDWordField (Local1, 0x10, FLGX)
                    If ((Arg1 == 0xA0))
                    {
                        Local2 = PIO0 /* \_SB_.PCI0.IDE0.GTF_.PIO0 */
                        Local3 = DMA0 /* \_SB_.PCI0.IDE0.GTF_.DMA0 */
                        FLGX &= 0x01
                    }
                    Else
                    {
                        Local2 = PIO1 /* \_SB_.PCI0.IDE0.GTF_.PIO1 */
                        Local3 = DMA1 /* \_SB_.PCI0.IDE0.GTF_.DMA1 */
                        FLGX &= 0x04
                    }

                    Local1 = FLGX /* \_SB_.PCI0.IDE0.GTF_.FLGX */
                    If ((Local2 > 0x0186))
                    {
                        Local2 = 0x00
                    }
                    ElseIf ((Local2 > 0xF0))
                    {
                        Local2 = 0x01
                    }
                    ElseIf ((Local2 > 0xB4))
                    {
                        Local2 = 0x02
                    }
                    ElseIf ((Local2 > 0x78))
                    {
                        Local2 = 0x03
                    }
                    Else
                    {
                        Local2 = 0x04
                    }

                    MODE = (0x08 | Local2)
                    Local2 = Local0
                    If (FLGX)
                    {
                        If ((Local3 > 0x5A))
                        {
                            Local3 = 0x00
                        }
                        ElseIf ((Local3 > 0x3C))
                        {
                            Local3 = 0x01
                        }
                        ElseIf ((Local3 > 0x2D))
                        {
                            Local3 = 0x02
                        }
                        ElseIf ((Local3 > 0x1E))
                        {
                            Local3 = 0x03
                        }
                        ElseIf ((Local3 > 0x14))
                        {
                            Local3 = 0x04
                        }
                        ElseIf ((Local3 > 0x0F))
                        {
                            Local3 = 0x05
                        }
                        Else
                        {
                            Local3 = 0x06
                        }

                        MODE = (0x40 | Local3)
                    }
                    ElseIf ((Local3 == 0xFFFFFFFF))
                    {
                        Return (Local0)
                    }
                    Else
                    {
                        If ((Local3 > 0x96))
                        {
                            Local3 = 0x00
                        }
                        ElseIf ((Local3 > 0x78))
                        {
                            Local3 = 0x01
                        }
                        Else
                        {
                            Local3 = 0x02
                        }

                        MODE = (0x20 | Local3)
                    }

                    Concatenate (Local0, Local2, Local1)
                    Return (Local1)
                }

                Device (PRI0)
                {
                    Name (_ADR, 0x00)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Return (GTM (0x00))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        STM (Arg0, Arg1, Arg2, 0x00)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (GTF (0x00, 0xA0))
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (GTF (0x00, 0xB0))
                        }
                    }
                }

                Device (SEC0)
                {
                    Name (_ADR, 0x01)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Return (GTM (0x01))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        STM (Arg0, Arg1, Arg2, 0x01)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (GTF (0x01, 0xA0))
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (GTF (0x01, 0xB0))
                        }
                    }
                }
            }

            Device (AGPB)
            {
                Name (_ADR, 0x001E0000)  // _ADR: Address
                Name (ONBV, 0x00)
                Name (PICM, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.LNK5, 
                        0x00
                    }
                })
                Name (APIC, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.APC5, 
                        0x00
                    }
                })
                Name (AGP0, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.LNK4, 
                        0x00
                    }
                })
                Name (AGP1, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.APC4, 
                        0x00
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    If (!PICF)
                    {
                        If ((ONBV == 0x01))
                        {
                            Return (PICM) /* \_SB_.PCI0.AGPB.PICM */
                        }
                        Else
                        {
                            Return (AGP0) /* \_SB_.PCI0.AGPB.AGP0 */
                        }
                    }
                    ElseIf ((ONBV == 0x01))
                    {
                        Return (APIC) /* \_SB_.PCI0.AGPB.APIC */
                    }
                    Else
                    {
                        Return (AGP1) /* \_SB_.PCI0.AGPB.AGP1 */
                    }
                }

                Device (VGAG)
                {
                    Name (_ADR, 0x00)  // _ADR: Address
                }
            }

            Device (HUB1)
            {
                Name (_ADR, 0x000C0000)  // _ADR: Address
                Name (PICM, Package (0x04)
                {
                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x00, 
                        \_SB.PCI0.L3CM, 
                        0x00
                    }, 

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

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

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x03, 
                        \_SB.PCI0.L3CM, 
                        0x00
                    }
                })
                Name (APIC, Package (0x04)
                {
                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x00, 
                        \_SB.PCI0.AP3C, 
                        0x00
                    }, 

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

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

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x03, 
                        \_SB.PCI0.AP3C, 
                        0x00
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    If (!PICF)
                    {
                        Return (PICM) /* \_SB_.PCI0.HUB1.PICM */
                    }
                    Else
                    {
                        Return (APIC) /* \_SB_.PCI0.HUB1.APIC */
                    }
                }

                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x0A, 
                    0x04
                })
            }

            Device (SMB0)
            {
                Name (_ADR, 0x00010001)  // _ADR: Address
                OperationRegion (SMCF, PCI_Config, 0x48, 0x10)
                Field (SMCF, DWordAcc, NoLock, Preserve)
                {
                    SMPM,   4, 
                    SMT1,   28, 
                    SMT2,   32, 
                    SB1,    32, 
                    SB2,    32
                }

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

            Device (VT86)
            {
                Name (_ADR, 0x00010000)  // _ADR: Address
                OperationRegion (PIO0, PCI_Config, 0x04, 0x20)
                Scope (\)
                {
                    Field (\_SB.PCI0.VT86.PIO0, ByteAcc, NoLock, Preserve)
                    {
                        SMEN,   8, 
                        Offset (0x0C), 
                        Offset (0x0D), 
                        SMIO,   8
                    }
                }

                Scope (\)
                {
                    OperationRegion (\_SB.PCI0.VT86.P60, PCI_Config, 0x60, 0x02)
                    Field (\_SB.PCI0.VT86.P60, AnyAcc, NoLock, Preserve)
                    {
                        PMBR,   16
                    }

                    OperationRegion (\_SB.PCI0.VT86.P64, PCI_Config, 0x64, 0x02)
                    Field (\_SB.PCI0.VT86.P64, AnyAcc, NoLock, Preserve)
                    {
                        NVSB,   16
                    }

                    OperationRegion (\_SB.PCI0.VT86.P68, PCI_Config, 0x68, 0x02)
                    Field (\_SB.PCI0.VT86.P68, AnyAcc, NoLock, Preserve)
                    {
                        ANLG,   16
                    }
                }

                OperationRegion (PIRQ, PCI_Config, 0x7C, 0x0C)
                Scope (\)
                {
                    Field (\_SB.PCI0.VT86.PIRQ, AnyAcc, NoLock, Preserve)
                    {
                        INTA,   4, 
                        INTB,   4, 
                        INTC,   4, 
                        INTD,   4, 
                        INTE,   4, 
                        Offset (0x04), 
                        SCII,   4, 
                        TCOI,   4, 
                        INTF,   4, 
                        INTQ,   4, 
                        INTU,   4, 
                        INTS,   4, 
                        Offset (0x08), 
                        INTG,   4, 
                        INTH,   4, 
                        INTJ,   4, 
                        INTK,   4, 
                        INTL,   4, 
                        INTM,   4, 
                        INTN,   4, 
                        INTP,   4
                    }
                }
            }

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

                Method (CKIO, 2, NotSerialized)
                {
                }

                Method (SLDM, 2, NotSerialized)
                {
                }
            }

            Device (USB0)
            {
                Name (_ADR, 0x00020000)  // _ADR: Address
                Method (_S1D, 0, NotSerialized)  // _S1D: S1 Device State
                {
                    Return (0x01)
                }

                Method (_S3D, 0, NotSerialized)  // _S3D: S3 Device State
                {
                    If ((OSFL == 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x0D, 
                    0x03
                })
            }

            Device (USB1)
            {
                Name (_ADR, 0x00020001)  // _ADR: Address
                Method (_S1D, 0, NotSerialized)  // _S1D: S1 Device State
                {
                    Return (0x01)
                }

                Method (_S3D, 0, NotSerialized)  // _S3D: S3 Device State
                {
                    If ((OSFL == 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x0C, 
                    0x03
                })
            }

            Device (USB2)
            {
                Name (_ADR, 0x00020002)  // _ADR: Address
                OperationRegion (P020, PCI_Config, 0x49, 0x01)
                Field (P020, AnyAcc, NoLock, Preserve)
                {
                    U0WK,   1
                }

                Method (_PSW, 1, NotSerialized)  // _PSW: Power State Wake
                {
                    If (Arg0)
                    {
                        U0WK = 0x01
                    }
                    Else
                    {
                        U0WK = 0x00
                    }
                }

                Method (_S1D, 0, NotSerialized)  // _S1D: S1 Device State
                {
                    Return (0x01)
                }

                Method (_S3D, 0, NotSerialized)  // _S3D: S3 Device State
                {
                    Return (0x01)
                }

                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x05, 
                    0x03
                })
            }

            Device (F139)
            {
                Name (_ADR, 0x000D0000)  // _ADR: Address
                Method (_S1D, 0, NotSerialized)  // _S1D: S1 Device State
                {
                    Return (0x01)
                }

                Method (_S3D, 0, NotSerialized)  // _S3D: S3 Device State
                {
                    If ((OSFL == 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x0F, 
                    0x03
                })
            }

            Device (MMAC)
            {
                Name (_ADR, 0x00040000)  // _ADR: Address
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x0B, 
                    0x05
                })
            }

            Device (MAPU)
            {
                Name (_ADR, 0x00050000)  // _ADR: Address
            }

            Device (MACI)
            {
                Name (_ADR, 0x00060000)  // _ADR: Address
            }

            Device (MMCI)
            {
                Name (_ADR, 0x00060001)  // _ADR: Address
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x07, 
                    0x05
                })
            }

            Name (BUFA, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,10,11,12,14,15}
            })
            Name (BUFB, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, _Y0D)
                    {}
            })
            CreateWordField (BUFB, \_SB.PCI0._Y0D._INT, IRQV)  // _INT: Interrupts
            Method (CRS, 1, NotSerialized)
            {
                If (Arg0)
                {
                    IRQV = (0x01 << Arg0)
                }
                Else
                {
                    IRQV = Zero
                }

                Return (BUFB) /* \_SB_.PCI0.BUFB */
            }

            Method (SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Local0--
                Return (Local0)
            }

            Method (CRSA, 1, Serialized)
            {
                Local0 = 0x00
                If ((Arg0 == 0x08))
                {
                    Local0 = 0x14
                }

                If ((Arg0 == 0x0D))
                {
                    Local0 = 0x15
                }

                If ((Arg0 == 0x02))
                {
                    Local0 = 0x16
                }

                Name (IRZ5, ResourceTemplate ()
                {
                    Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, _Y0E)
                    {
                        0x00000007,
                    }
                })
                CreateWordField (IRZ5, \_SB.PCI0.CRSA._Y0E._INT, INZ5)  // _INT: Interrupts
                INZ5 = Local0
                Return (IRZ5) /* \_SB_.PCI0.CRSA.IRZ5 */
            }

            Method (SRSA, 1, Serialized)
            {
                CreateWordField (Arg0, 0x05, INZ6)
                Local0 = 0x08
                If ((INZ6 == 0x14))
                {
                    Local0 = 0x08
                }

                If ((INZ6 == 0x15))
                {
                    Local0 = 0x0D
                }

                If ((INZ6 == 0x16))
                {
                    Local0 = 0x02
                }

                Return (Local0)
            }

            Device (LNK1)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x01)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTA)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTA = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTA))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTA = SRS (Arg0)
                }
            }

            Device (LNK2)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x02)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTB)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTB = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTB))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTB = SRS (Arg0)
                }
            }

            Device (LNK3)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x03)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTC)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTC = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTC))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTC = SRS (Arg0)
                }
            }

            Device (LNK4)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x04)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTD)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTD = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTD))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTD = SRS (Arg0)
                }
            }

            Device (LNK5)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x05)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTE)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTE = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTE))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTE = SRS (Arg0)
                }
            }

            Device (LUBA)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x06)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTG)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTG = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTG))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTG = SRS (Arg0)
                }
            }

            Device (LUBB)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x07)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTH)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTH = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTH))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTH = SRS (Arg0)
                }
            }

            Device (LMAC)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x08)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTJ)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTJ = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTJ))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTJ = SRS (Arg0)
                }
            }

            Device (LAPU)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x09)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTK)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTK = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTK))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTK = SRS (Arg0)
                }
            }

            Device (LACI)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0A)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTL)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTL = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTL))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTL = SRS (Arg0)
                }
            }

            Device (LMCI)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0B)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTM)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTM = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTM))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTM = SRS (Arg0)
                }
            }

            Device (LSMB)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0C)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTF)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTF = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTF))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTF = SRS (Arg0)
                }
            }

            Device (LUB2)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0D)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTQ)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTQ = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTQ))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTQ = SRS (Arg0)
                }
            }

            Device (LFIR)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0E)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTU)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTU = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTU))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTU = SRS (Arg0)
                }
            }

            Device (L3CM)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0F)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTS)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTS = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTS))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTS = SRS (Arg0)
                }
            }

            Device (LIDE)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x10)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTN)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFA) /* \_SB_.PCI0.BUFA */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTN = 0x00
                    INTP = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRS (INTN))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTN = SRS (Arg0)
                    INTP = SRS (Arg0)
                }
            }

            Name (BUF1, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, )
                {
                    0x00000010,
                }
            })
            Name (BUF2, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, )
                {
                    0x00000011,
                }
            })
            Name (BUF3, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, )
                {
                    0x00000012,
                }
            })
            Name (BUF4, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, )
                {
                    0x00000013,
                }
            })
            Name (BUFF, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, )
                {
                    0x00000014,
                    0x00000015,
                    0x00000016,
                }
            })
            Name (BUFI, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, )
                {
                    0x00000017,
                }
            })
            Name (IRZ1, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveHigh, Shared, ,, _Y0F)
                {
                    0x00000007,
                }
            })
            Device (APC1)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0B)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTA)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUF1) /* \_SB_.PCI0.BUF1 */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTA = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    CreateWordField (IRZ1, \_SB.PCI0._Y0F._INT, IRQ1)  // _INT: Interrupts
                    IRQ1 = 0x10
                    Return (IRZ1) /* \_SB_.PCI0.IRZ1 */
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTA = 0x08
                }
            }

            Device (APC2)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0C)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTB)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUF2) /* \_SB_.PCI0.BUF2 */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTB = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    CreateWordField (IRZ1, \_SB.PCI0._Y0F._INT, IRQ1)  // _INT: Interrupts
                    IRQ1 = 0x11
                    Return (IRZ1) /* \_SB_.PCI0.IRZ1 */
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTB = 0x01
                }
            }

            Device (APC3)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0D)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTC)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUF3) /* \_SB_.PCI0.BUF3 */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTC = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    CreateWordField (IRZ1, \_SB.PCI0._Y0F._INT, IRQ1)  // _INT: Interrupts
                    IRQ1 = 0x12
                    Return (IRZ1) /* \_SB_.PCI0.IRZ1 */
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTC = 0x02
                }
            }

            Device (APC4)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0E)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTD)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUF4) /* \_SB_.PCI0.BUF4 */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTD = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    CreateWordField (IRZ1, \_SB.PCI0._Y0F._INT, IRQ1)  // _INT: Interrupts
                    IRQ1 = 0x13
                    Return (IRZ1) /* \_SB_.PCI0.IRZ1 */
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTD = 0x0D
                }
            }

            Device (APC5)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x0F)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTE)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUF1) /* \_SB_.PCI0.BUF1 */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTE = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    CreateWordField (IRZ1, \_SB.PCI0._Y0F._INT, IRQ1)  // _INT: Interrupts
                    IRQ1 = 0x10
                    Return (IRZ1) /* \_SB_.PCI0.IRZ1 */
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTE = 0x08
                }
            }

            Device (APCF)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x10)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTG)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTG = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTG))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTG = SRSA (Arg0)
                }
            }

            Device (APCG)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x11)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTH)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTH = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTH))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTH = SRSA (Arg0)
                }
            }

            Device (APCH)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x12)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTJ)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTJ = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTJ))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTJ = SRSA (Arg0)
                }
            }

            Device (APCI)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x1A)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTK)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTK = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTK))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTK = SRSA (Arg0)
                }
            }

            Device (APCJ)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x1B)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTL)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTL = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTL))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTL = SRSA (Arg0)
                }
            }

            Device (APCK)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x1C)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTM)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTM = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTM))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTM = SRSA (Arg0)
                }
            }

            Device (APCS)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x1D)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTF)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFI) /* \_SB_.PCI0.BUFI */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTF = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    CreateWordField (IRZ1, \_SB.PCI0._Y0F._INT, IRQ1)  // _INT: Interrupts
                    IRQ1 = 0x17
                    Return (IRZ1) /* \_SB_.PCI0.IRZ1 */
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTF = 0x02
                }
            }

            Device (APCL)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x1E)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTQ)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTQ = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTQ))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTQ = SRSA (Arg0)
                }
            }

            Device (APCM)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x1F)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTU)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTU = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTU))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTU = SRSA (Arg0)
                }
            }

            Device (AP3C)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x20)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTS)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTS = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTS))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTS = SRSA (Arg0)
                }
            }

            Device (APCZ)
            {
                Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
                Name (_UID, 0x21)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (INTN)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                {
                    Return (BUFF) /* \_SB_.PCI0.BUFF */
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    INTN = 0x00
                    INTP = 0x00
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Return (CRSA (INTN))
                }

                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    INTN = SRSA (Arg0)
                    INTP = SRSA (Arg0)
                }
            }

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

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

            Scope (\)
            {
                Method (OSTP, 0, NotSerialized)
                {
                    If ((OSFL == 0x01))
                    {
                        SMIP = 0x56
                    }

                    If ((OSFL == 0x02))
                    {
                        SMIP = 0x57
                    }

                    If ((OSFL == 0x00))
                    {
                        SMIP = 0x58
                    }

                    If ((OSFX == 0x03))
                    {
                        SMIP = 0x59
                    }
                }
            }

            Device (SYSR)
            {
                Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                Name (_UID, 0x01)  // _UID: Unique ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    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,
                        0x0B78,             // Range Minimum
                        0x0B78,             // Range Maximum
                        0x04,               // Alignment
                        0x04,               // Length
                        )
                    IO (Decode16,
                        0x0F78,             // Range Minimum
                        0x0F78,             // Range Maximum
                        0x04,               // Alignment
                        0x04,               // Length
                        )
                    IO (Decode16,
                        0x0A78,             // Range Minimum
                        0x0A78,             // Range Maximum
                        0x04,               // Alignment
                        0x04,               // Length
                        )
                    IO (Decode16,
                        0x0E78,             // Range Minimum
                        0x0E78,             // Range Maximum
                        0x04,               // Alignment
                        0x04,               // Length
                        )
                    IO (Decode16,
                        0x0BBC,             // Range Minimum
                        0x0BBC,             // Range Maximum
                        0x04,               // Alignment
                        0x04,               // Length
                        )
                    IO (Decode16,
                        0x0FBC,             // Range Minimum
                        0x0FBC,             // Range Maximum
                        0x04,               // Alignment
                        0x04,               // Length
                        )
                    IO (Decode16,
                        0x04D0,             // Range Minimum
                        0x04D0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0294,             // Range Minimum
                        0x0294,             // Range Maximum
                        0x01,               // Alignment
                        0x04,               // Length
                        )
                })
            }

            Device (PIC)
            {
                Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */)  // _HID: Hardware ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    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") /* PC-class DMA Controller */)  // _HID: Hardware ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    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") /* PC-class System Timer */)  // _HID: Hardware ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x01,               // Alignment
                        0x04,               // Length
                        )
                    IRQNoFlags ()
                        {0}
                })
            }

            Device (RTC)
            {
                Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */)  // _HID: Hardware ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x04,               // Alignment
                        0x04,               // Length
                        )
                    IRQNoFlags ()
                        {8}
                })
            }

            Device (SPKR)
            {
                Name (_HID, EisaId ("PNP0800") /* Microsoft Sound System Compatible Device */)  // _HID: Hardware ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    IO (Decode16,
                        0x0061,             // Range Minimum
                        0x0061,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                })
            }

            Device (COPR)
            {
                Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */)  // _HID: Hardware ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    IO (Decode16,
                        0x00F0,             // Range Minimum
                        0x00F0,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IRQNoFlags ()
                        {13}
                })
            }

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

                IndexField (INDP, DATA, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x02), 
                    CFG,    8, 
                    Offset (0x07), 
                    LDN,    8, 
                    Offset (0x20), 
                    IDHI,   8, 
                    IDLO,   8, 
                    POWC,   8, 
                    Offset (0x30), 
                    ACTR,   8, 
                    Offset (0x60), 
                    IOAH,   8, 
                    IOAL,   8, 
                    IO2H,   8, 
                    IO2L,   8, 
                    Offset (0x70), 
                    INTR,   8, 
                    Offset (0x72), 
                    INT1,   8, 
                    Offset (0x74), 
                    DMCH,   8, 
                    Offset (0xE0), 
                    CRE0,   8, 
                    CRE1,   8, 
                    CRE2,   8, 
                    CRE3,   8, 
                    CRE4,   8, 
                    Offset (0xF0), 
                    OPT1,   8, 
                    OPT2,   8, 
                    OPT3,   8, 
                    OPT4,   8, 
                    OPT5,   8, 
                    OPT6,   8, 
                    OPT7,   8, 
                    OPT8,   8, 
                    OPT9,   8, 
                    OPTA,   8
                }

                Method (ENFG, 0, NotSerialized)
                {
                    INDP = 0x87
                    INDP = 0x87
                }

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

            OperationRegion (COM1, SystemIO, 0x03F8, 0x08)
            Field (COM1, ByteAcc, NoLock, Preserve)
            {
                P3F8,   8, 
                P3F9,   8, 
                P3FA,   8, 
                P3FB,   8, 
                P3FC,   8, 
                P3FD,   8, 
                P3FE,   8, 
                P3FF,   8
            }

            OperationRegion (COM2, SystemIO, 0x02F8, 0x08)
            Field (COM2, ByteAcc, NoLock, Preserve)
            {
                P2F8,   8, 
                P2F9,   8, 
                P2FA,   8, 
                P2FB,   8, 
                P2FC,   8, 
                P2FD,   8, 
                P2FE,   8, 
                P2FF,   8
            }

            OperationRegion (COM3, SystemIO, 0x03E8, 0x08)
            Field (COM3, ByteAcc, NoLock, Preserve)
            {
                P3E8,   8, 
                P3E9,   8, 
                P3EA,   8, 
                P3EB,   8, 
                P3EC,   8, 
                P3ED,   8, 
                P3EE,   8, 
                P3EF,   8
            }

            OperationRegion (COM4, SystemIO, 0x02E8, 0x08)
            Field (COM4, ByteAcc, NoLock, Preserve)
            {
                P2E8,   8, 
                P2E9,   8, 
                P2EA,   8, 
                P2EB,   8, 
                P2EC,   8, 
                P2ED,   8, 
                P2EE,   8, 
                P2EF,   8
            }

            Method (ICOM, 1, NotSerialized)
            {
                Local0 = Arg0
                If ((Local0 == 0x03F8))
                {
                    Local0 = P3FD /* \_SB_.PCI0.P3FD */
                    Local0 = P3FD /* \_SB_.PCI0.P3FD */
                    P3FA = 0xC3
                    While ((P3FA != 0xC1))
                    {
                        Local0 = P3FE /* \_SB_.PCI0.P3FE */
                    }
                }
                ElseIf ((Local0 == 0x02F8))
                {
                    Local0 = P2FD /* \_SB_.PCI0.P2FD */
                    Local0 = P2FD /* \_SB_.PCI0.P2FD */
                    P2FA = 0xC3
                    While ((P2FA != 0xC1))
                    {
                        Local0 = P2FE /* \_SB_.PCI0.P2FE */
                    }
                }
                ElseIf ((Local0 == 0x03E8))
                {
                    Local0 = P3ED /* \_SB_.PCI0.P3ED */
                    Local0 = P3ED /* \_SB_.PCI0.P3ED */
                    P3EA = 0xC3
                    While ((P3EA != 0xC1))
                    {
                        Local0 = P3EE /* \_SB_.PCI0.P3EE */
                    }
                }
                ElseIf ((Local0 == 0x02E8))
                {
                    Local0 = P2ED /* \_SB_.PCI0.P2ED */
                    Local0 = P2ED /* \_SB_.PCI0.P2ED */
                    P2EA = 0xC3
                    While ((P2EA != 0xC1))
                    {
                        Local0 = P2EE /* \_SB_.PCI0.P2EE */
                    }
                }
            }

            Device (FDC0)
            {
                Name (_HID, EisaId ("PNP0700"))  // _HID: Hardware ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = Zero
                    If (ACTR)
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    ElseIf ((IOAH || IOAL))
                    {
                        EXFG ()
                        Return (0x0D)
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    ENFG ()
                    LDN = 0x00
                    ACTR = Zero
                    SLDM (DMCH, 0x04)
                    EXFG ()
                    DISD (0x03)
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x03F0,             // Range Minimum
                            0x03F0,             // Range Maximum
                            0x01,               // Alignment
                            0x06,               // Length
                            _Y10)
                        IO (Decode16,
                            0x03F7,             // Range Minimum
                            0x03F7,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {6}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {2}
                    })
                    CreateByteField (BUF0, \_SB.PCI0.FDC0._CRS._Y10._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF0, 0x03, IOHI)
                    CreateByteField (BUF0, \_SB.PCI0.FDC0._CRS._Y10._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF0, 0x05, IORH)
                    ENFG ()
                    EXFG ()
                    Return (BUF0) /* \_SB_.PCI0.FDC0._CRS.BUF0 */
                }

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

            Device (UAR1)
            {
                Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */)  // _HID: Hardware ID
                Name (_UID, 0x01)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = 0x02
                    If (ACTR)
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    ElseIf ((IOAH || IOAL))
                    {
                        EXFG ()
                        Return (0x0D)
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }

                    EXFG ()
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    ENFG ()
                    LDN = 0x02
                    ACTR = Zero
                    EXFG ()
                    DISD (0x00)
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y11)
                        IRQNoFlags (_Y12)
                            {}
                    })
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y11._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF1, 0x03, IOHI)
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y11._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF1, 0x05, IORH)
                    CreateWordField (BUF1, \_SB.PCI0.UAR1._CRS._Y12._INT, IRQW)  // _INT: Interrupts
                    ENFG ()
                    LDN = 0x02
                    IOLO = IOAL /* \IOAL */
                    IORL = IOAL /* \IOAL */
                    IOHI = IOAH /* \IOAH */
                    IORH = IOAH /* \IOAH */
                    Local0 = One
                    IRQW = (Local0 << INTR) /* \INTR */
                    EXFG ()
                    Return (BUF1) /* \_SB_.PCI0.UAR1._CRS.BUF1 */
                }

                Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    LDN = 0x02
                    ACTR = One
                    IOAL = IOLO /* \_SB_.PCI0.UAR1._SRS.IOLO */
                    IOAH = IOHI /* \_SB_.PCI0.UAR1._SRS.IOHI */
                    FindSetRightBit (IRQW, Local0)
                    INTR = (Local0 - 0x01)
                    EXFG ()
                    CKIO (IOAD, 0x00)
                }
            }

            Device (UAR2)
            {
                Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */)  // _HID: Hardware ID
                Name (_UID, 0x02)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = 0x03
                    Local0 = (OPT2 & 0x30)
                    If ((Local0 != 0x10))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        ElseIf ((IOAH || IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    ENFG ()
                    LDN = 0x03
                    Local0 = (OPT2 & 0x38)
                    If ((Local0 == 0x00))
                    {
                        ACTR = Zero
                    }

                    EXFG ()
                    DISD (0x01)
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF2, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y13)
                        IRQNoFlags (_Y14)
                            {4}
                    })
                    CreateByteField (BUF2, \_SB.PCI0.UAR2._CRS._Y13._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF2, 0x03, IOHI)
                    CreateByteField (BUF2, \_SB.PCI0.UAR2._CRS._Y13._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF2, 0x05, IORH)
                    CreateWordField (BUF2, \_SB.PCI0.UAR2._CRS._Y14._INT, IRQW)  // _INT: Interrupts
                    ENFG ()
                    LDN = 0x03
                    IOLO = IOAL /* \IOAL */
                    IORL = IOAL /* \IOAL */
                    IOHI = IOAH /* \IOAH */
                    IORH = IOAH /* \IOAH */
                    Local0 = One
                    IRQW = (Local0 << INTR) /* \INTR */
                    EXFG ()
                    Return (BUF2) /* \_SB_.PCI0.UAR2._CRS.BUF2 */
                }

                Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    LDN = 0x03
                    ACTR = One
                    IOAL = IOLO /* \_SB_.PCI0.UAR2._SRS.IOLO */
                    IOAH = IOHI /* \_SB_.PCI0.UAR2._SRS.IOHI */
                    FindSetRightBit (IRQW, Local0)
                    INTR = (Local0 - 0x01)
                    EXFG ()
                    CKIO (IOAD, 0x01)
                }
            }

            Device (IRDA)
            {
                Name (_HID, EisaId ("PNP0510") /* Generic IRDA-compatible Device */)  // _HID: Hardware ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = 0x03
                    Local0 = (OPT2 & 0x30)
                    If ((Local0 == 0x10))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        ElseIf ((IOAH || IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    If ((DISE == 0x01))
                    {
                        ENFG ()
                        LDN = 0x03
                        Local0 = (OPT2 & 0x38)
                        If ((Local0 != 0x00))
                        {
                            ACTR = Zero
                        }

                        EXFG ()
                        DISD (0x01)
                    }

                    Local0 = Local0
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF4, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y15)
                        IRQNoFlags (_Y16)
                            {}
                    })
                    CreateByteField (BUF4, \_SB.PCI0.IRDA._CRS._Y15._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF4, 0x03, IOHI)
                    CreateByteField (BUF4, \_SB.PCI0.IRDA._CRS._Y15._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF4, 0x05, IORH)
                    CreateWordField (BUF4, \_SB.PCI0.IRDA._CRS._Y16._INT, IRQW)  // _INT: Interrupts
                    ENFG ()
                    LDN = 0x03
                    IOLO = IOAL /* \IOAL */
                    IORL = IOAL /* \IOAL */
                    IOHI = IOAH /* \IOAH */
                    IORH = IOAH /* \IOAH */
                    IRQW = (0x01 << INTR) /* \INTR */
                    EXFG ()
                    Return (BUF4) /* \_SB_.PCI0.IRDA._CRS.BUF4 */
                }

                Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    LDN = 0x03
                    ACTR = One
                    IOAL = IOLO /* \_SB_.PCI0.IRDA._SRS.IOLO */
                    IOAH = IOHI /* \_SB_.PCI0.IRDA._SRS.IOHI */
                    FindSetRightBit (IRQW, Local0)
                    INTR = (Local0 - 0x01)
                    EXFG ()
                    CKIO (IOAD, 0x01)
                }
            }

            Device (LPT1)
            {
                Name (_HID, EisaId ("PNP0400") /* Standard LPT Parallel Port */)  // _HID: Hardware ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = 0x01
                    Local0 = (OPT1 & 0x02)
                    If ((Local0 != 0x02))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        ElseIf ((IOAH || IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    ENFG ()
                    LDN = 0x01
                    ACTR = Zero
                    EXFG ()
                    DISD (0x02)
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF5, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y17)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            _Y18)
                        IRQNoFlags (_Y19)
                            {}
                    })
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y17._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF5, 0x03, IOHI)
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y17._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF5, 0x05, IORH)
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y17._LEN, IOLE)  // _LEN: Length
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y18._MIN, IO21)  // _MIN: Minimum Base Address
                    CreateByteField (BUF5, 0x0B, IO22)
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y18._MAX, IO23)  // _MAX: Maximum Base Address
                    CreateByteField (BUF5, 0x0D, IO24)
                    CreateWordField (BUF5, \_SB.PCI0.LPT1._CRS._Y19._INT, IRQW)  // _INT: Interrupts
                    ENFG ()
                    LDN = 0x01
                    IOLO = IOAL /* \IOAL */
                    IORL = IOLO /* \_SB_.PCI0.LPT1._CRS.IOLO */
                    IOHI = IOAH /* \IOAH */
                    IORH = IOHI /* \_SB_.PCI0.LPT1._CRS.IOHI */
                    IO21 = IOAL /* \IOAL */
                    IO23 = IOAL /* \IOAL */
                    IO22 = (IOAH + 0x04)
                    IO24 = (IOAH + 0x04)
                    If ((IOLO == 0xBC))
                    {
                        IOLE = 0x04
                    }
                    Else
                    {
                        IOLE = 0x08
                    }

                    Local0 = One
                    Local5 = INTR /* \INTR */
                    IRQW = (Local0 << Local5)
                    ACTR = One
                    EXFG ()
                    Return (BUF5) /* \_SB_.PCI0.LPT1._CRS.BUF5 */
                }

                Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x07BC,             // Range Minimum
                            0x07BC,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateByteField (Arg0, 0x04, IORL)
                    CreateByteField (Arg0, 0x05, IORH)
                    CreateWordField (Arg0, 0x11, IRQW)
                    ENFG ()
                    LDN = 0x01
                    ACTR = One
                    IOAL = IOLO /* \_SB_.PCI0.LPT1._SRS.IOLO */
                    IOAH = IOHI /* \_SB_.PCI0.LPT1._SRS.IOHI */
                    FindSetLeftBit (IRQW, Local0)
                    Local0 -= 0x01
                    INTR = Local0
                    EXFG ()
                    CKIO (IOAD, 0x02)
                }
            }

            Device (ECP1)
            {
                Name (_HID, EisaId ("PNP0401") /* ECP Parallel Port */)  // _HID: Hardware ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = 0x01
                    Local0 = (OPT1 & 0x02)
                    If ((Local0 == 0x02))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        ElseIf ((IOAH || IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    ENFG ()
                    LDN = 0x01
                    ACTR = Zero
                    SLDM (DMCH, 0x04)
                    EXFG ()
                    DISD (0x02)
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF6, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y1A)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            _Y1B)
                        IRQNoFlags (_Y1C)
                            {}
                        DMA (Compatibility, NotBusMaster, Transfer8, _Y1D)
                            {}
                    })
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y1A._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF6, 0x03, IOHI)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y1A._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF6, 0x05, IORH)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y1B._MIN, IOEL)  // _MIN: Minimum Base Address
                    CreateByteField (BUF6, 0x0B, IOEH)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y1B._MAX, IOML)  // _MAX: Maximum Base Address
                    CreateByteField (BUF6, 0x0D, IOMH)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y1A._LEN, IOLE)  // _LEN: Length
                    CreateWordField (BUF6, \_SB.PCI0.ECP1._CRS._Y1C._INT, IRQW)  // _INT: Interrupts
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y1D._DMA, DMAC)  // _DMA: Direct Memory Access
                    ENFG ()
                    LDN = 0x01
                    ACTR = One
                    Local2 = IOAL /* \IOAL */
                    IOLO = Local2
                    Local3 = IOAH /* \IOAH */
                    IOHI = Local3
                    Local3 |= 0x04
                    IOEH = Local3
                    IOMH = Local3
                    IORL = IOLO /* \_SB_.PCI0.ECP1._CRS.IOLO */
                    IOEL = IOLO /* \_SB_.PCI0.ECP1._CRS.IOLO */
                    IOML = IOLO /* \_SB_.PCI0.ECP1._CRS.IOLO */
                    IORH = IOHI /* \_SB_.PCI0.ECP1._CRS.IOHI */
                    If ((IOLO == 0xBC))
                    {
                        IOLE = 0x04
                    }
                    Else
                    {
                        IOLE = 0x08
                    }

                    Local0 = One
                    Local5 = INTR /* \INTR */
                    IRQW = (Local0 << Local5)
                    Local0 = One
                    Local5 = DMCH /* \DMCH */
                    DMAC = (Local0 << Local5)
                    EXFG ()
                    Return (BUF6) /* \_SB_.PCI0.ECP1._CRS.BUF6 */
                }

                Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {0,1,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {0,1,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x07BC,             // Range Minimum
                            0x07BC,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {0,1,3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x11, IRQW)
                    CreateByteField (Arg0, 0x14, DMAC)
                    ENFG ()
                    LDN = 0x01
                    ACTR = One
                    IOAL = IOLO /* \_SB_.PCI0.ECP1._SRS.IOLO */
                    IOAH = IOHI /* \_SB_.PCI0.ECP1._SRS.IOHI */
                    FindSetLeftBit (IRQW, Local0)
                    Local0 -= 0x01
                    INTR = Local0
                    FindSetLeftBit (DMAC, Local1)
                    Local0 = DMCH /* \DMCH */
                    DMCH = (Local1 - 0x01)
                    SLDM (Local0, DMCH)
                    EXFG ()
                    CKIO (IOAD, 0x02)
                }
            }

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

            Device (PS2M)
            {
                Name (_HID, EisaId ("PNP0F13") /* PS/2 Mouse */)  // _HID: Hardware ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If ((PS2F == 0x00))
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    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 ((KBDI == 0x01))
                    {
                        If ((OSFL == 0x02))
                        {
                            Return (BUF1) /* \_SB_.PCI0.PS2M._CRS.BUF1 */
                        }

                        If ((OSFL == 0x01))
                        {
                            Return (BUF1) /* \_SB_.PCI0.PS2M._CRS.BUF1 */
                        }
                        Else
                        {
                            Return (BUF2) /* \_SB_.PCI0.PS2M._CRS.BUF2 */
                        }
                    }
                    Else
                    {
                        Return (BUF1) /* \_SB_.PCI0.PS2M._CRS.BUF1 */
                    }
                }
            }

            Device (PS2K)
            {
                Name (_HID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */)  // _HID: Hardware ID
                Name (_CID, EisaId ("PNP030B"))  // _CID: Compatible ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If ((KBDI == 0x01))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    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") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                Name (_UID, 0x03)  // _UID: Unique ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If ((KBDI == 0x00))
                    {
                        Return (0x00)
                    }

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

                        If ((OSFL == 0x01))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Return (0x00)
                }

                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    IO (Decode16,
                        0x0060,             // Range Minimum
                        0x0060,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                    IO (Decode16,
                        0x0064,             // Range Minimum
                        0x0064,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                })
            }

            Device (GAME)
            {
                Name (_HID, EisaId ("PNPB02F"))  // _HID: Hardware ID
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = 0x07
                    If ((IOAH || IOAL))
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    Else
                    {
                        Local0 = (ACTR & 0x02)
                        If ((Local0 == 0x02))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    ENFG ()
                    LDN = 0x07
                    IOAH = Zero
                    IOAL = Zero
                    EXFG ()
                    DISD (0x04)
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            _Y1E)
                    })
                    CreateByteField (BUF1, \_SB.PCI0.GAME._CRS._Y1E._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF1, 0x03, IOHI)
                    CreateByteField (BUF1, \_SB.PCI0.GAME._CRS._Y1E._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF1, 0x05, IORH)
                    ENFG ()
                    LDN = 0x07
                    IOLO = IOAL /* \IOAL */
                    IORL = IOAL /* \IOAL */
                    IOHI = IOAH /* \IOAH */
                    IORH = IOAH /* \IOAH */
                    EXFG ()
                    Return (BUF1) /* \_SB_.PCI0.GAME._CRS.BUF1 */
                }

                Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0201,             // Range Minimum
                            0x0201,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0209,             // Range Minimum
                            0x0209,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    ENFG ()
                    LDN = 0x07
                    ACTR |= 0x02
                    IOAL = IOLO /* \_SB_.PCI0.GAME._SRS.IOLO */
                    IOAH = IOHI /* \_SB_.PCI0.GAME._SRS.IOHI */
                    EXFG ()
                    CKIO (IOAD, 0x04)
                }
            }

            Device (MIDI)
            {
                Name (_HID, EisaId ("PNPB006"))  // _HID: Hardware ID
                OperationRegion (MID1, SystemIO, 0x0290, 0x02)
                Field (MID1, ByteAcc, NoLock, Preserve)
                {
                    MD1,    8, 
                    ST1,    8
                }

                OperationRegion (MID2, SystemIO, 0x0300, 0x02)
                Field (MID2, ByteAcc, NoLock, Preserve)
                {
                    MD2,    8, 
                    ST2,    8
                }

                OperationRegion (MID3, SystemIO, 0x0330, 0x02)
                Field (MID3, ByteAcc, NoLock, Preserve)
                {
                    MD3,    8, 
                    ST3,    8
                }

                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    ENFG ()
                    LDN = 0x07
                    If ((IO2H || IO2L))
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    Else
                    {
                        Local0 = (ACTR & 0x04)
                        If ((Local0 == 0x04))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                }

                Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                {
                    ENFG ()
                    LDN = 0x07
                    IO2H = Zero
                    IO2L = Zero
                    INTR = Zero
                    EXFG ()
                    DISD (0x05)
                }

                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            _Y1F)
                        IRQNoFlags (_Y20)
                            {}
                    })
                    CreateByteField (BUF1, \_SB.PCI0.MIDI._CRS._Y1F._MIN, IOLO)  // _MIN: Minimum Base Address
                    CreateByteField (BUF1, 0x03, IOHI)
                    CreateByteField (BUF1, \_SB.PCI0.MIDI._CRS._Y1F._MAX, IORL)  // _MAX: Maximum Base Address
                    CreateByteField (BUF1, 0x05, IORH)
                    CreateWordField (BUF1, \_SB.PCI0.MIDI._CRS._Y20._INT, IRQW)  // _INT: Interrupts
                    ENFG ()
                    LDN = 0x07
                    IOLO = IO2L /* \IO2L */
                    IORL = IO2L /* \IO2L */
                    IOHI = IO2H /* \IO2H */
                    IORH = IO2H /* \IO2H */
                    Local0 = One
                    IRQW = (Local0 << INTR) /* \INTR */
                    EXFG ()
                    Return (BUF1) /* \_SB_.PCI0.MIDI._CRS.BUF1 */
                }

                Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0330,             // Range Minimum
                            0x0330,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0300,             // Range Minimum
                            0x0300,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0290,             // Range Minimum
                            0x0290,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    LDN = 0x07
                    ACTR |= 0x04
                    IO2L = IOLO /* \_SB_.PCI0.MIDI._SRS.IOLO */
                    IO2H = IOHI /* \_SB_.PCI0.MIDI._SRS.IOHI */
                    FindSetLeftBit (IRQW, Local0)
                    Local0 -= 0x01
                    INTR = Local0
                    EXFG ()
                    CKIO (IOAD, 0x05)
                    If ((IOAD == 0x0290))
                    {
                        Local0 = (ST1 & 0x40)
                        While ((Local0 == 0x40))
                        {
                            Local0 = MD1 /* \_SB_.PCI0.MIDI.MD1_ */
                            Local0 = (ST1 & 0x40)
                        }
                    }
                    ElseIf ((IOAD == 0x0300))
                    {
                        Local0 = (ST2 & 0x40)
                        While ((Local0 == 0x40))
                        {
                            Local0 = MD2 /* \_SB_.PCI0.MIDI.MD2_ */
                            Local0 = (ST2 & 0x40)
                        }
                    }
                    Else
                    {
                        Local0 = (ST3 & 0x40)
                        While ((Local0 == 0x40))
                        {
                            Local0 = MD3 /* \_SB_.PCI0.MIDI.MD3_ */
                            Local0 = (ST3 & 0x40)
                        }
                    }
                }
            }

            Scope (\)
            {
                Method (SALD, 1, NotSerialized)
                {
                    If ((Arg0 == 0x00))
                    {
                        Local0 = 0x40
                    }

                    If ((Arg0 == 0x01))
                    {
                        Local0 = 0x80
                    }

                    If ((Arg0 == 0x03))
                    {
                        Local0 = 0x80
                    }

                    If ((Arg0 == 0x04))
                    {
                        Local0 = (0x40 ^ 0x40)
                    }

                    If ((Arg0 == 0x05))
                    {
                        Local0 = (0x40 ^ 0x40)
                    }

                    SLED (Local0)
                    SLED (Local0)
                }
            }

            Scope (\)
            {
                Method (PLED, 1, NotSerialized)
                {
                    ENFG ()
                    LDN = 0x08
                    Local0 = (OPT6 & 0x3F)
                    OPT6 = (Local0 | Arg0)
                    EXFG ()
                }
            }

            Scope (\)
            {
                Method (SLED, 1, NotSerialized)
                {
                    ENFG ()
                    LDN = 0x09
                    Local0 = (OPT4 & 0x3F)
                    OPT4 = (Local0 | Arg0)
                    EXFG ()
                }
            }

            Method (\_SB.PCI0.UAR1._PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
            {
                Return (Package (0x02)
                {
                    0x03, 
                    0x05
                })
            }
        }
    }
}

