/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20041119
 *
 * Disassembly of /tmp/acpidump.f1ANfX, Wed Aug 30 03:14:56 2006
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "Intel", "LINDHRST", 100925440)
{
    Scope (_GPE)
    {
        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
        }

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

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

        Method (_L08, 0, NotSerialized)
        {
            Store (0xCC, \_SB.PCI0.PT80)
            Notify (\_SB.PCI0.LPC0.SIO.COM1, 0x02)
        }

        Method (_L0B, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.PCIB, 0x02)
            Notify (\_SB.PCI0.LPC0.KBC0, 0x02)
            Notify (\_SB.PCI0.LPC0.MSE0, 0x02)
        }

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

        Method (_L18, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.P0P2, 0x02)
        }
    }

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

    Scope (_SB)
    {
        OperationRegion (ACB, SystemMemory, 0x3FF7AEBC, 0x00000090)
        Field (ACB, AnyAcc, NoLock, Preserve)
        {
            BCMD,   8, 
            DID,    32, 
            INFO,   1104
        }

        Field (ACB, AnyAcc, NoLock, Preserve)
        {
            DMY,    40, 
            INF,    8
        }

        OperationRegion (SMIB, SystemIO, 0x0000FE00, 0x02)
        Field (SMIB, AnyAcc, NoLock, Preserve)
        {
            SMIC,   8
        }

        Name (OSTB, 0xFFFFFFFF)
        Method (OSTP, 0, NotSerialized)
        {
            If (LEqual (^OSTB, 0xFFFFFFFF))
            {
                If (CondRefOf (\_OSI, Local0))
                {
                    If (\_OSI ("Windows 2001"))
                    {
                        Store (0x08, ^OSTB)
                    }
                    Else
                    {
                        Store (0x00, ^OSTB)
                    }
                }
                Else
                {
                    If (CondRefOf (\_OS, Local0))
                    {
                        If (^SEQL (\_OS, "Microsoft Windows"))
                        {
                            Store (0x01, ^OSTB)
                        }
                        Else
                        {
                            If (^SEQL (\_OS, "Microsoft WindowsME: Millennium Edition"))
                            {
                                Store (0x02, ^OSTB)
                            }
                            Else
                            {
                                If (^SEQL (\_OS, "Microsoft Windows NT"))
                                {
                                    Store (0x04, ^OSTB)
                                }
                                Else
                                {
                                    Store (0x00, ^OSTB)
                                }
                            }
                        }
                    }
                    Else
                    {
                        Store (0x00, ^OSTB)
                    }
                }
            }

            Return (^OSTB)
        }

        Method (SEQL, 2, Serialized)
        {
            Noop
            Store (SizeOf (Arg0), Local0)
            Store (SizeOf (Arg1), Local1)
            If (LNot (LEqual (Local0, Local1)))
            {
                Return (Zero)
            }

            Name (BUF0, Buffer (Local0) {})
            Store (Arg0, BUF0)
            Name (BUF1, Buffer (Local0) {})
            Store (Arg1, BUF1)
            Store (Zero, Local2)
            While (LLess (Local2, Local0))
            {
                Store (DerefOf (Index (BUF0, Local2)), Local3)
                Store (DerefOf (Index (BUF1, Local2)), Local4)
                If (LNot (LEqual (Local3, Local4)))
                {
                    Return (Zero)
                }

                Increment (Local2)
            }

            Return (One)
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_BBN, 0x00)
            Name (_ADR, 0x00)
            Name (RSRC, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,
                    0x0000,
                    0x00FF,
                    0x0000,
                    0x0100, 0x00)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,
                    0x0000,
                    0x0CF7,
                    0x0000,
                    0x0CF8, 0x00)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,
                    0x0D00,
                    0xFFFF,
                    0x0000,
                    0xF300, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000A0000,
                    0x000BFFFF,
                    0x00000000,
                    0x00020000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C0000,
                    0x000C3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C4000,
                    0x000C7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C8000,
                    0x000CBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000CC000,
                    0x000CFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D0000,
                    0x000D3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D4000,
                    0x000D7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D8000,
                    0x000DBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000DC000,
                    0x000DFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E0000,
                    0x000E3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E4000,
                    0x000E7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E8000,
                    0x000EBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000EC000,
                    0x000EFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x00000000,
                    0x00000000,
                    0x00000000,
                    0x00000000, 0x00)
            })
            Method (_CRS, 0, Serialized)
            {
                CreateDWordField (RSRC, 0x01A4, BTMN)
                CreateDWordField (RSRC, 0x01A8, BTMX)
                CreateDWordField (RSRC, 0x01B0, BTLN)
                And (TOLM, 0xF800, Local0)
                ShiftLeft (Local0, 0x10, Local0)
                Store (Local0, BTMN)
                Subtract (0xFEC00000, Local0, BTLN)
                Subtract (Add (BTMN, BTLN), 0x01, BTMX)
                CreateBitField (RSRC, 0x02D8, C0RW)
                CreateDWordField (RSRC, 0x60, C0MN)
                CreateDWordField (RSRC, 0x64, C0MX)
                CreateDWordField (RSRC, 0x6C, C0LN)
                Store (One, C0RW)
                If (LEqual (And (PAM1, 0x03), 0x01))
                {
                    Store (Zero, C0RW)
                }

                Store (Zero, C0LN)
                If (LNot (And (PAM1, 0x03)))
                {
                    Store (0x4000, C0LN)
                }

                CreateBitField (RSRC, 0x03B0, C4RW)
                CreateDWordField (RSRC, 0x7B, C4MN)
                CreateDWordField (RSRC, 0x7F, C4MX)
                CreateDWordField (RSRC, 0x87, C4LN)
                Store (One, C4RW)
                If (LEqual (And (PAM1, 0x30), 0x10))
                {
                    Store (Zero, C4RW)
                }

                Store (Zero, C4LN)
                If (LNot (And (PAM1, 0x30)))
                {
                    Store (0x4000, C4LN)
                }

                CreateBitField (RSRC, 0x0488, C8RW)
                CreateDWordField (RSRC, 0x96, C8MN)
                CreateDWordField (RSRC, 0x9A, C8MX)
                CreateDWordField (RSRC, 0xA2, C8LN)
                Store (One, C8RW)
                If (LEqual (And (PAM2, 0x03), 0x01))
                {
                    Store (Zero, C8RW)
                }

                Store (Zero, C8LN)
                If (LNot (And (PAM2, 0x03)))
                {
                    Store (0x4000, C8LN)
                }

                CreateBitField (RSRC, 0x0560, CCRW)
                CreateDWordField (RSRC, 0xB1, CCMN)
                CreateDWordField (RSRC, 0xB5, CCMX)
                CreateDWordField (RSRC, 0xBD, CCLN)
                Store (One, CCRW)
                If (LEqual (And (PAM2, 0x30), 0x10))
                {
                    Store (Zero, CCRW)
                }

                Store (Zero, CCLN)
                If (LNot (And (PAM2, 0x30)))
                {
                    Store (0x4000, CCLN)
                }

                CreateBitField (RSRC, 0x0638, D0RW)
                CreateDWordField (RSRC, 0xCC, D0MN)
                CreateDWordField (RSRC, 0xD0, D0MX)
                CreateDWordField (RSRC, 0xD8, D0LN)
                Store (One, D0RW)
                If (LEqual (And (PAM3, 0x03), 0x01))
                {
                    Store (Zero, D0RW)
                }

                Store (Zero, D0LN)
                If (LNot (And (PAM3, 0x03)))
                {
                    Store (0x4000, D0LN)
                }

                CreateBitField (RSRC, 0x0710, D4RW)
                CreateDWordField (RSRC, 0xE7, D4MN)
                CreateDWordField (RSRC, 0xEB, D4MX)
                CreateDWordField (RSRC, 0xF3, D4LN)
                Store (One, D4RW)
                If (LEqual (And (PAM3, 0x30), 0x10))
                {
                    Store (Zero, D4RW)
                }

                Store (Zero, D4LN)
                If (LNot (And (PAM3, 0x30)))
                {
                    Store (0x4000, D4LN)
                }

                CreateBitField (RSRC, 0x07E8, D8RW)
                CreateDWordField (RSRC, 0x0102, D8MN)
                CreateDWordField (RSRC, 0x0106, D8MX)
                CreateDWordField (RSRC, 0x010E, D8LN)
                Store (One, D8RW)
                If (LEqual (And (PAM4, 0x03), 0x01))
                {
                    Store (Zero, D8RW)
                }

                Store (Zero, D8LN)
                If (LNot (And (PAM4, 0x03)))
                {
                    Store (0x4000, D8LN)
                }

                CreateBitField (RSRC, 0x08C0, DCRW)
                CreateDWordField (RSRC, 0x011D, DCMN)
                CreateDWordField (RSRC, 0x0121, DCMX)
                CreateDWordField (RSRC, 0x0129, DCLN)
                Store (One, DCRW)
                If (LEqual (And (PAM4, 0x30), 0x10))
                {
                    Store (Zero, DCRW)
                }

                Store (Zero, DCLN)
                If (LNot (And (PAM4, 0x30)))
                {
                    Store (0x4000, DCLN)
                }

                CreateBitField (RSRC, 0x0998, E0RW)
                CreateDWordField (RSRC, 0x0138, E0MN)
                CreateDWordField (RSRC, 0x013C, E0MX)
                CreateDWordField (RSRC, 0x0144, E0LN)
                Store (One, E0RW)
                If (LEqual (And (PAM5, 0x03), 0x01))
                {
                    Store (Zero, E0RW)
                }

                Store (Zero, E0LN)
                If (LNot (And (PAM5, 0x03)))
                {
                    Store (0x4000, E0LN)
                }

                CreateBitField (RSRC, 0x0A70, E4RW)
                CreateDWordField (RSRC, 0x0153, E4MN)
                CreateDWordField (RSRC, 0x0157, E4MX)
                CreateDWordField (RSRC, 0x015F, E4LN)
                Store (One, E4RW)
                If (LEqual (And (PAM5, 0x30), 0x10))
                {
                    Store (Zero, E4RW)
                }

                Store (Zero, E4LN)
                If (LNot (And (PAM5, 0x30)))
                {
                    Store (0x4000, E4LN)
                }

                CreateBitField (RSRC, 0x0B48, E8RW)
                CreateDWordField (RSRC, 0x016E, E8MN)
                CreateDWordField (RSRC, 0x0172, E8MX)
                CreateDWordField (RSRC, 0x017A, E8LN)
                Store (One, E8RW)
                If (LEqual (And (PAM6, 0x03), 0x01))
                {
                    Store (Zero, E8RW)
                }

                Store (Zero, E8LN)
                If (LNot (And (PAM6, 0x03)))
                {
                    Store (0x4000, E8LN)
                }

                CreateBitField (RSRC, 0x0C20, ECRW)
                CreateDWordField (RSRC, 0x0189, ECMN)
                CreateDWordField (RSRC, 0x018D, ECMX)
                CreateDWordField (RSRC, 0x0195, ECLN)
                Store (One, ECRW)
                If (LEqual (And (PAM6, 0x30), 0x10))
                {
                    Store (Zero, ECRW)
                }

                Store (Zero, ECLN)
                If (LNot (And (PAM6, 0x30)))
                {
                    Store (0x4000, ECLN)
                }

                Return (RSRC)
            }

            Method (_INI, 0, NotSerialized)
            {
                \_SB.OSTP ()
            }

            Device (P0P2)
            {
                Name (_ADR, 0x00020000)
                Name (_PRW, Package (0x02)
                {
                    0x18, 
                    0x05
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }, 

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

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

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPC0.LNKD, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

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

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

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

            Device (P0P4)
            {
                Name (_ADR, 0x00040000)
                Name (_PRW, Package (0x02)
                {
                    0x18, 
                    0x05
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }, 

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

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

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPC0.LNKD, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

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

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

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

            Device (P0P5)
            {
                Name (_ADR, 0x00050000)
                Name (_PRW, Package (0x02)
                {
                    0x18, 
                    0x05
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }, 

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

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

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPC0.LNKD, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

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

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

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

            Device (P0P6)
            {
                Name (_ADR, 0x00060000)
                Name (_PRW, Package (0x02)
                {
                    0x18, 
                    0x05
                })
                Device (P2P3)
                {
                    Name (_ADR, 0x00)
                    Name (_PRW, Package (0x02)
                    {
                        0x18, 
                        0x05
                    })
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (LNot (\PICF))
                        {
                            Return (Package (0x04)
                            {
                                Package (0x04)
                                {
                                    0x0001FFFF, 
                                    0x00, 
                                    \_SB.PCI0.LPC0.LNKA, 
                                    0x00
                                }, 

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

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

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

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

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

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

                    OperationRegion (HPCA, PCI_Config, 0x00, 0xFF)
                    Field (HPCA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x40), 
                            ,   5, 
                        SGPE,   1, 
                            ,   3, 
                        PFRQ,   2, 
                            ,   2, 
                        IOAD,   1, 
                        PMOA,   2, 
                        Offset (0x70), 
                        Offset (0x71), 
                        PMEE,   1, 
                        Offset (0x72), 
                        Offset (0x7A), 
                        DWSE,   8, 
                            ,   6, 
                        CSEP,   1, 
                        CIPS,   1
                    }

                    OperationRegion (HPCB, PCI_Config, 0x00, 0xFF)
                    Field (HPCB, WordAcc, NoLock, Preserve)
                    {
                        Offset (0x7C), 
                        DAT0,   16, 
                        DAT1,   16
                    }
                }

                Device (P2P4)
                {
                    Name (_ADR, 0x02)
                    Name (_PRW, Package (0x02)
                    {
                        0x18, 
                        0x05
                    })
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (LNot (\PICF))
                        {
                            Return (Package (0x04)
                            {
                                Package (0x04)
                                {
                                    0x0003FFFF, 
                                    0x00, 
                                    \_SB.PCI0.LPC0.LNKA, 
                                    0x00
                                }, 

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

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

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

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

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

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

                    OperationRegion (HPCA, PCI_Config, 0x00, 0xFF)
                    Field (HPCA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x3E), 
                            ,   6, 
                        XSBR,   1, 
                        Offset (0x3F), 
                        Offset (0x40), 
                            ,   5, 
                        SGPE,   1, 
                            ,   3, 
                        PFRQ,   2, 
                            ,   2, 
                        IOAD,   1, 
                        PMOA,   2, 
                        Offset (0x70), 
                        Offset (0x71), 
                        PMEE,   1, 
                        Offset (0x72), 
                        Offset (0x7A), 
                        DWSE,   8, 
                            ,   6, 
                        CSEP,   1, 
                        CIPS,   1
                    }

                    OperationRegion (HPCB, PCI_Config, 0x00, 0xFF)
                    Field (HPCB, WordAcc, NoLock, Preserve)
                    {
                        Offset (0x7C), 
                        DAT0,   16, 
                        DAT1,   16
                    }
                }
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (LNot (\PICF))
                {
                    Return (Package (0x21)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            \_SB.PCI0.LPC0.LNKA, 
                            0x00
                        }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            \_SB.PCI0.LPC0.LNKB, 
                            0x00
                        }
                    })
                }
                Else
                {
                    Return (Package (0x21)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            0x00, 
                            0x10
                        }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            Method (_S1D, 0, NotSerialized)
            {
                Return (0x01)
            }

            OperationRegion (DB80, SystemIO, 0x80, 0x01)
            Field (DB80, ByteAcc, NoLock, Preserve)
            {
                PT80,   8
            }

            OperationRegion (DB90, SystemIO, 0x90, 0x01)
            Field (DB90, ByteAcc, NoLock, Preserve)
            {
                PT90,   8
            }

            OperationRegion (REGS, PCI_Config, 0x40, 0xC0)
            Field (REGS, DWordAcc, Lock, Preserve)
            {
                Offset (0x18), 
                    ,   7, 
                HEN,    1, 
                PAM0,   8, 
                PAM1,   8, 
                PAM2,   8, 
                PAM3,   8, 
                PAM4,   8, 
                PAM5,   8, 
                PAM6,   8, 
                Offset (0x27), 
                DRB7,   8, 
                Offset (0x84), 
                TOLM,   16, 
                RMB,    16, 
                RML,    16, 
                ROFF,   16, 
                TOM,    16, 
                EXPB,   16
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)
                OperationRegion (US1W, PCI_Config, 0xC4, 0x04)
                Field (US1W, DWordAcc, Lock, Preserve)
                {
                    W1EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x03, 
                    0x01
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, W1EN)
                    }
                    Else
                    {
                        Store (0x00, W1EN)
                    }
                }

                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x01)
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)
                OperationRegion (US2W, PCI_Config, 0xC4, 0x04)
                Field (US2W, DWordAcc, Lock, Preserve)
                {
                    W2EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x04, 
                    0x01
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, W2EN)
                    }
                    Else
                    {
                        Store (0x00, W2EN)
                    }
                }

                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x01)
                }
            }

            Device (EUSB)
            {
                Name (_ADR, 0x001D0007)
                Name (_S1D, 0x02)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x01
                })
            }

            Device (PCIB)
            {
                Name (_ADR, 0x001E0000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x05)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }, 

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

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

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

                            Package (0x04)
                            {
                                0x0001FFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x05)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

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

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

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

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

                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x01
                })
            }

            Device (LPC0)
            {
                Name (_ADR, 0x001F0000)
                Name (DVEN, 0x00)
                Method (DECD, 4, Serialized)
                {
                    Noop
                }

                Device (MBRD)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x1F)
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0010, 0x0010, 0x01, 0x10)
                        IO (Decode16, 0x0024, 0x0024, 0x01, 0x02)
                        IO (Decode16, 0x0028, 0x0028, 0x01, 0x02)
                        IO (Decode16, 0x002C, 0x002C, 0x01, 0x02)
                        IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
                        IO (Decode16, 0x0030, 0x0030, 0x01, 0x02)
                        IO (Decode16, 0x0034, 0x0034, 0x01, 0x02)
                        IO (Decode16, 0x0038, 0x0038, 0x01, 0x02)
                        IO (Decode16, 0x003C, 0x003C, 0x01, 0x02)
                        IO (Decode16, 0x0050, 0x0050, 0x01, 0x04)
                        IO (Decode16, 0x0072, 0x0072, 0x01, 0x06)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x0090, 0x0090, 0x01, 0x10)
                        IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
                        IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x06)
                        IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
                        IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
                        IO (Decode16, 0x1180, 0x1180, 0x01, 0x40)
                        IO (Decode16, 0xFE00, 0xFE00, 0x01, 0x01)
                        IO (Decode16, 0xFE10, 0xFE10, 0x01, 0x02)
                        IO (Decode16, 0x0600, 0x0600, 0x01, 0x80)
                        IO (Decode16, 0x0CA2, 0x0CA2, 0x01, 0x04)
                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
                        Memory32Fixed (ReadWrite, 0xE0000000, 0x10000000)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0xA2, PMMN)
                        CreateWordField (RSRC, 0xA4, PMMX)
                        And (^^PMBA, 0xFF80, PMMN)
                        Store (PMMN, PMMX)
                        CreateWordField (RSRC, 0xAA, GPMN)
                        CreateWordField (RSRC, 0xAC, GPMX)
                        And (^^GPBA, 0xFFC0, GPMN)
                        Store (GPMN, GPMX)
                        Return (RSRC)
                    }
                }

                OperationRegion (MMTO, PCI_Config, 0xD0, 0x04)
                Field (MMTO, DWordAcc, NoLock, Preserve)
                {
                    MTSE,   32
                }

                Device (MMTM)
                {
                    Name (_HID, EisaId ("PNP0103"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        IRQNoFlags () {0}
                        IRQNoFlags () {8}
                        Memory32Fixed (ReadOnly, 0xFED00000, 0x00000400)
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        ShiftRight (And (MTSE, 0x00038000), 0x0F, Local0)
                        If (And (Local0, 0x04))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Method (_CRS, 0, Serialized)
                    {
                        ShiftRight (And (MTSE, 0x00038000), 0x0F, Local0)
                        If (And (Local0, 0x04))
                        {
                            CreateDWordField (BUF0, 0x0A, TBAS)
                            If (LEqual (Local0, 0x05))
                            {
                                Store (0xFED01000, TBAS)
                            }

                            If (LEqual (Local0, 0x06))
                            {
                                Store (0xFED02000, TBAS)
                            }

                            If (LEqual (Local0, 0x07))
                            {
                                Store (0xFED03000, TBAS)
                            }
                        }

                        Return (BUF0)
                    }
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x10)
                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
                        DMA (Compatibility, NotBusMaster, Transfer16) {4}
                    })
                }

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x0F)
                        IRQ (Edge, ActiveHigh, Exclusive) {13}
                    })
                }

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

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x02)
                        IRQ (Edge, ActiveHigh, Exclusive) {8}
                    })
                }

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

                Device (TIME)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                        IRQ (Edge, ActiveHigh, Exclusive) {0}
                    })
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRA, 0x80, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRA, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRA, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRB, 0x80, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRB, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRB, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRC, 0x80, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRC, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRC, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRD, 0x80, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRD, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRD, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRE, 0x80, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRE, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRE, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRF, 0x80, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRF, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRF, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRG, 0x80, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRG, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRG, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRH, 0x80, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRH, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRH, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                OperationRegion (PIRX, PCI_Config, 0x60, 0x04)
                Field (PIRX, DWordAcc, Lock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8
                }

                OperationRegion (PIRY, PCI_Config, 0x68, 0x04)
                Field (PIRY, DWordAcc, Lock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    PIRE,   8, 
                    PIRF,   8, 
                    PIRG,   8, 
                    PIRH,   8
                }

                OperationRegion (REGS, PCI_Config, 0x40, 0xC0)
                Field (REGS, DWordAcc, Lock, Preserve)
                {
                    PMBA,   16, 
                    Offset (0x18), 
                    GPBA,   16, 
                    Offset (0xB0), 
                        ,   5, 
                    FUND,   2
                }

                Device (KBC0)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQ (Edge, ActiveHigh, Exclusive) {1}
                    })
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x01
                    })
                    Name (SLEP, 0x00)
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            Or (0x08, DVEN, DVEN)
                            Store (0x01, SLEP)
                            Or (0x08, KB0A, KB0A)
                        }
                        Else
                        {
                            And (0xF7, DVEN, DVEN)
                            Store (0x00, SLEP)
                            And (0xF7, KB0A, KB0A)
                        }
                    }
                }

                Device (MSE0)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive) {12}
                    })
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x01
                    })
                    Name (SLEP, 0x00)
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            Or (0x10, DVEN, DVEN)
                            Store (0x01, SLEP)
                            Or (0x10, KB0A, KB0A)
                        }
                        Else
                        {
                            And (0xEF, DVEN, DVEN)
                            Store (0x00, SLEP)
                            And (0xEF, KB0A, KB0A)
                        }

                        If (LEqual (\_SB.OSTP (), 0x02))
                        {
                            And (0xEF, DVEN, DVEN)
                            And (0xEF, KB0A, KB0A)
                        }
                    }
                }

                Device (SIO)
                {
                    Name (_HID, EisaId ("PNP0A05"))
                    Name (_UID, 0x01)
                    Name (_STA, 0x0F)
                    Mutex (S192, 0x00)
                    OperationRegion (SMC1, SystemIO, 0x4E, 0x02)
                    Field (SMC1, ByteAcc, NoLock, Preserve)
                    {
                        INDX,   8, 
                        DATA,   8
                    }

                    IndexField (INDX, DATA, AnyAcc, NoLock, Preserve)
                    {
                        CR00,   8, 
                        Offset (0x02), 
                        CFG,    8, 
                        Offset (0x07), 
                        LDN,    8, 
                        Offset (0x22), 
                        PWC,    8, 
                        LPWC,   8, 
                        Offset (0x30), 
                        CR30,   1, 
                        Offset (0x60), 
                        CR60,   8, 
                        CR61,   8, 
                        Offset (0x70), 
                        CR70,   8, 
                        Offset (0x74), 
                        CR74,   8, 
                        Offset (0xF0), 
                        CRF0,   8, 
                        CRF1,   8, 
                        CRF2,   8
                    }

                    IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
                    {
                        Offset (0xF0), 
                        LPTM,   3
                    }

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

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

                    Device (COM1)
                    {
                        Name (_HID, EisaId ("PNP0501"))
                        Name (_DDN, "COM1")
                        Name (_UID, 0x01)
                        Name (_PRW, Package (0x02)
                        {
                            0x08, 
                            0x05
                        })
                        Method (_STA, 0, NotSerialized)
                        {
                            Acquire (S192, 0xFFFF)
                            ENFG ()
                            Store (0x04, LDN)
                            If (CR30)
                            {
                                EXFG ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (CR60, CR61))
                                {
                                    EXFG ()
                                    Return (0x0D)
                                }
                                Else
                                {
                                    EXFG ()
                                    Return (0x00)
                                }
                            }

                            Release (S192)
                            Return (Local0)
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            ENFG ()
                            Store (0x04, LDN)
                            Store (0x00, CR30)
                            EXFG ()
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (RSRC, ResourceTemplate ()
                            {
                                IO (Decode16, 0x0000, 0x0000, 0x08, 0x08)
                                IRQNoFlags () {}
                            })
                            CreateByteField (RSRC, 0x02, IO1)
                            CreateByteField (RSRC, 0x03, IO2)
                            CreateByteField (RSRC, 0x04, IO3)
                            CreateByteField (RSRC, 0x05, IO4)
                            CreateWordField (RSRC, 0x09, IRQV)
                            Acquire (S192, 0xFFFF)
                            ENFG ()
                            Store (0x04, LDN)
                            If (CR30)
                            {
                                Store (CR61, IO1)
                                Store (CR60, IO2)
                                Store (CR61, IO3)
                                Store (CR60, IO4)
                                Store (0x01, Local0)
                                ShiftLeft (Local0, CR70, IRQV)
                            }

                            EXFG ()
                            Release (S192)
                            Return (RSRC)
                        }

                        Method (_PRS, 0, NotSerialized)
                        {
                            Name (BUF0, ResourceTemplate ()
                            {
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x03F8, 0x03F8, 0x00, 0x08)
                                    IRQNoFlags () {4}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x03F8, 0x03F8, 0x00, 0x08)
                                    IRQNoFlags () {4}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x02F8, 0x02F8, 0x00, 0x08)
                                    IRQNoFlags () {4}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x03E8, 0x03E8, 0x00, 0x08)
                                    IRQNoFlags () {4}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x02E8, 0x02E8, 0x00, 0x08)
                                    IRQNoFlags () {4}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x03F8, 0x03F8, 0x00, 0x08)
                                    IRQNoFlags () {3}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x02F8, 0x02F8, 0x00, 0x08)
                                    IRQNoFlags () {3}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x03E8, 0x03E8, 0x00, 0x08)
                                    IRQNoFlags () {3}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x02E8, 0x02E8, 0x00, 0x08)
                                    IRQNoFlags () {3}
                                }
                                EndDependentFn ()
                            })
                            CreateByteField (BUF0, 0x03, IOLO)
                            CreateByteField (BUF0, 0x04, IOHI)
                            CreateByteField (BUF0, 0x05, IOLM)
                            CreateByteField (BUF0, 0x06, IOHM)
                            CreateWordField (BUF0, 0x0A, IRQV)
                            ENFG ()
                            Store (0x04, LDN)
                            Store (CR61, IOLO)
                            Store (CR60, IOHI)
                            Store (CR61, IOLM)
                            Store (CR60, IOHM)
                            Store (0x01, Local0)
                            ShiftLeft (Local0, CR70, IRQV)
                            EXFG ()
                            Return (BUF0)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, IOLO)
                            CreateByteField (Arg0, 0x03, IOHI)
                            CreateWordField (Arg0, 0x09, IRQV)
                            If (IOLO)
                            {
                                ENFG ()
                                Store (0x04, LDN)
                                Store (0x01, CR30)
                                Store (PWC, Local0)
                                Or (Local0, 0x10)
                                Store (Local0, PWC)
                                Store (IOLO, CR61)
                                Store (IOHI, CR60)
                                FindSetRightBit (IRQV, Local0)
                                Subtract (Local0, 0x01, CR70)
                                EXFG ()
                            }
                            Else
                            {
                                _DIS ()
                            }
                        }

                        Method (_PSC, 0, NotSerialized)
                        {
                            ENFG ()
                            Store (0x04, LDN)
                            Store (CR30, Local0)
                            EXFG ()
                            If (Local0)
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                Return (0x03)
                            }
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            ENFG ()
                            Store (0x04, LDN)
                            Store (0x00, LPWC)
                            Store (PWC, Local0)
                            Or (Local0, 0x10)
                            Store (Local0, PWC)
                            Store (0x01, CR30)
                            EXFG ()
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            ENFG ()
                            Store (0x04, LDN)
                            Store (PWC, Local0)
                            And (Local0, 0xEF)
                            Store (Local0, PWC)
                            EXFG ()
                        }

                        Name (SV60, 0x00)
                        Name (SV61, 0x00)
                        Name (IRQV, 0x00)
                        Method (SAVE, 0, NotSerialized)
                        {
                            ENFG ()
                            Store (0x04, LDN)
                            Store (CR30, Local0)
                            If (Local0)
                            {
                                Store (CR60, SV60)
                                Store (CR61, SV61)
                                Store (CR70, IRQV)
                            }

                            EXFG ()
                        }

                        Method (REST, 0, NotSerialized)
                        {
                            If (LNot (LEqual (SV60, Zero)))
                            {
                                ENFG ()
                                Store (0x04, LDN)
                                Or (CR30, 0x01, CR30)
                                Store (SV60, CR60)
                                Store (SV61, CR61)
                                Store (IRQV, CR70)
                                EXFG ()
                            }
                        }
                    }
                }

                Device (SIO2)
                {
                    Name (_HID, EisaId ("PNP0A05"))
                    Name (_UID, 0x02)
                    Name (_STA, 0x0F)
                    OperationRegion (SMC2, SystemIO, 0x2E, 0x02)
                    Field (SMC2, ByteAcc, NoLock, Preserve)
                    {
                        INDX,   8, 
                        DATA,   8
                    }

                    IndexField (INDX, DATA, AnyAcc, NoLock, Preserve)
                    {
                        AccessAs (ByteAcc, 0x00), 
                        Offset (0x07), 
                        LDN,    8, 
                        Offset (0x30), 
                        CR30,   1, 
                        Offset (0x60), 
                        CR60,   8, 
                        CR61,   8, 
                        CR62,   8, 
                        CR63,   8, 
                        Offset (0x70), 
                        CR70,   8, 
                        CR71,   8, 
                        Offset (0x74), 
                        CR74,   8, 
                        CR75,   8, 
                        Offset (0xF0), 
                        CRF0,   8, 
                        CRF1,   8, 
                        CRF2,   8
                    }

                    Device (COM2)
                    {
                        Name (_HID, EisaId ("PNP0501"))
                        Name (_DDN, "COM2")
                        Name (_UID, 0x02)
                        Name (_PRW, Package (0x02)
                        {
                            0x08, 
                            0x05
                        })
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (0x03, LDN)
                            If (CR30)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (CR60, CR61))
                                {
                                    Return (0x0D)
                                }
                                Else
                                {
                                    Return (0x00)
                                }
                            }

                            Return (Local0)
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            Store (0x03, LDN)
                            Store (0x00, CR30)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (RSRC, ResourceTemplate ()
                            {
                                IO (Decode16, 0x0000, 0x0000, 0x08, 0x08)
                                IRQNoFlags () {}
                            })
                            CreateByteField (RSRC, 0x02, IO1)
                            CreateByteField (RSRC, 0x03, IO2)
                            CreateByteField (RSRC, 0x04, IO3)
                            CreateByteField (RSRC, 0x05, IO4)
                            CreateWordField (RSRC, 0x09, IRQV)
                            Store (0x03, LDN)
                            If (CR30)
                            {
                                Store (CR61, IO1)
                                Store (CR60, IO2)
                                Store (CR61, IO3)
                                Store (CR60, IO4)
                                Store (0x01, Local0)
                                ShiftLeft (Local0, CR70, IRQV)
                            }

                            Return (RSRC)
                        }

                        Method (_PRS, 0, NotSerialized)
                        {
                            Name (BUF0, ResourceTemplate ()
                            {
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x03F8, 0x03F8, 0x00, 0x08)
                                    IRQNoFlags () {4}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x03E8, 0x03E8, 0x00, 0x08)
                                    IRQNoFlags () {4}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x02F8, 0x02F8, 0x00, 0x08)
                                    IRQNoFlags () {3}
                                }
                                StartDependentFnNoPri ()
                                {
                                    IO (Decode16, 0x02E8, 0x02E8, 0x00, 0x08)
                                    IRQNoFlags () {3}
                                }
                                EndDependentFn ()
                            })
                            CreateByteField (BUF0, 0x03, IOLO)
                            CreateByteField (BUF0, 0x04, IOHI)
                            CreateByteField (BUF0, 0x05, IOLM)
                            CreateByteField (BUF0, 0x06, IOHM)
                            CreateWordField (BUF0, 0x0A, IRQV)
                            Store (0x03, LDN)
                            Store (CR61, IOLO)
                            Store (CR60, IOHI)
                            Store (CR61, IOLM)
                            Store (CR60, IOHM)
                            Store (0x01, Local0)
                            ShiftLeft (Local0, CR70, IRQV)
                            Return (BUF0)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, IOLO)
                            CreateByteField (Arg0, 0x03, IOHI)
                            CreateWordField (Arg0, 0x09, IRQV)
                            If (IOLO)
                            {
                                Store (0x03, LDN)
                                Store (0x01, CR30)
                                Store (IOLO, CR61)
                                Store (IOHI, CR60)
                                FindSetRightBit (IRQV, Local0)
                            }
                            Else
                            {
                                _DIS ()
                            }
                        }

                        Name (SV60, 0x00)
                        Name (SV61, 0x00)
                        Name (IRQV, 0x00)
                        Method (SAVE, 0, NotSerialized)
                        {
                            Store (0x03, LDN)
                            Store (CR30, Local0)
                            If (Local0)
                            {
                                Store (CR60, SV60)
                                Store (CR61, SV61)
                                Store (CR70, IRQV)
                            }
                        }

                        Method (REST, 0, NotSerialized)
                        {
                            If (LNot (LEqual (SV60, Zero)))
                            {
                                Store (0x03, LDN)
                                Or (CR30, 0x01, CR30)
                                Store (SV60, CR60)
                                Store (SV61, CR61)
                                Store (IRQV, CR70)
                            }
                        }
                    }
                }
            }

            Name (NATA, Package (0x02)
            {
                0x001F0001, 
                0x001F0002
            })
            Method (GETP, 1, NotSerialized)
            {
                Noop
                If (LEqual (And (Arg0, 0x09), 0x00))
                {
                    Return (0xFFFFFFFF)
                }

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

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

            Method (GETD, 4, NotSerialized)
            {
                Noop
                If (Arg0)
                {
                    If (Arg1)
                    {
                        Return (0x14)
                    }

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

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

                Return (0xFFFFFFFF)
            }

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

            Method (GETF, 3, NotSerialized)
            {
                Noop
                Name (TMPF, 0x00)
                If (Arg0)
                {
                    Or (TMPF, 0x01, TMPF)
                }

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

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

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

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

                Return (TMPF)
            }

            Method (SETP, 3, NotSerialized)
            {
                Noop
                If (LNot (LLess (Arg0, 0xF0)))
                {
                    Return (0x08)
                }
                Else
                {
                    If (And (Arg1, 0x02))
                    {
                        If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                        {
                            Return (0x2301)
                        }

                        If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                        {
                            Return (0x2101)
                        }
                    }

                    Return (0x1001)
                }
            }

            Method (SETD, 1, NotSerialized)
            {
                Noop
                If (LNot (LGreater (Arg0, 0x14)))
                {
                    Return (0x01)
                }

                If (LNot (LGreater (Arg0, 0x1E)))
                {
                    Return (0x02)
                }

                If (LNot (LGreater (Arg0, 0x2D)))
                {
                    Return (0x01)
                }

                If (LNot (LGreater (Arg0, 0x3C)))
                {
                    Return (0x02)
                }

                If (LNot (LGreater (Arg0, 0x5A)))
                {
                    Return (0x01)
                }

                Return (0x00)
            }

            Method (SETT, 3, NotSerialized)
            {
                Noop
                If (And (Arg1, 0x02))
                {
                    If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                    {
                        Return (0x0B)
                    }

                    If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                    {
                        Return (0x09)
                    }
                }

                Return (0x04)
            }

            Device (IDEC)
            {
                Name (_ADR, 0x001F0001)
                OperationRegion (IDEC, PCI_Config, 0x40, 0x18)
                Field (IDEC, DWordAcc, NoLock, Preserve)
                {
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                    Offset (0x08), 
                    SDMA,   4, 
                    Offset (0x0A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                    Offset (0x0B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                    Offset (0x14), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Noop
                        Name (PBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (PBUF, 0x00, PIO0)
                        CreateDWordField (PBUF, 0x04, DMA0)
                        CreateDWordField (PBUF, 0x08, PIO1)
                        CreateDWordField (PBUF, 0x0C, DMA1)
                        CreateDWordField (PBUF, 0x10, FLAG)
                        Store (GETP (PRIT), PIO0)
                        Store (GETD (And (SDMA, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

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

                        Store (GETD (And (SDMA, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SDMA, 0x01), And (SDMA, 0x02), PRIT), FLAG)
                        Return (PBUF)
                    }

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

                            Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SDMA, 0x01, SDMA)
                                Store (SETD (DMA0), SDT0)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                    Or (ICR5, 0x01, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

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

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

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

                            If (And (FLAG, 0x04))
                            {
                                Or (SDMA, 0x02, SDMA)
                                Store (SETD (DMA1), SDT1)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                    Or (ICR5, 0x02, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                        Noop
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Noop
                    }

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

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

                            If (And (SDMA, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                If (And (ICR0, 0x01))
                                {
                                    Add (DMD0, 0x02, DMD0)
                                }

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

                            Return (PIB0)
                        }
                    }

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

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

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

                            Return (PIB1)
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Noop
                        Name (SBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (SBUF, 0x00, PIO0)
                        CreateDWordField (SBUF, 0x04, DMA0)
                        CreateDWordField (SBUF, 0x08, PIO1)
                        CreateDWordField (SBUF, 0x0C, DMA1)
                        CreateDWordField (SBUF, 0x10, FLAG)
                        Store (GETP (SECT), PIO0)
                        Store (GETD (And (SDMA, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

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

                        Store (GETD (And (SDMA, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

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

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

                            Or (SECT, SETP (PIO0, W530, W640), SECT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SDMA, 0x04, SDMA)
                                Store (SETD (DMA0), SDT2)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                    Or (ICR5, 0x04, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x04, ICR3)
                                }

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

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

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

                            If (And (FLAG, 0x04))
                            {
                                Or (SDMA, 0x08, SDMA)
                                Store (SETD (DMA1), SDT3)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                    Or (ICR5, 0x08, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x08, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                        Noop
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Noop
                    }

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

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

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

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

                            Return (SIB0)
                        }
                    }

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

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

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

                            Return (SIB1)
                        }
                    }
                }
            }

            Device (IDE1)
            {
                Name (_ADR, 0x001F0002)
                OperationRegion (IDE1, PCI_Config, 0x90, 0x03)
                Field (IDE1, DWordAcc, NoLock, Preserve)
                {
                    MAP,    8, 
                    Offset (0x02), 
                    PCS,    8
                }

                OperationRegion (IDEC, PCI_Config, 0x40, 0x18)
                Field (IDEC, DWordAcc, NoLock, Preserve)
                {
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                    Offset (0x08), 
                    SDMA,   4, 
                    Offset (0x0A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                    Offset (0x0B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                    Offset (0x14), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4
                }

                Method (CTYP, 1, NotSerialized)
                {
                    Store (Zero, Local0)
                    If (Arg0)
                    {
                        If (LAnd (LGreater (MAP, 0x01), LLess (MAP, 0x06)))
                        {
                            Store (0x01, Local0)
                        }
                        Else
                        {
                            If (LEqual (MAP, Zero))
                            {
                                Store (0x03, Local0)
                            }

                            If (LEqual (MAP, One))
                            {
                                Store (0x04, Local0)
                            }
                        }
                    }
                    Else
                    {
                        If (LGreater (MAP, 0x05))
                        {
                            Store (0x02, Local0)
                        }
                        Else
                        {
                            If (LEqual (MAP, Zero))
                            {
                                Store (0x05, Local0)
                            }

                            If (LEqual (MAP, One))
                            {
                                Store (0x06, Local0)
                            }
                        }
                    }

                    Return (Local0)
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Noop
                        Name (PBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (PBUF, 0x00, PIO0)
                        CreateDWordField (PBUF, 0x04, DMA0)
                        CreateDWordField (PBUF, 0x08, PIO1)
                        CreateDWordField (PBUF, 0x0C, DMA1)
                        CreateDWordField (PBUF, 0x10, FLAG)
                        Store (GETP (PRIT), PIO0)
                        Store (GETD (And (SDMA, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

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

                        Store (GETD (And (SDMA, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SDMA, 0x01), And (SDMA, 0x02), PRIT), FLAG)
                        Return (PBUF)
                    }

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

                            Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SDMA, 0x01, SDMA)
                                Store (SETD (DMA0), SDT0)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                    Or (ICR5, 0x01, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

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

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

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

                            If (And (FLAG, 0x04))
                            {
                                Or (SDMA, 0x02, SDMA)
                                Store (SETD (DMA1), SDT1)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                    Or (ICR5, 0x02, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }

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

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

                            If (And (SDMA, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                If (And (ICR0, 0x01))
                                {
                                    Add (DMD0, 0x02, DMD0)
                                }

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

                            Return (PIB0)
                        }
                    }

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

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

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

                            Return (PIB1)
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Noop
                        Name (SBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (SBUF, 0x00, PIO0)
                        CreateDWordField (SBUF, 0x04, DMA0)
                        CreateDWordField (SBUF, 0x08, PIO1)
                        CreateDWordField (SBUF, 0x0C, DMA1)
                        CreateDWordField (SBUF, 0x10, FLAG)
                        Store (GETP (SECT), PIO0)
                        Store (GETD (And (SDMA, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

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

                        Store (GETD (And (SDMA, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

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

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

                            Or (SECT, SETP (PIO0, W530, W640), SECT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SDMA, 0x04, SDMA)
                                Store (SETD (DMA0), SDT2)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                    Or (ICR5, 0x04, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x04, ICR3)
                                }

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

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

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

                            If (And (FLAG, 0x04))
                            {
                                Or (SDMA, 0x08, SDMA)
                                Store (SETD (DMA1), SDT3)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                    Or (ICR5, 0x08, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x08, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }

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

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

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

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

                            Return (SIB0)
                        }
                    }

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

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

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

                            Return (SIB1)
                        }
                    }
                }
            }

            Device (SMBS)
            {
                Name (_ADR, 0x001F0003)
            }

            Device (AC97)
            {
                Name (_ADR, 0x001F0006)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x01
                })
            }

            Device (PWRB)
            {
                Name (_HID, EisaId ("PNP0C0C"))
            }
        }
    }

    OperationRegion (Z000, SystemIO, 0x1028, 0x04)
    Field (Z000, ByteAcc, NoLock, Preserve)
    {
        PCMS,   32
    }

    OperationRegion (Z001, SystemIO, 0x102F, 0x01)
    Field (Z001, ByteAcc, NoLock, Preserve)
    {
        PCME,   8
    }

    OperationRegion (Z002, SystemIO, 0x102D, 0x01)
    Field (Z002, ByteAcc, NoLock, Preserve)
    {
        PCOM,   8
    }

    OperationRegion (Z003, SystemIO, 0x0600, 0x01)
    Field (Z003, ByteAcc, NoLock, Preserve)
    {
        PM0S,   8
    }

    OperationRegion (Z004, SystemIO, 0x0602, 0x01)
    Field (Z004, ByteAcc, NoLock, Preserve)
    {
        PME0,   8
    }

    OperationRegion (Z005, SystemIO, 0x0604, 0x01)
    Field (Z005, ByteAcc, NoLock, Preserve)
    {
        PMES,   8
    }

    OperationRegion (KBCS, SystemIO, 0x060A, 0x01)
    Field (KBCS, ByteAcc, NoLock, Preserve)
    {
        KB0A,   8
    }

    OperationRegion (Z006, SystemIO, 0x065D, 0x01)
    Field (Z006, ByteAcc, NoLock, Preserve)
    {
        LED1,   8
    }

    Scope (_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x01))
            {
                Store (0xAA, \_SB.PCI0.PT80)
                Store (0x00, PME0)
                And (0xE7, KB0A, KB0A)
                And (0xFE, PCME, PCME)
                Store (PMES, Local0)
                Or (Local0, PMES, PMES)
                Store (PM0S, Local0)
                Or (Local0, PM0S, PM0S)
                Store (PCMS, Local0)
                Or (Local0, PCMS, PCMS)
                And (0xFE, PCME, PCME)
                Notify (\_SB.PCI0.PWRB, 0x02)
            }

            If (LEqual (Arg0, 0x04))
            {
                Store (PCMS, Local0)
                Or (Local0, PCMS, PCMS)
            }
        }
    }

    Scope (_TZ)
    {
    }

    Name (_S0, Package (0x02)
    {
        0x00, 
        0x00
    })
    Name (_S1, Package (0x02)
    {
        0x01, 
        0x01
    })
    Name (_S4, Package (0x02)
    {
        0x06, 
        0x06
    })
    Name (_S5, Package (0x02)
    {
        0x07, 
        0x07
    })
    Name (PICF, 0x00)
    Method (_PIC, 1, NotSerialized)
    {
        Store (Arg0, \PICF)
    }

    Method (_PTS, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x01))
        {
            Store (0xBB, \_SB.PCI0.PT80)
            Store (PMES, Local0)
            Or (Local0, PMES, PMES)
            Store (PM0S, Local0)
            Or (Local0, PM0S, PM0S)
            Store (0x01, PME0)
            Or (0x18, KB0A, KB0A)
            Or (0x01, PCME, PCME)
            \_SB.PCI0.LPC0.SIO.ENFG ()
            Store (0x07, \_SB.PCI0.LPC0.SIO.LDN)
            Store (\_SB.PCI0.LPC0.SIO.CRF0, Local0)
            And (Local0, 0x9F, Local0)
            Store (\_SB.PCI0.LPC0.KBC0.SLEP, Local1)
            Store (\_SB.PCI0.LPC0.MSE0.SLEP, Local2)
            If (LAnd (LEqual (Local1, 0x00), LEqual (Local2, 0x01)))
            {
                Or (Local0, 0x40, Local0)
            }

            If (LAnd (LEqual (Local1, 0x01), LEqual (Local2, 0x00)))
            {
                Or (Local0, 0x20, Local0)
            }

            Store (Local0, \_SB.PCI0.LPC0.SIO.CRF0)
            \_SB.PCI0.LPC0.SIO.EXFG ()
            Store (0x01, LED1)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (PCMS, Local0)
            Or (Local0, PCMS, PCMS)
        }

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

    Method (_WAK, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x01))
        {
            \_SB.PCI0.LPC0.SIO.ENFG ()
            Store (0x07, \_SB.PCI0.LPC0.SIO.LDN)
            And (0x9F, \_SB.PCI0.LPC0.SIO.CRF0, \_SB.PCI0.LPC0.SIO.CRF0)
            \_SB.PCI0.LPC0.SIO.EXFG ()
            Store (0x03, LED1)
            And (0xFE, PCME, PCME)
        }
    }
}