/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20040527
 *
 * Disassembly of /tmp/acpidump.5bh0ZF, Wed Sep  8 19:16:35 2004
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "VT9174", "AWRDACPI", 4096)
{
    Scope (\_PR)
    {
        Processor (\_PR.CPU0, 0x00, 0x00000410, 0x06) {}
    }

    Name (U3DX, 0x00)
    Name (U4DX, 0x00)
    Name (U5DX, 0x00)
    Name (U6DX, 0x00)
    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S1, Package (0x04)
    {
        0x04, 
        0x04, 
        0x04, 
        0x04
    })
    Name (\SS3, Package (0x04)
    {
        0x01, 
        0x01, 
        0x01, 
        0x01
    })
    Name (\_S4, Package (0x04)
    {
        0x02, 
        0x02, 
        0x02, 
        0x02
    })
    Name (\_S5, Package (0x04)
    {
        0x02, 
        0x02, 
        0x02, 
        0x02
    })
    OperationRegion (\DEBG, SystemIO, 0x80, 0x01)
    Field (\DEBG, ByteAcc, NoLock, Preserve)
    {
        DBG1,   8
    }

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

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

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

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

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

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

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

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

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

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

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

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

        Return (One)
    }

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

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

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

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

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

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

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

            Decrement (Local2)
        }

        Store (Local0, S1B)
    }

    Method (\_PTS, 1, NotSerialized)
    {
        Or (Arg0, 0xF0, Local0)
        Store (Local0, DBG1)
        \_SB.PCI0.OSTP ()
        If (LEqual (Arg0, 0x01))
        {
            If (LNot (LEqual (OSFL, 0x00)))
            {
                Store (\_SB.PCI0.USB3.ECDX, U3DX)
                Store (\_SB.PCI0.USB4.ECDX, U4DX)
                Store (\_SB.PCI0.USB5.ECDX, U5DX)
                Store (0x02, \_SB.PCI0.USB3.ECDX)
                Store (0x02, \_SB.PCI0.USB4.ECDX)
                Store (0x02, \_SB.PCI0.USB5.ECDX)
            }

            Store (0x03, \_SB.PCI0.USB6.ECDX)
            While (PRII)
            {
                Store (One, PRII)
            }

            While (LNot (LEqual (PADS, 0x00)))
            {
                Store (PADS, PADS)
            }

            Or (IRQR, 0x80, IRQR)
        }

        If (LEqual (Arg0, 0x03))
        {
            Or (Arg0, 0x50, Local1)
            Store (Local1, SCP)
        }

        If (LEqual (Arg0, 0x04))
        {
            Sleep (0x64)
            Store (One, LANE)
            Or (Arg0, 0x50, Local2)
            Store (Local2, SCP)
        }

        If (LEqual (Arg0, 0x05))
        {
            Store (One, LANE)
        }

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

    Method (\_WAK, 1, NotSerialized)
    {
        Store (0xFF, DBG1)
        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x03)) {}
        If (LEqual (Arg0, 0x01))
        {
            If (LNot (LEqual (OSFL, 0x00)))
            {
                Store (U3DX, \_SB.PCI0.USB3.ECDX)
                Store (U4DX, \_SB.PCI0.USB4.ECDX)
                Store (U5DX, \_SB.PCI0.USB5.ECDX)
            }

            Store (U6DX, \_SB.PCI0.USB6.ECDX)
            And (IRQR, 0x7F, IRQR)
            While (PRII)
            {
                Store (One, PRII)
            }

            While (LNot (LEqual (PADS, 0x00)))
            {
                Store (PADS, PADS)
            }
        }

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

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

        Method (_SST, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x03)) {}
            If (LEqual (Arg0, 0x01)) {}
            If (LEqual (Arg0, Zero)) {}
            Store (Local0, Local0)
        }
    }

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

        Method (_L0E, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB0, 0x02)
            Notify (\_SB.PCI0.USB3, 0x02)
            Notify (\_SB.PCI0.USB4, 0x02)
            Notify (\_SB.PCI0.USB5, 0x02)
            Notify (\_SB.PCI0.USB6, 0x02)
        }

        Method (_L05, 0, NotSerialized)
        {
            Store (0x01, \_SB.PCI0.CRD0.PMST)
            Store (0x01, \_SB.PCI0.CRD1.PMST)
            Notify (\_SB.PCI0, 0x02)
        }

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

        Method (_L0D, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.AC97, 0x02)
        }
    }

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

        Device (MEM)
        {
            Name (_HID, EisaId ("PNP0C01"))
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite, 0x000F0000, 0x00004000)
                    Memory32Fixed (ReadWrite, 0x000F4000, 0x00004000)
                    Memory32Fixed (ReadWrite, 0x000F8000, 0x00004000)
                    Memory32Fixed (ReadWrite, 0x000FC000, 0x00004000)
                    Memory32Fixed (ReadWrite, 0x00000000, 0x00010000)
                    Memory32Fixed (ReadWrite, 0xFFFF0000, 0x00010000)
                    Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000)
                    Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
                    Memory32Fixed (ReadWrite, 0xFEE00000, 0x00001000)
                    Memory32Fixed (ReadWrite, 0xFFF80000, 0x00070000)
                })
                CreateDWordField (BUF0, 0x34, ACMM)
                CreateDWordField (BUF0, 0x04, RMA1)
                CreateDWordField (BUF0, 0x08, RSS1)
                CreateDWordField (BUF0, 0x10, RMA2)
                CreateDWordField (BUF0, 0x14, RSS2)
                CreateDWordField (BUF0, 0x1C, RMA3)
                CreateDWordField (BUF0, 0x20, RSS3)
                CreateDWordField (BUF0, 0x28, RMA4)
                CreateDWordField (BUF0, 0x2C, RSS4)
                CreateDWordField (BUF0, 0x5C, EXTM)
                Subtract (AMEM, 0x00100000, EXTM)
                If (LNot (LEqual (ROM1, Zero)))
                {
                    Store (RMA1, RMA2)
                    ShiftLeft (ROM1, 0x08, Local0)
                    Store (Local0, RMA1)
                    ShiftLeft (RMS1, 0x08, Local0)
                    Store (Local0, RSS1)
                    Store (0x8000, RSS2)
                }

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

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

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

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

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

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

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

            Name (_PRW, Package (0x02)
            {
                0x05, 
                0x05
            })
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    WordBusNumber (ResourceConsumer, MinNotFixed, MaxNotFixed, PosDecode,
                        0x0000,
                        0x0000,
                        0x00FF,
                        0x0000,
                        0x0100)
                    IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,
                        0x0000,
                        0x0CF7,
                        0x0000,
                        0x0CF8)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,
                        0x0D00,
                        0xFFFF,
                        0x0000,
                        0xF300)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,
                        0x000A0000,
                        0x000BFFFF,
                        0x00000000,
                        0x00020000)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,
                        0x000C0000,
                        0x000DFFFF,
                        0x00000000,
                        0x00020000)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,
                        0x00100000,
                        0xFFEFFFFF,
                        0x00000000,
                        0xFFF00000)
                })
                CreateDWordField (BUF0, 0x76, TCMM)
                CreateDWordField (BUF0, 0x82, TOMM)
                Add (AMEM, 0x00010000, TCMM)
                Subtract (0xFFF00000, TCMM, TOMM)
                Return (BUF0)
            }

            Name (PICM, Package (0x13)
            {
                Package (0x04)
                {
                    0x0014FFFF, 
                    0x00, 
                    \_SB.PCI0.LNKB, 
                    0x00
                }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x03, 
                    \_SB.PCI0.LNKC, 
                    0x00
                }
            })
            Method (_PRT, 0, NotSerialized)
            {
                Return (PICM)
            }

            Device (AGPB)
            {
                Name (_ADR, 0x00010000)
                Name (PICM, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        0x00, 
                        \_SB.PCI0.LNKA, 
                        0x00
                    }, 

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

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        \_SB.PCI0.LNKD, 
                        0x00
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    Return (PICM)
                }
            }

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

            Device (VT86)
            {
                Name (_ADR, 0x00110000)
                OperationRegion (VTSB, PCI_Config, 0x00, 0xE8)
                Scope (\)
                {
                    Field (\_SB.PCI0.VT86.VTSB, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x02), 
                        DEID,   16, 
                        Offset (0x52), 
                        SIRQ,   8, 
                        Offset (0x55), 
                        PIRA,   8, 
                        PIBC,   8, 
                        PIRD,   8, 
                        Offset (0x94), 
                        PWC1,   8
                    }
                }
            }

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

                OperationRegion (VIDE, PCI_Config, 0x00, 0xC2)
                Scope (\)
                {
                    Field (\_SB.PCI0.IDE0.VIDE, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x09), 
                        ENAT,   4, 
                        Offset (0x3C), 
                        IDEI,   4
                    }
                }

                Method (A133, 0, NotSerialized)
                {
                    If (LNot (LEqual (DEID, 0x3177)))
                    {
                        If (LEqual (DEID, 0x3147))
                        {
                            Return (One)
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }
                    Else
                    {
                        Return (One)
                    }
                }

                Name (TIM0, Package (0x0F)
                {
                    Package (0x04)
                    {
                        0x78, 
                        0xB4, 
                        0xF0, 
                        0x0258
                    }, 

                    Package (0x04)
                    {
                        0x20, 
                        0x31, 
                        0x65, 
                        0xA8
                    }, 

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

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

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

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

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

                    Package (0x05)
                    {
                        0x00, 
                        0x00, 
                        0x00, 
                        0x01, 
                        0x01
                    }, 

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

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

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

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

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

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

                    Package (0x07)
                    {
                        0x0E, 
                        0x08, 
                        0x06, 
                        0x04, 
                        0x02, 
                        0x01, 
                        0x00
                    }
                })
                Name (TMD0, Buffer (0x14) {})
                CreateDWordField (TMD0, 0x00, PIO0)
                CreateDWordField (TMD0, 0x04, DMA0)
                CreateDWordField (TMD0, 0x08, PIO1)
                CreateDWordField (TMD0, 0x0C, DMA1)
                CreateDWordField (TMD0, 0x10, CHNF)
                OperationRegion (CFG2, PCI_Config, 0x40, 0x20)
                Field (CFG2, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x08), 
                    SSPT,   8, 
                    SMPT,   8, 
                    PSPT,   8, 
                    PMPT,   8, 
                    Offset (0x10), 
                    SSUT,   4, 
                    SSCT,   1, 
                    SSUE,   3, 
                    SMUT,   4, 
                    SMCT,   1, 
                    SMUE,   3, 
                    PSUT,   4, 
                    PSCT,   1, 
                    PSUE,   3, 
                    PMUT,   4, 
                    PMCT,   1, 
                    PMUE,   3
                }

                Name (GMPT, 0x00)
                Name (GMUE, 0x00)
                Name (GMUT, 0x00)
                Name (GSPT, 0x00)
                Name (GSUE, 0x00)
                Name (GSUT, 0x00)
                Name (GBCS, 0x00)
                Device (CHN0)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (GTM (PMPT, PMUE, PMUT, PSPT, PSUE, PSUT))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, TMD0)
                        Store (PMPT, GMPT)
                        Store (PMUE, GMUE)
                        Store (PMUT, GMUT)
                        Store (PSPT, GSPT)
                        Store (PSUE, GSUE)
                        Store (PSUT, GSUT)
                        STM ()
                        Store (GMPT, PMPT)
                        Store (GMUE, PMUE)
                        Store (GMUT, PMUT)
                        Store (GSPT, PSPT)
                        Store (GSUE, PSUE)
                        Store (GSUT, PSUT)
                    }

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

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

                Device (CHN1)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (GTM (SMPT, SMUE, SMUT, SSPT, SSUE, SSUT))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, TMD0)
                        Store (SMPT, GMPT)
                        Store (SMUE, GMUE)
                        Store (SMUT, GMUT)
                        Store (SSPT, GSPT)
                        Store (SSUE, GSUE)
                        Store (SSUT, GSUT)
                        STM ()
                        Store (GMPT, SMPT)
                        Store (GMUE, SMUE)
                        Store (GMUT, SMUT)
                        Store (GSPT, SSPT)
                        Store (GSUE, SSUE)
                        Store (GSUT, SSUT)
                    }

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

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

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

                    If (Arg1)
                    {
                        If (A133 ())
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0D)), Arg2)), UMOD)
                        }
                        Else
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0A)), Arg2)), UMOD)
                        }

                        Or (UMOD, 0x40, UMOD)
                    }
                    Else
                    {
                        Store (Match (DerefOf (Index (TIM0, 0x01)), MEQ, Arg3, MTR, 0x00, 0x00), Local0)
                        Or (0x20, DerefOf (Index (DerefOf (Index (TIM0, 0x09)), Local0)), UMOD)
                    }

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

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

                    Store (Match (DerefOf (Index (TIM0, 0x01)), MEQ, Arg0, MTR, 0x00, 0x00), Local6)
                    Store (DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local6)), Local7)
                    Store (Local7, DMA0)
                    Store (Local7, PIO0)
                    Store (Match (DerefOf (Index (TIM0, 0x01)), MEQ, Arg3, MTR, 0x00, 0x00), Local6)
                    Store (DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local6)), Local7)
                    Store (Local7, DMA1)
                    Store (Local7, PIO1)
                    If (Arg1)
                    {
                        If (A133 ())
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0D)), Arg2)), Local5)
                        }
                        Else
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0A)), Arg2)), Local5)
                        }

                        If (A133 ())
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0C)), Local5)), DMA0)
                        }
                        Else
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local5)), DMA0)
                        }

                        Or (CHNF, 0x01, CHNF)
                    }

                    If (Arg4)
                    {
                        If (A133 ())
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0D)), Arg5)), Local5)
                        }
                        Else
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0A)), Arg5)), Local5)
                        }

                        If (A133 ())
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0C)), Local5)), DMA1)
                        }
                        Else
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local5)), DMA1)
                        }

                        Or (CHNF, 0x04, CHNF)
                    }

                    Return (TMD0)
                }

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

                    Store (0x00, GMUE)
                    Store (0x00, GSUE)
                    Store (0x07, GMUT)
                    Store (0x07, GSUT)
                    If (And (CHNF, 0x01))
                    {
                        If (A133 ())
                        {
                            Store (Match (DerefOf (Index (TIM0, 0x0C)), MLE, DMA0, MTR, 0x00, 0x00), Local0)
                        }
                        Else
                        {
                            Store (Match (DerefOf (Index (TIM0, 0x04)), MLE, DMA0, MTR, 0x00, 0x00), Local0)
                        }

                        If (A133 ())
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0E)), Local0)), GMUT)
                        }
                        Else
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0B)), Local0)), GMUT)
                        }

                        Or (GMUE, 0x07, GMUE)
                    }
                    Else
                    {
                        If (Or (LEqual (PIO0, Ones), LEqual (PIO0, 0x00)))
                        {
                            If (And (LLess (DMA0, Ones), LGreater (DMA0, 0x00)))
                            {
                                Store (DMA0, PIO0)
                            }
                        }
                    }

                    If (And (CHNF, 0x04))
                    {
                        If (A133 ())
                        {
                            Store (Match (DerefOf (Index (TIM0, 0x0C)), MLE, DMA1, MTR, 0x00, 0x00), Local0)
                        }
                        Else
                        {
                            Store (Match (DerefOf (Index (TIM0, 0x04)), MLE, DMA1, MTR, 0x00, 0x00), Local0)
                        }

                        If (A133 ())
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0E)), Local0)), GSUT)
                        }
                        Else
                        {
                            Store (DerefOf (Index (DerefOf (Index (TIM0, 0x0B)), Local0)), GSUT)
                        }

                        Or (GSUE, 0x07, GSUE)
                    }
                    Else
                    {
                        If (Or (LEqual (PIO1, Ones), LEqual (PIO1, 0x00)))
                        {
                            If (And (LLess (DMA1, Ones), LGreater (DMA1, 0x00)))
                            {
                                Store (DMA1, PIO1)
                            }
                        }
                    }

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

            Device (USB0)
            {
                Name (_ADR, 0x00110002)
                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x05
                })
                Method (SS3D, 0, NotSerialized)
                {
                    Store (0x55, DBG1)
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

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

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

            Device (USB3)
            {
                Name (_ADR, 0x00100000)
                OperationRegion (U2F0, PCI_Config, 0x00, 0xC2)
                Field (U2F0, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x84), 
                    ECDX,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (SS3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

            Device (USB4)
            {
                Name (_ADR, 0x00100001)
                OperationRegion (U2F1, PCI_Config, 0x00, 0xC2)
                Field (U2F1, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x84), 
                    ECDX,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (SS3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

            Device (USB5)
            {
                Name (_ADR, 0x00100002)
                OperationRegion (U2F2, PCI_Config, 0x00, 0xC2)
                Field (U2F2, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x84), 
                    ECDX,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (SS3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

            Device (USB6)
            {
                Name (_ADR, 0x00100003)
                OperationRegion (U2F3, PCI_Config, 0x00, 0xC2)
                Field (U2F3, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x84), 
                    ECDX,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x0E, 
                    0x03
                })
                Method (SS3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }
            }

            Device (LAN0)
            {
                Name (_ADR, 0x00120000)
                Name (_PRW, Package (0x02)
                {
                    0x03, 
                    0x05
                })
            }

            Device (AC97)
            {
                Name (_ADR, 0x00110005)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x05
                })
            }

            Device (CRD0)
            {
                Name (_ADR, 0x000A0000)
                Method (_INI, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PSC, 0, NotSerialized)
                {
                    Return (PWST)
                }

                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                OperationRegion (CCRA, PCI_Config, 0xE0, 0x04)
                Field (CCRA, DWordAcc, Lock, Preserve)
                {
                    PWST,   2, 
                    Offset (0x01), 
                        ,   7, 
                    PMST,   1
                }
            }

            Device (CRD1)
            {
                Name (_ADR, 0x000A0001)
                Method (_INI, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PSC, 0, NotSerialized)
                {
                    Return (PWST)
                }

                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (0x01, PMST)
                }

                OperationRegion (CCRB, PCI_Config, 0xE0, 0x04)
                Field (CCRB, DWordAcc, Lock, Preserve)
                {
                    PWST,   2, 
                    Offset (0x01), 
                        ,   7, 
                    PMST,   1
                }
            }

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

                Method (CKIO, 2, NotSerialized)
                {
                }

                Method (SLDM, 2, NotSerialized)
                {
                }
            }

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

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

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFB, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    CreateByteField (BUFB, 0x01, IRB1)
                    CreateByteField (BUFB, 0x02, IRB2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIRA, 0xF0, Local1)
                    ShiftRight (Local1, 0x04, Local1)
                    If (LNot (LEqual (Local1, 0x00)))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

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

                    Return (BUFB)
                }

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

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

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

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

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFA, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    CreateByteField (BUFA, 0x01, IRA1)
                    CreateByteField (BUFA, 0x02, IRA2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIBC, 0x0F, Local1)
                    If (LNot (LEqual (Local1, 0x00)))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

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

                    Return (BUFA)
                }

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

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

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

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

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    CreateByteField (BUFC, 0x01, IRC1)
                    CreateByteField (BUFC, 0x02, IRC2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIBC, 0xF0, Local1)
                    ShiftRight (Local1, 0x04, Local1)
                    If (LNot (LEqual (Local1, 0x00)))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

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

                    Return (BUFC)
                }

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

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

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

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

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUFD, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    CreateByteField (BUFD, 0x01, IRD1)
                    CreateByteField (BUFD, 0x02, IRD2)
                    Store (0x00, Local3)
                    Store (0x00, Local4)
                    And (PIRD, 0xF0, Local1)
                    ShiftRight (Local1, 0x04, Local1)
                    If (LNot (LEqual (Local1, 0x00)))
                    {
                        If (LGreater (Local1, 0x07))
                        {
                            Subtract (Local1, 0x08, Local2)
                            ShiftLeft (One, Local2, Local4)
                        }
                        Else
                        {
                            If (LGreater (Local1, 0x00))
                            {
                                ShiftLeft (One, Local1, Local3)
                            }
                        }

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

                    Return (BUFD)
                }

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

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

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

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

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

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

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

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

            Device (PIC)
            {
                Name (_HID, EisaId ("PNP0000"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
                    IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
                    IRQNoFlags () {2}
                })
            }

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

            Device (TMR)
            {
                Name (_HID, EisaId ("PNP0100"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                    IRQNoFlags () {0}
                })
            }

            Device (RTC)
            {
                Name (_HID, EisaId ("PNP0B00"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x0070, 0x0070, 0x04, 0x04)
                    IRQNoFlags () {8}
                })
            }

            Device (SPKR)
            {
                Name (_HID, EisaId ("PNP0800"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
                })
            }

            Device (COPR)
            {
                Name (_HID, EisaId ("PNP0C04"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x10)
                    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, 
                    Offset (0x70), 
                    INTR,   8, 
                    Offset (0x72), 
                    INT1,   8, 
                    Offset (0x74), 
                    DMCH,   8, 
                    Offset (0xC0), 
                    GP40,   8, 
                    Offset (0xF0), 
                    OPT1,   8, 
                    OPT2,   8, 
                    OPT3,   8, 
                    OPT4,   8, 
                    OPT5,   8, 
                    OPT6,   8, 
                    OPT7,   8
                }

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

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

            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)
            {
                Store (Arg0, Local0)
                If (LEqual (Local0, 0x03F8))
                {
                    Store (P3FD, Local0)
                    Store (P3FD, Local0)
                    Store (0xC3, P3FA)
                    While (LNot (LEqual (P3FA, 0xC1)))
                    {
                        Store (P3FE, Local0)
                    }
                }
                Else
                {
                    If (LEqual (Local0, 0x02F8))
                    {
                        Store (P2FD, Local0)
                        Store (P2FD, Local0)
                        Store (0xC3, P2FA)
                        While (LNot (LEqual (P2FA, 0xC1)))
                        {
                            Store (P2FE, Local0)
                        }
                    }
                    Else
                    {
                        If (LEqual (Local0, 0x03E8))
                        {
                            Store (P3ED, Local0)
                            Store (P3ED, Local0)
                            Store (0xC3, P3EA)
                            While (LNot (LEqual (P3EA, 0xC1)))
                            {
                                Store (P3EE, Local0)
                            }
                        }
                        Else
                        {
                            If (LEqual (Local0, 0x02E8))
                            {
                                Store (P2ED, Local0)
                                Store (P2ED, Local0)
                                Store (0xC3, P2EA)
                                While (LNot (LEqual (P2EA, 0xC1)))
                                {
                                    Store (P2EE, Local0)
                                }
                            }
                        }
                    }
                }
            }

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

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16, 0x03F0, 0x03F0, 0x00, 0x06)
                        IO (Decode16, 0x03F7, 0x03F7, 0x00, 0x01)
                        IRQNoFlags () {6}
                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
                    })
                    CreateByteField (BUF0, 0x02, IOLO)
                    CreateByteField (BUF0, 0x03, IOHI)
                    CreateByteField (BUF0, 0x04, IORL)
                    CreateByteField (BUF0, 0x05, IORH)
                    ENFG ()
                    EXFG ()
                    Return (BUF0)
                }

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

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

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                        IRQNoFlags () {4}
                    })
                    CreateWordField (BUF1, 0x02, IMIN)
                    CreateWordField (BUF1, 0x04, IMAX)
                    CreateWordField (BUF1, 0x09, IRQW)
                    ENFG ()
                    Store (0x02, LDN)
                    Store (IOAH, Local0)
                    ShiftLeft (Local0, 0x02, Local0)
                    Store (Local0, IMIN)
                    Store (Local0, IMAX)
                    Store (INTR, Local0)
                    And (Local0, 0x0F, Local0)
                    Store (One, Local1)
                    ShiftLeft (Local1, Local0, IRQW)
                    EXFG ()
                    Return (BUF1)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                        IRQNoFlags () {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02F8, 0x02F8, 0x08, 0x08)
                        IRQNoFlags () {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03E8, 0x03E8, 0x08, 0x08)
                        IRQNoFlags () {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02E8, 0x02E8, 0x08, 0x08)
                        IRQNoFlags () {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x02, LDN)
                    Store (IOLO, Local0)
                    ShiftRight (Local0, 0x02, Local0)
                    And (Local0, 0xFE, Local0)
                    Store (IOHI, Local1)
                    ShiftLeft (Local1, 0x06, Local1)
                    Or (Local0, Local1, Local0)
                    Store (Local0, IOAH)
                    FindSetRightBit (IRQW, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        Decrement (Local0)
                    }

                    Store (Local0, INTR)
                    Store (One, ACTR)
                    EXFG ()
                }
            }

            Device (UAR2)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x02)
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    If (ACTR)
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    Else
                    {
                        If (LNot (LEqual (IOAH, 0x00)))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                }

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF2, ResourceTemplate ()
                    {
                        IO (Decode16, 0x02F8, 0x02F8, 0x08, 0x08)
                        IRQNoFlags () {3}
                    })
                    CreateWordField (BUF2, 0x02, IMIN)
                    CreateWordField (BUF2, 0x04, IMAX)
                    CreateWordField (BUF2, 0x09, IRQ0)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (IOAH, Local0)
                    ShiftLeft (Local0, 0x02, Local0)
                    Store (Local0, IMIN)
                    Store (Local0, IMAX)
                    Store (INTR, Local0)
                    And (Local0, 0x0F, Local0)
                    Store (One, Local1)
                    ShiftLeft (Local1, Local0, IRQ0)
                    EXFG ()
                    Return (BUF2)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                        IRQNoFlags () {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02F8, 0x02F8, 0x08, 0x08)
                        IRQNoFlags () {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03E8, 0x03E8, 0x08, 0x08)
                        IRQNoFlags () {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02E8, 0x02E8, 0x08, 0x08)
                        IRQNoFlags () {3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (IOLO, Local0)
                    ShiftRight (Local0, 0x02, Local0)
                    And (Local0, 0xFE, Local0)
                    Store (IOHI, Local1)
                    ShiftLeft (Local1, 0x06, Local1)
                    Or (Local0, Local1, Local0)
                    Store (Local0, IOAH)
                    FindSetRightBit (IRQW, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        Decrement (Local0)
                    }

                    Store (Local0, INTR)
                    Store (One, ACTR)
                    EXFG ()
                }
            }

            Device (LPT1)
            {
                Name (PIOM, Buffer (0x01)
                {
                    0x00
                })
                CreateByteField (PIOM, 0x00, LPTM)
                Name (_HID, EisaId ("PNP0400"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (One, LDN)
                    Store (ACTR, Local0)
                    And (Local0, 0x03, Local0)
                    If (LEqual (Local0, 0x01))
                    {
                        EXFG ()
                        Return (0x00)
                    }

                    If (LEqual (Local0, 0x03))
                    {
                        Store (IOAH, Local1)
                        If (LNot (LEqual (Local1, 0x00)))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        Store (Local0, LPTM)
                        EXFG ()
                        Return (0x0F)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (One, LDN)
                    Store (0x03, ACTR)
                    EXFG ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF5, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0378, 0x0378, 0x08, 0x08)
                        IRQNoFlags () {7}
                    })
                    CreateWordField (BUF5, 0x02, IMIN)
                    CreateWordField (BUF5, 0x04, IMAX)
                    CreateByteField (BUF5, 0x06, LALN)
                    CreateByteField (BUF5, 0x07, LLEN)
                    CreateWordField (BUF5, 0x09, IRQ0)
                    ENFG ()
                    Store (One, LDN)
                    Store (IOAH, Local0)
                    ShiftLeft (Local0, 0x02, Local0)
                    Store (Local0, IMIN)
                    Store (Local0, IMAX)
                    If (LEqual (IMIN, 0x03BC))
                    {
                        Store (0x04, LALN)
                        Store (0x04, LLEN)
                    }
                    Else
                    {
                        Store (0x08, LALN)
                        Store (0x08, LLEN)
                    }

                    Store (INTR, Local0)
                    Store (0x01, Local1)
                    ShiftLeft (Local1, Local0, IRQ0)
                    EXFG ()
                    Return (BUF5)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x0378, 0x0378, 0x08, 0x08)
                        IRQNoFlags () {7}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x0278, 0x0278, 0x08, 0x08)
                        IRQNoFlags () {5}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03BC, 0x03BC, 0x04, 0x04)
                        IRQNoFlags () {7}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x09, IRQ0)
                    ENFG ()
                    Store (One, LDN)
                    Store (IOLO, Local0)
                    ShiftRight (Local0, 0x02, Local0)
                    Store (IOHI, Local1)
                    ShiftLeft (Local1, 0x06, Local1)
                    Or (Local0, Local1, Local0)
                    Store (Local0, IOAH)
                    FindSetRightBit (IRQ0, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        Decrement (Local0)
                    }

                    Store (Local0, INTR)
                    Store (ACTR, Local0)
                    And (Local0, 0xFC, Local0)
                    Store (LPTM, Local1)
                    Or (Local0, Local1, Local1)
                    Store (Local1, ACTR)
                    EXFG ()
                }
            }

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

                    If (LEqual (Local0, 0x01))
                    {
                        EXFG ()
                        Return (0x0F)
                    }

                    If (LEqual (Local0, 0x03))
                    {
                        If (LNot (LEqual (DMCH, 0x00)))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (One, LDN)
                    Store (0x03, ACTR)
                    EXFG ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF6, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0378, 0x0378, 0x08, 0x08)
                        IO (Decode16, 0x0778, 0x0778, 0x04, 0x04)
                        IRQNoFlags () {7}
                        DMA (Compatibility, NotBusMaster, Transfer8) {3}
                    })
                    CreateWordField (BUF6, 0x02, IMI1)
                    CreateWordField (BUF6, 0x04, IMA1)
                    CreateByteField (BUF6, 0x06, ALN1)
                    CreateByteField (BUF6, 0x07, LEN1)
                    CreateWordField (BUF6, 0x0A, IMI2)
                    CreateWordField (BUF6, 0x0C, IMA2)
                    CreateWordField (BUF6, 0x11, IRQ0)
                    CreateByteField (BUF6, 0x14, DMA0)
                    ENFG ()
                    Store (One, LDN)
                    Store (IOAH, Local0)
                    ShiftLeft (Local0, 0x02, Local0)
                    Store (Local0, IMI1)
                    Store (Local0, IMA1)
                    Add (Local0, 0x0400, Local0)
                    Store (Local0, IMI2)
                    Store (Local0, IMA2)
                    If (LEqual (IMI1, 0x03BC))
                    {
                        Store (0x04, ALN1)
                        Store (0x04, LEN1)
                    }
                    Else
                    {
                        Store (0x08, ALN1)
                        Store (0x08, LEN1)
                    }

                    Store (INTR, Local0)
                    Store (0x01, Local1)
                    ShiftLeft (Local1, Local0, IRQ0)
                    Store (DMCH, Local0)
                    And (Local0, 0x03, Local0)
                    Store (0x01, Local1)
                    ShiftLeft (Local1, Local0, DMA0)
                    EXFG ()
                    Return (BUF6)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x0378, 0x0378, 0x08, 0x08)
                        IO (Decode16, 0x0778, 0x0778, 0x04, 0x04)
                        IRQNoFlags () {7}
                        DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x0278, 0x0278, 0x08, 0x08)
                        IO (Decode16, 0x0678, 0x0678, 0x04, 0x04)
                        IRQNoFlags () {5}
                        DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03BC, 0x03BC, 0x04, 0x04)
                        IO (Decode16, 0x07BC, 0x07BC, 0x04, 0x04)
                        IRQNoFlags () {7}
                        DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x11, IRQ0)
                    CreateByteField (Arg0, 0x14, DMA0)
                    ENFG ()
                    Store (One, LDN)
                    Store (IOLO, Local0)
                    ShiftRight (Local0, 0x02, Local0)
                    Store (IOHI, Local1)
                    ShiftLeft (Local1, 0x06, Local1)
                    Or (Local0, Local1, Local0)
                    Store (Local0, IOAH)
                    FindSetRightBit (IRQ0, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        Decrement (Local0)
                    }

                    Store (Local0, INTR)
                    FindSetRightBit (DMA0, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        Decrement (Local0)
                    }

                    Store (Local0, DMCH)
                    Store (ACTR, Local0)
                    And (Local0, 0xFC, Local0)
                    Or (Local0, 0x01, Local0)
                    Store (Local0, ACTR)
                    EXFG ()
                }
            }

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

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

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

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

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

                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                    IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                    IRQNoFlags () {1}
                })
            }

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

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

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

                        Return (0x00)
                    }

                    Return (0x0F)
                }

                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                    IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                })
            }

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

                    EXFG ()
                }

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

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x80)
                        IRQNoFlags () {}
                        DMA (Compatibility, NotBusMaster, Transfer8) {}
                    })
                    CreateByteField (BUF1, 0x02, IOLO)
                    CreateByteField (BUF1, 0x03, IOHI)
                    CreateByteField (BUF1, 0x04, IORL)
                    CreateByteField (BUF1, 0x05, IORH)
                    CreateWordField (BUF1, 0x09, IRQW)
                    CreateByteField (BUF1, 0x0C, DMA0)
                    ENFG ()
                    Store (0x0C, LDN)
                    Store (IOAL, IOLO)
                    Store (IOAL, IORL)
                    Store (IOAH, IOHI)
                    Store (IOAH, IORH)
                    Store (One, Local0)
                    ShiftLeft (Local0, INTR, IRQW)
                    Store (DMCH, Local0)
                    And (Local0, 0x0F, Local1)
                    If (LEqual (Local1, 0x0A))
                    {
                        Store (0x06, Local0)
                    }

                    Store (One, Local1)
                    ShiftLeft (Local1, Local0, DMA0)
                    EXFG ()
                    Return (BUF1)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0xE600, 0xE600, 0x01, 0x80)
                        IRQNoFlags () {3,4,5,7,9,10,11,12}
                        DMA (Compatibility, NotBusMaster, Transfer8) {5,6}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    CreateByteField (Arg0, 0x0C, DMA0)
                    ENFG ()
                    Store (0x0C, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, INTR)
                    Store (DMA0, Local0)
                    If (LEqual (Local0, 0x40))
                    {
                        Store (0x0A, DMCH)
                    }
                    Else
                    {
                        FindSetRightBit (DMA0, Local0)
                        Subtract (Local0, 0x01, DMCH)
                    }

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

            Scope (\)
            {
                OperationRegion (WIN2, SystemIO, 0x4E, 0x02)
                Field (WIN2, ByteAcc, NoLock, Preserve)
                {
                    SINP,   8, 
                    SDAT,   8
                }

                IndexField (SINP, SDAT, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x02), 
                    SCFG,   8, 
                    Offset (0x07), 
                    SLDN,   8, 
                    Offset (0x20), 
                    SDHI,   8, 
                    SDLO,   8, 
                    SOWC,   8, 
                    Offset (0x30), 
                    SCTR,   8, 
                    Offset (0x60), 
                    SOAH,   8, 
                    SOAL,   8, 
                    Offset (0x70), 
                    SNTR,   8, 
                    Offset (0x72), 
                    SNT1,   8, 
                    Offset (0x74), 
                    SMCH,   8, 
                    Offset (0xC0), 
                    SP40,   8, 
                    Offset (0xF0), 
                    SPT1,   8, 
                    SPT2,   8, 
                    SPT3,   8, 
                    SPT4,   8, 
                    SPT5,   8, 
                    SPT6,   8, 
                    SPT7,   8
                }

                Method (SENF, 0, NotSerialized)
                {
                    Store (0x87, SINP)
                    Store (0x87, SINP)
                }

                Method (SEXF, 0, NotSerialized)
                {
                    Store (0xAA, SINP)
                }
            }

            OperationRegion (COM5, SystemIO, 0x03F8, 0x08)
            Field (COM5, ByteAcc, NoLock, Preserve)
            {
                S3F8,   8, 
                S3F9,   8, 
                S3FA,   8, 
                S3FB,   8, 
                S3FC,   8, 
                S3FD,   8, 
                S3FE,   8, 
                S3FF,   8
            }

            OperationRegion (COM6, SystemIO, 0x02F8, 0x08)
            Field (COM6, ByteAcc, NoLock, Preserve)
            {
                S2F8,   8, 
                S2F9,   8, 
                S2FA,   8, 
                S2FB,   8, 
                S2FC,   8, 
                S2FD,   8, 
                S2FE,   8, 
                S2FF,   8
            }

            OperationRegion (COM7, SystemIO, 0x03E8, 0x08)
            Field (COM7, ByteAcc, NoLock, Preserve)
            {
                S3E8,   8, 
                S3E9,   8, 
                S3EA,   8, 
                S3EB,   8, 
                S3EC,   8, 
                S3ED,   8, 
                S3EE,   8, 
                S3EF,   8
            }

            OperationRegion (COM8, SystemIO, 0x02E8, 0x08)
            Field (COM8, ByteAcc, NoLock, Preserve)
            {
                S2E8,   8, 
                S2E9,   8, 
                S2EA,   8, 
                S2EB,   8, 
                S2EC,   8, 
                S2ED,   8, 
                S2EE,   8, 
                S2EF,   8
            }

            Method (SICO, 1, NotSerialized)
            {
                Store (Arg0, Local0)
                If (LEqual (Local0, 0x03F8))
                {
                    Store (S3FD, Local0)
                    Store (S3FD, Local0)
                    Store (0xC3, S3FA)
                    While (LNot (LEqual (S3FA, 0xC1)))
                    {
                        Store (S3FE, Local0)
                    }
                }
                Else
                {
                    If (LEqual (Local0, 0x02F8))
                    {
                        Store (S2FD, Local0)
                        Store (S2FD, Local0)
                        Store (0xC3, S2FA)
                        While (LNot (LEqual (S2FA, 0xC1)))
                        {
                            Store (S2FE, Local0)
                        }
                    }
                    Else
                    {
                        If (LEqual (Local0, 0x03E8))
                        {
                            Store (S3ED, Local0)
                            Store (S3ED, Local0)
                            Store (0xC3, S3EA)
                            While (LNot (LEqual (S3EA, 0xC1)))
                            {
                                Store (S3EE, Local0)
                            }
                        }
                        Else
                        {
                            If (LEqual (Local0, 0x02E8))
                            {
                                Store (S2ED, Local0)
                                Store (S2ED, Local0)
                                Store (0xC3, S2EA)
                                While (LNot (LEqual (S2EA, 0xC1)))
                                {
                                    Store (S2EE, Local0)
                                }
                            }
                        }
                    }
                }
            }

            Device (UAR3)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x03)
                Method (_STA, 0, NotSerialized)
                {
                    SENF ()
                    Store (0x02, SLDN)
                    If (SCTR)
                    {
                        SEXF ()
                        Return (0x0F)
                    }
                    Else
                    {
                        If (LNot (LEqual (SOAH, 0x00)))
                        {
                            SEXF ()
                            Return (0x0D)
                        }
                        Else
                        {
                            SEXF ()
                            Return (0x00)
                        }
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    SENF ()
                    Store (0x02, SLDN)
                    Store (Zero, SCTR)
                    SEXF ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                        IRQNoFlags () {5}
                    })
                    CreateWordField (BUF1, 0x02, IMIN)
                    CreateWordField (BUF1, 0x04, IMAX)
                    CreateWordField (BUF1, 0x09, IRQW)
                    SENF ()
                    Store (0x02, SLDN)
                    Store (SOAH, Local0)
                    ShiftLeft (Local0, 0x02, Local0)
                    Store (Local0, IMIN)
                    Store (Local0, IMAX)
                    Store (SNTR, Local0)
                    And (Local0, 0x0F, Local0)
                    Store (One, Local1)
                    ShiftLeft (Local1, Local0, IRQW)
                    SEXF ()
                    Return (BUF1)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                        IRQNoFlags () {5}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02F8, 0x02F8, 0x08, 0x08)
                        IRQNoFlags () {10}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03E8, 0x03E8, 0x08, 0x08)
                        IRQNoFlags () {5}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02E8, 0x02E8, 0x08, 0x08)
                        IRQNoFlags () {10}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x09, IRQW)
                    SENF ()
                    Store (0x02, SLDN)
                    Store (IOLO, Local0)
                    ShiftRight (Local0, 0x02, Local0)
                    And (Local0, 0xFE, Local0)
                    Store (IOHI, Local1)
                    ShiftLeft (Local1, 0x06, Local1)
                    Or (Local0, Local1, Local0)
                    Store (Local0, SOAH)
                    FindSetRightBit (IRQW, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        Decrement (Local0)
                    }

                    Store (Local0, SNTR)
                    Store (One, SCTR)
                    SEXF ()
                }
            }

            Device (UAR4)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x04)
                Method (_STA, 0, NotSerialized)
                {
                    SENF ()
                    Store (0x03, SLDN)
                    If (SCTR)
                    {
                        SEXF ()
                        Return (0x0F)
                    }
                    Else
                    {
                        If (LNot (LEqual (SOAH, 0x00)))
                        {
                            SEXF ()
                            Return (0x0D)
                        }
                        Else
                        {
                            SEXF ()
                            Return (0x00)
                        }
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    SENF ()
                    Store (0x03, SLDN)
                    Store (Zero, SCTR)
                    SEXF ()
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF2, ResourceTemplate ()
                    {
                        IO (Decode16, 0x02F8, 0x02F8, 0x08, 0x08)
                        IRQNoFlags () {10}
                    })
                    CreateWordField (BUF2, 0x02, IMIN)
                    CreateWordField (BUF2, 0x04, IMAX)
                    CreateWordField (BUF2, 0x09, IRQ0)
                    SENF ()
                    Store (0x03, SLDN)
                    Store (SOAH, Local0)
                    ShiftLeft (Local0, 0x02, Local0)
                    Store (Local0, IMIN)
                    Store (Local0, IMAX)
                    Store (SNTR, Local0)
                    And (Local0, 0x0F, Local0)
                    Store (One, Local1)
                    ShiftLeft (Local1, Local0, IRQ0)
                    SEXF ()
                    Return (BUF2)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                        IRQNoFlags () {5}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02F8, 0x02F8, 0x08, 0x08)
                        IRQNoFlags () {10}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x03E8, 0x03E8, 0x08, 0x08)
                        IRQNoFlags () {5}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16, 0x02E8, 0x02E8, 0x08, 0x08)
                        IRQNoFlags () {10}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x09, IRQW)
                    SENF ()
                    Store (0x03, SLDN)
                    Store (IOLO, Local0)
                    ShiftRight (Local0, 0x02, Local0)
                    And (Local0, 0xFE, Local0)
                    Store (IOHI, Local1)
                    ShiftLeft (Local1, 0x06, Local1)
                    Or (Local0, Local1, Local0)
                    Store (Local0, SOAH)
                    FindSetRightBit (IRQW, Local0)
                    If (LGreater (Local0, 0x00))
                    {
                        Decrement (Local0)
                    }

                    Store (Local0, SNTR)
                    Store (One, SCTR)
                    SEXF ()
                }
            }

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