/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20050624
 *
 * Disassembly of dsdt, Thu Jul 21 21:01:31 2005
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "MSI", "1013", 103227397)
{
    OperationRegion (BIOS, SystemMemory, 0x3BF50064, 0xFF)
    Field (BIOS, ByteAcc, NoLock, Preserve)
    {
        SS1,    1, 
        SS2,    1, 
        SS3,    1, 
        SS4,    1, 
        Offset (0x01), 
        IOST,   16, 
        TOPM,   32, 
        ROMS,   32, 
        MG1B,   32, 
        MG1L,   32, 
        MG2B,   32, 
        MG2L,   32, 
        TCRT,   8, 
        THOT,   8, 
        TMAX,   8, 
        TMIN,   8, 
        TC1,    8, 
        TC2,    8, 
        TSP,    8, 
        SBAS,   16, 
        TZEN,   8
    }

    Name (SHPG, 0x00)
    Name (APCB, 0xFEC00000)
    Name (APCL, 0x1000)
    Name (PMBS, 0x4000)
    Name (PMAB, 0x4100)
    Name (PMLN, 0x80)
    Name (GPBS, 0x00)
    Name (GPLN, 0x00)
    Name (SMBL, 0x00)
    Name (PCIB, 0xE0000000)
    Name (PCIL, 0x10000000)
    Name (IO1B, 0x00)
    Name (IO1L, 0x10)
    Name (STHP, 0x00)
    Name (SPIO, 0x00)
    Method (RRIO, 4, NotSerialized)
    {
        Store ("RRIO", Debug)
    }

    Method (RDMA, 3, NotSerialized)
    {
        Store ("rDMA", Debug)
    }

    Name (PICM, 0x00)
    Method (_PIC, 1, NotSerialized)
    {
        If (Arg0)
        {
            Store (0xAA, DBG8)
        }
        Else
        {
            Store (0xAC, DBG8)
        }

        Store (Arg0, PICM)
    }

    Name (OSVR, Ones)
    Method (OSFL, 0, NotSerialized)
    {
        If (LNot (LEqual (OSVR, Ones)))
        {
            Return (OSVR)
        }

        If (LEqual (PICM, 0x00))
        {
            Store (0xAC, DBG8)
        }

        Store (0x01, OSVR)
        If (MCTH (\_OS, "Microsoft Windows NT"))
        {
            Store (0x00, OSVR)
        }
        Else
        {
            If (MCTH (\_OS, "Microsoft WindowsME: Millennium Edition"))
            {
                Store (0x02, OSVR)
            }

            If (MCTH (\_OS, "Linux"))
            {
                Store (0x03, OSVR)
            }
        }

        Return (OSVR)
    }

    Method (MCTH, 2, NotSerialized)
    {
        If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
        {
            Return (Zero)
        }

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

        Return (One)
    }

    Name (PRWP, Package (0x02)
    {
        Zero, 
        Zero
    })
    Method (GPRW, 2, NotSerialized)
    {
        Store (Arg0, Index (PRWP, 0x00))
        Store (ShiftLeft (SS1, 0x01), Local0)
        Or (Local0, ShiftLeft (SS2, 0x02), Local0)
        Or (Local0, ShiftLeft (SS3, 0x03), Local0)
        Or (Local0, ShiftLeft (SS4, 0x04), Local0)
        If (And (ShiftLeft (0x01, Arg1), Local0))
        {
            Store (Arg1, Index (PRWP, 0x01))
        }
        Else
        {
            ShiftRight (Local0, 0x01, Local0)
            If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))
            {
                FindSetLeftBit (Local0, Index (PRWP, 0x01))
            }
            Else
            {
                FindSetRightBit (Local0, Index (PRWP, 0x01))
            }
        }

        Return (PRWP)
    }

    Name (WAKP, Package (0x02)
    {
        Zero, 
        Zero
    })
    OperationRegion (DEB0, SystemIO, 0x80, 0x01)
    Field (DEB0, ByteAcc, NoLock, Preserve)
    {
        DBG8,   8
    }

    OperationRegion (DEB1, SystemIO, 0x90, 0x02)
    Field (DEB1, WordAcc, NoLock, Preserve)
    {
        DBG9,   16
    }

    Scope (\_SB)
    {
        Name (PR00, Package (0x15)
        {
            Package (0x04)
            {
                0x0001FFFF, 
                0x00, 
                LNKB, 
                0x00
            }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            Package (0x04)
            {
                0x0013FFFF, 
                0x00, 
                LNKD, 
                0x00
            }
        })
        Name (AR00, Package (0x15)
        {
            Package (0x04)
            {
                0x0001FFFF, 
                0x00, 
                0x00, 
                0x11
            }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            Package (0x04)
            {
                0x0013FFFF, 
                0x00, 
                0x00, 
                0x13
            }
        })
        Name (PR01, Package (0x04)
        {
            Package (0x04)
            {
                0x0005FFFF, 
                0x00, 
                LNKB, 
                0x00
            }, 

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

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

            Package (0x04)
            {
                0x0005FFFF, 
                0x03, 
                LNKA, 
                0x00
            }
        })
        Name (AR01, Package (0x04)
        {
            Package (0x04)
            {
                0x0005FFFF, 
                0x00, 
                0x00, 
                0x11
            }, 

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

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

            Package (0x04)
            {
                0x0005FFFF, 
                0x03, 
                0x00, 
                0x10
            }
        })
        Name (PR02, Package (0x06)
        {
            Package (0x04)
            {
                0x0004FFFF, 
                0x00, 
                LNKD, 
                0x00
            }, 

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

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

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

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

            Package (0x04)
            {
                0x0009FFFF, 
                0x01, 
                LNKH, 
                0x00
            }
        })
        Name (AR02, Package (0x06)
        {
            Package (0x04)
            {
                0x0004FFFF, 
                0x00, 
                0x00, 
                0x13
            }, 

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

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

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

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

            Package (0x04)
            {
                0x0009FFFF, 
                0x01, 
                0x00, 
                0x17
            }
        })
        Name (PRSA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared) {5,6,7,10,11,12,14,15}
        })
        Alias (PRSA, PRSB)
        Alias (PRSA, PRSC)
        Alias (PRSA, PRSD)
        Alias (PRSA, PRSE)
        Alias (PRSA, PRSF)
        Alias (PRSA, PRSG)
        Alias (PRSA, PRSH)
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00180000)
            Method (^BN00, 0, NotSerialized)
            {
                Return (0x00)
            }

            Method (_BBN, 0, NotSerialized)
            {
                Return (BN00 ())
            }

            Name (_UID, 0x00)
            Method (_PRT, 0, NotSerialized)
            {
                If (PICM)
                {
                    Return (AR00)
                }

                Return (PR00)
            }

            Device (P0P1)
            {
                Name (_ADR, 0x00010000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR01)
                    }

                    Return (PR01)
                }
            }

            Device (P0PA)
            {
                Name (_ADR, 0x00020000)
            }

            Device (P0P4)
            {
                Name (_ADR, 0x00040000)
            }

            Device (P0P5)
            {
                Name (_ADR, 0x00050000)
            }

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

                Device (DMAD)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        DMA (Compatibility, BusMaster, Transfer8) {4}
                        IO (Decode16, 0x0000, 0x0000, 0x00, 0x10)
                        IO (Decode16, 0x0081, 0x0081, 0x00, 0x03)
                        IO (Decode16, 0x0087, 0x0087, 0x00, 0x01)
                        IO (Decode16, 0x0089, 0x0089, 0x00, 0x03)
                        IO (Decode16, 0x008F, 0x008F, 0x00, 0x01)
                        IO (Decode16, 0x00C0, 0x00C0, 0x00, 0x20)
                    })
                }

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

                Device (RTC0)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x00, 0x02)
                        IRQNoFlags () {8}
                    })
                }

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CID, 0x0B03D041)
                    Method (_STA, 0, NotSerialized)
                    {
                        ShiftLeft (0x01, 0x0A, Local0)
                        If (And (IOST, Local0))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

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

                Device (PS2M)
                {
                    Name (_HID, EisaId ("PNP0F03"))
                    Name (_CID, 0x130FD041)
                    Method (_STA, 0, NotSerialized)
                    {
                        ShiftLeft (0x01, 0x0C, Local0)
                        If (And (IOST, Local0))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Name (CRS1, ResourceTemplate ()
                    {
                        IRQNoFlags () {12}
                    })
                    Name (CRS2, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x00, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x00, 0x01)
                        IRQNoFlags () {12}
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        ShiftLeft (0x01, 0x0A, Local0)
                        If (And (IOST, Local0))
                        {
                            Return (CRS1)
                        }
                        Else
                        {
                            Return (CRS2)
                        }
                    }
                }

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

                Device (COPR)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x00, 0x10)
                        IRQNoFlags () {13}
                    })
                }

                Device (RMSC)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x10)
                    Name (CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0010, 0x0010, 0x00, 0x10)
                        IO (Decode16, 0x0022, 0x0022, 0x00, 0x1E)
                        IO (Decode16, 0x0010, 0x0010, 0x00, 0x10)
                        IO (Decode16, 0x0044, 0x0044, 0x00, 0x1C)
                        IO (Decode16, 0x0063, 0x0063, 0x00, 0x01)
                        IO (Decode16, 0x0065, 0x0065, 0x00, 0x01)
                        IO (Decode16, 0x0067, 0x0067, 0x00, 0x09)
                        IO (Decode16, 0x0072, 0x0072, 0x00, 0x0E)
                        IO (Decode16, 0x0080, 0x0080, 0x00, 0x01)
                        IO (Decode16, 0x0084, 0x0084, 0x00, 0x03)
                        IO (Decode16, 0x0088, 0x0088, 0x00, 0x01)
                        IO (Decode16, 0x008C, 0x008C, 0x00, 0x03)
                        IO (Decode16, 0x0090, 0x0090, 0x00, 0x10)
                        IO (Decode16, 0x00A2, 0x00A2, 0x00, 0x1E)
                        IO (Decode16, 0x00E0, 0x00E0, 0x00, 0x10)
                        IO (Decode16, 0x04D0, 0x04D0, 0x00, 0x02)
                        IO (Decode16, 0x040B, 0x040B, 0x00, 0x01)
                        IO (Decode16, 0x04D6, 0x04D6, 0x00, 0x01)
                        IO (Decode16, 0x0C00, 0x0C00, 0x00, 0x02)
                        IO (Decode16, 0x0C14, 0x0C14, 0x00, 0x01)
                        IO (Decode16, 0x0C50, 0x0C50, 0x00, 0x02)
                        IO (Decode16, 0x0C52, 0x0C52, 0x00, 0x01)
                        IO (Decode16, 0x0C6C, 0x0C6C, 0x00, 0x01)
                        IO (Decode16, 0x0C6F, 0x0C6F, 0x00, 0x01)
                        IO (Decode16, 0x0CD6, 0x0CD6, 0x00, 0x02)
                        IO (Decode16, 0x0CD4, 0x0CD4, 0x00, 0x02)
                        IO (Decode16, 0x0CD8, 0x0CD8, 0x00, 0x08)
                        IO (Decode16, 0x0000, 0x0000, 0x00, 0x00)
                        IO (Decode16, 0x0000, 0x0000, 0x00, 0x00)
                        Memory32Fixed (ReadOnly, 0xFFF80000, 0x00080000)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (CRS, 0xDA, GP00)
                        CreateWordField (CRS, 0xDC, GP01)
                        CreateByteField (CRS, 0xDF, GP0L)
                        Store (PMBS, GP00)
                        Store (PMBS, GP01)
                        Store (PMLN, GP0L)
                        If (GPBS)
                        {
                            CreateWordField (CRS, 0xE2, GP20)
                            CreateWordField (CRS, 0xE4, GP21)
                            CreateByteField (CRS, 0xE7, GP2L)
                            Store (GPBS, GP20)
                            Store (GPBS, GP21)
                            Store (GPLN, GP2L)
                        }

                        Return (CRS)
                    }
                }

                Scope (\_SB.PCI0)
                {
                    Device (PCIE)
                    {
                        Name (_HID, EisaId ("PNP0C02"))
                        Name (_UID, 0x11)
                        Name (CRS, ResourceTemplate ()
                        {
                            Memory32Fixed (ReadOnly, 0xE0000000, 0x10000000)
                        })
                        Method (_CRS, 0, NotSerialized)
                        {
                            CreateDWordField (CRS, 0x04, BAS1)
                            CreateDWordField (CRS, 0x08, LEN1)
                            Store (\PCIB, BAS1)
                            Store (\PCIL, LEN1)
                            Return (CRS)
                        }
                    }
                }

                Scope (\_PR)
                {
                    Processor (CPU1, 0x01, 0x00004010, 0x06)
                    {
                        Name (_PCT, Package (0x02)
                        {
                            ResourceTemplate ()
                            {
                                Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
                            }, 

                            ResourceTemplate ()
                            {
                                Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
                            }
                        })
                        Name (_PSS, Package (0x03)
                        {
                            Package (0x06)
                            {
                                0x00000708, 
                                0x000061A8, 
                                0x00000064, 
                                0x00000007, 
                                0xE0202A8A, 
                                0x0000028A
                            }, 

                            Package (0x06)
                            {
                                0x00000640, 
                                0x000055F0, 
                                0x00000064, 
                                0x00000007, 
                                0xE0202B08, 
                                0x00000308
                            }, 

                            Package (0x06)
                            {
                                0x00000320, 
                                0x00001F40, 
                                0x00000064, 
                                0x00000007, 
                                0xE0202CC0, 
                                0x000004C0
                            }, 

                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero, 
                            Zero
                        })
                        Method (_PPC, 0, NotSerialized)
                        {
                            Store (SizeOf (_PSS), Local0)
                            Store (0x00, Local1)
                            If (\_SB.PCI0.SBRG.EC.MYEC)
                            {
                                If (LNot (LEqual (\_SB.PCI0.SBRG.EC.ADP1.ACP, 0x01)))
                                {
                                    If (LEqual (\_SB.PCI0.SBRG.EC.BATS, 0x01))
                                    {
                                        Subtract (Local0, 0x01, Local1)
                                    }
                                }
                            }

                            If (\_SB.PCI0.SBRG.EC.MYEC)
                            {
                                If (\_SB.PCI0.SBRG.EC.HTDM)
                                {
                                    Subtract (Local0, 0x01, Local1)
                                }
                            }

                            Store (Local1, DBG8)
                            Return (Local1)
                        }
                    }
                }

                Device (OMSC)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x00)
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)
                        Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        If (APCB)
                        {
                            CreateDWordField (CRS, 0x08, ML01)
                            CreateDWordField (CRS, 0x04, MB01)
                            CreateDWordField (CRS, 0x14, ML02)
                            CreateDWordField (CRS, 0x10, MB02)
                            Store (APCB, MB01)
                            Store (APCL, ML01)
                            Store (0xFEE00000, MB02)
                            Store (0x1000, ML02)
                        }

                        Return (CRS)
                    }
                }

                Device (\_SB.RMEM)
                {
                    Name (_HID, EisaId ("PNP0C01"))
                    Name (_UID, 0x01)
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000)
                        Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)
                        Memory32Fixed (ReadOnly, 0x000E0000, 0x00020000)
                        Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
                        Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateDWordField (CRS, 0x10, BAS1)
                        CreateDWordField (CRS, 0x14, LEN1)
                        CreateDWordField (CRS, 0x1C, BAS2)
                        CreateDWordField (CRS, 0x20, LEN2)
                        CreateDWordField (CRS, 0x2C, LEN3)
                        CreateDWordField (CRS, 0x34, BAS4)
                        CreateDWordField (CRS, 0x38, LEN4)
                        If (OSFL ()) {}
                        Else
                        {
                            If (MG1B)
                            {
                                If (LGreater (MG1B, 0x000C0000))
                                {
                                    Store (0x000C0000, BAS1)
                                    Subtract (MG1B, BAS1, LEN1)
                                }
                            }
                            Else
                            {
                                Store (0x000C0000, BAS1)
                                Store (0x00020000, LEN1)
                            }

                            If (Add (MG1B, MG1L, Local0))
                            {
                                Store (Local0, BAS2)
                                Subtract (0x00100000, BAS2, LEN2)
                            }
                        }

                        Subtract (MG2B, 0x00100000, LEN3)
                        Add (MG2B, MG2L, BAS4)
                        Subtract (0x00, BAS4, LEN4)
                        Return (CRS)
                    }
                }

                Device (EC)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_GPE, 0x06)
                    Name (CTID, 0x00)
                    Name (MYEC, 0x00)
                    Name (CTSD, 0x00)
                    Name (HTDM, 0x00)
                    Name (BATS, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, MYEC)
                        }

                        Store (0x00, HTDM)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0062, 0x0062, 0x00, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x00, 0x01)
                    })
                    OperationRegion (EC, EmbeddedControl, 0x00, 0xFF)
                    Field (EC, ByteAcc, NoLock, Preserve)
                    {
                        SMPR,   8, 
                        SMST,   8, 
                        SMAD,   8, 
                        SMCM,   8, 
                        SMD0,   264, 
                        SMAA,   8, 
                        Offset (0x30), 
                        POWS,   1, 
                        LIDS,   1, 
                        KBCS,   1, 
                        Offset (0x31), 
                        MBTS,   1, 
                        MBCS,   1, 
                        MBDS,   1, 
                        MBFS,   1, 
                        MBWS,   1, 
                        MBLS,   1, 
                        MBCL,   1, 
                        MBFL,   1, 
                        Offset (0x38), 
                        MDCL,   8, 
                        MDCH,   8, 
                        MDVL,   8, 
                        MDVH,   8, 
                        MCAL,   8, 
                        MCAH,   8, 
                        MSTL,   8, 
                        MSTH,   8, 
                        MCCL,   8, 
                        MCCH,   8, 
                        MPOL,   8, 
                        MPOH,   8, 
                        MFCL,   8, 
                        MFCH,   8, 
                        MCUL,   8, 
                        MCUH,   8, 
                        MRCL,   8, 
                        MRCH,   8, 
                        MVOL,   8, 
                        MVOH,   8, 
                        Offset (0x68), 
                        CPUT,   8, 
                        Offset (0x7E), 
                            ,   3, 
                        THFG,   1, 
                        Offset (0x7F), 
                        Offset (0x80), 
                        SYST,   8
                    }

                    OperationRegion (PMIO, SystemIO, 0x4010, 0x10)
                    Field (PMIO, ByteAcc, NoLock, Preserve)
                    {
                        PCNT,   8
                    }

                    OperationRegion (APMP, SystemIO, 0xB0, 0x02)
                    Field (APMP, ByteAcc, NoLock, Preserve)
                    {
                        APMC,   8, 
                        APMS,   8
                    }

                    Device (ADP1)
                    {
                        Name (_HID, "ACPI0003")
                        Name (BFLG, 0x01)
                        Name (ACP, 0x01)
                        Name (INIT, 0x01)
                        Method (_PSR, 0, NotSerialized)
                        {
                            If (\_SB.PCI0.SBRG.EC.ADP1.ACP)
                            {
                                Return (One)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Method (_STA, 0, NotSerialized)
                        {
                            If (\_SB.PCI0.SBRG.EC.MYEC)
                            {
                                If (\_SB.PCI0.SBRG.EC.ADP1.INIT)
                                {
                                    Store (MBTS, Local0)
                                    If (LEqual (Local0, 0x01))
                                    {
                                        Store (0x01, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                                    }
                                    Else
                                    {
                                        Store (0x00, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                                    }

                                    Store (POWS, Local0)
                                    If (LEqual (Local0, 0x01))
                                    {
                                        Store (0x01, \_SB.PCI0.SBRG.EC.ADP1.ACP)
                                    }
                                    Else
                                    {
                                        Store (0x00, \_SB.PCI0.SBRG.EC.ADP1.ACP)
                                    }
                                }

                                Store (0x00, \_SB.PCI0.SBRG.EC.ADP1.INIT)
                            }

                            Return (0x0F)
                        }

                        Name (_PCL, Package (0x01)
                        {
                            \_SB
                        })
                    }

                    Name (BIF0, Package (0x0D)
                    {
                        0x01, 
                        0x0898, 
                        0x0898, 
                        0x01, 
                        0x39D0, 
                        0x00, 
                        0x00, 
                        0x01, 
                        0x01, 
                        "MS-1013", 
                        "1", 
                        "LION", 
                        "MSI Corp."
                    })
                    Name (STAT, Package (0x04)
                    {
                        0x02, 
                        0x0500, 
                        0x0800, 
                        0x03E8
                    })
                    Device (BAT1)
                    {
                        Name (_HID, EisaId ("PNP0C0A"))
                        Name (_UID, 0x01)
                        Name (_PCL, Package (0x01)
                        {
                            \_SB
                        })
                        Method (_STA, 0, NotSerialized)
                        {
                            If (\_SB.PCI0.SBRG.EC.ADP1.BFLG)
                            {
                                If (\_SB.PCI0.SBRG.EC.MYEC)
                                {
                                    Store (MDCH, Local0)
                                    If (LEqual (Local0, 0x08))
                                    {
                                        Store (0x01, BATS)
                                    }
                                    Else
                                    {
                                        Store (0x00, BATS)
                                    }

                                    Notify (\_PR.CPU1, 0x80)
                                }

                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x0F)
                            }
                        }

                        Method (_BIF, 0, NotSerialized)
                        {
                            If (\_SB.PCI0.SBRG.EC.MYEC)
                            {
                                UPBI ()
                            }
                            Else
                            {
                                IVBI ()
                            }

                            Return (BIF0)
                        }

                        Method (_BST, 0, NotSerialized)
                        {
                            If (\_SB.PCI0.SBRG.EC.MYEC)
                            {
                                UPBS ()
                            }
                            Else
                            {
                                IVBS ()
                            }

                            Return (STAT)
                        }

                        Method (IVBI, 0, NotSerialized)
                        {
                            Store (0xFFFFFFFF, Index (BIF0, 0x01))
                            Store (0xFFFFFFFF, Index (BIF0, 0x02))
                            Store (0xFFFFFFFF, Index (BIF0, 0x04))
                            Store ("Wrong", Index (BIF0, 0x09))
                            Store (" ", Index (BIF0, 0x0A))
                            Store ("Wrong", Index (BIF0, 0x0B))
                            Store ("Wrong", Index (BIF0, 0x0C))
                        }

                        Method (IVBS, 0, NotSerialized)
                        {
                            Store (0x00, Index (STAT, 0x00))
                            Store (0xFFFFFFFF, Index (STAT, 0x01))
                            Store (0xFFFFFFFF, Index (STAT, 0x02))
                            Store (0x2710, Index (STAT, 0x03))
                        }

                        Method (UPBI, 0, NotSerialized)
                        {
                            Store (0x00, Local0)
                            Store (0x00, Local1)
                            Store (0x00, Local2)
                            Store (0x00, Local3)
                            Store (MDCH, Local0)
                            Store (MDCL, Local1)
                            ShiftLeft (Local0, 0x08, Local0)
                            Or (Local0, Local1, Local0)
                            Store (Local0, Index (BIF0, 0x01))
                            Store (MFCH, Local0)
                            Store (MFCL, Local1)
                            ShiftLeft (Local0, 0x08, Local0)
                            Or (Local0, Local1, Local1)
                            Store (Local1, Index (BIF0, 0x02))
                            Store (MDVH, Local0)
                            Store (MDVL, Local2)
                            ShiftLeft (Local0, 0x08, Local0)
                            Or (Local0, Local2, Local2)
                            Store (Local2, Index (BIF0, 0x04))
                            Store ("\n", Index (BIF0, 0x0A))
                            Store ("LION\n", Index (BIF0, 0x0B))
                            Store (CTID, Local0)
                            If (LEqual (Local0, 0x00))
                            {
                                Store ("MS-1013\n", Index (BIF0, 0x09))
                                Store ("\n", Index (BIF0, 0x0C))
                            }
                            Else
                            {
                                Store ("?MODEL\n", Index (BIF0, 0x09))
                                Store ("?CUSTOMER\n", Index (BIF0, 0x0C))
                            }
                        }

                        Method (UPBS, 0, NotSerialized)
                        {
                            Store (0x00, Local0)
                            Store (0x00, Local1)
                            Store (0x00, Local2)
                            Store (0x00, Local3)
                            Store (0x00, Local4)
                            Store (0x00, Local7)
                            Store (MBTS, Local0)
                            If (LEqual (Local0, 0x01))
                            {
                                Store (POWS, Local0)
                                If (LEqual (Local0, 0x01))
                                {
                                    Store (MBCS, Local1)
                                    If (LEqual (Local1, 0x01))
                                    {
                                        Or (Local4, 0x02, Local4)
                                    }
                                }
                                Else
                                {
                                    Or (Local4, 0x01, Local4)
                                    Store (MBCL, Local0)
                                    If (LEqual (Local0, 0x01))
                                    {
                                        Or (Local4, 0x04, Local4)
                                    }
                                }

                                Store (POWS, Local0)
                                If (LEqual (Local0, 0x01))
                                {
                                    Store (MBCS, Local0)
                                    If (LEqual (Local0, 0x01))
                                    {
                                        Store (MCUH, Local0)
                                        Store (MCUL, Local1)
                                        ShiftLeft (Local0, 0x08, Local0)
                                        Or (Local0, Local1, Local1)
                                        If (LEqual (Local1, 0xFFFF))
                                        {
                                            Store (0xFFFFFFFF, Local1)
                                        }

                                        Store (Local1, Index (STAT, 0x01))
                                    }
                                    Else
                                    {
                                        Store (0x00, Index (STAT, 0x01))
                                    }
                                }
                                Else
                                {
                                    Store (MCUH, Local0)
                                    Store (MCUL, Local1)
                                    ShiftLeft (Local0, 0x08, Local0)
                                    Or (Local0, Local1, Local1)
                                    XOr (Local1, 0xFFFF, Local1)
                                    If (LEqual (Local1, 0x00))
                                    {
                                        Store (0xFFFFFFFF, Local1)
                                    }

                                    Store (Local1, Index (STAT, 0x01))
                                }

                                Store (MRCH, Local0)
                                Store (MRCL, Local2)
                                ShiftLeft (Local0, 0x08, Local0)
                                Or (Local0, Local2, Local2)
                                Store (Local2, Index (STAT, 0x02))
                                Store (MVOH, Local0)
                                Store (MVOL, Local3)
                                ShiftLeft (Local0, 0x08, Local0)
                                Or (Local0, Local3, Local3)
                                Store (Local3, Index (STAT, 0x03))
                                Store (Local4, Index (STAT, 0x00))
                            }
                            Else
                            {
                                IVBS ()
                            }
                        }
                    }

                    Device (LID0)
                    {
                        Name (_HID, EisaId ("PNP0C0D"))
                        Method (_LID, 0, NotSerialized)
                        {
                            If (LIDS)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Device (SLPB)
                    {
                        Name (_HID, EisaId ("PNP0C0E"))
                        Name (_STA, 0x0B)
                    }

                    Method (_Q80, 0, NotSerialized)
                    {
                        Store (0x80, DBG8)
                    }

                    Method (_Q81, 0, NotSerialized)
                    {
                        Store (0x81, DBG8)
                        Store (0x01, \_SB.PCI0.SBRG.EC.HTDM)
                        Store (0x01, THFG)
                        Notify (\_PR.CPU1, 0x80)
                    }

                    Method (_Q82, 0, NotSerialized)
                    {
                        Store (0x82, DBG8)
                        Store (0x00, \_SB.PCI0.SBRG.EC.HTDM)
                        Store (0x01, THFG)
                        Notify (\_PR.CPU1, 0x80)
                    }

                    Method (_Q83, 0, NotSerialized)
                    {
                        Store (0x83, DBG8)
                        Store (POWS, Local0)
                        If (LEqual (Local0, 0x01))
                        {
                            Store (0x01, \_SB.PCI0.SBRG.EC.ADP1.ACP)
                        }
                        Else
                        {
                            Store (0x00, \_SB.PCI0.SBRG.EC.ADP1.ACP)
                        }

                        Notify (\_SB.PCI0.SBRG.EC.ADP1, 0x00)
                        Notify (\_PR.CPU1, 0x80)
                    }

                    Method (_Q84, 0, NotSerialized)
                    {
                        Store (0x84, DBG8)
                        Notify (LID0, 0x80)
                    }

                    Method (_Q85, 0, NotSerialized)
                    {
                        Store (0x85, DBG8)
                        Store (0x01, \_SB.PCI0.SBRG.EC.CTSD)
                        Notify (\_TZ.THRM, 0x80)
                    }

                    Method (_Q86, 0, NotSerialized)
                    {
                        Store (0x86, DBG8)
                    }

                    Method (_Q87, 0, NotSerialized)
                    {
                        Store (0x87, DBG8)
                        If (\_SB.PCI0.SBRG.EC.MYEC)
                        {
                            Store (MDCH, Local0)
                            If (LEqual (Local0, 0x08))
                            {
                                Store (0x01, BATS)
                            }
                            Else
                            {
                                Store (0x00, BATS)
                            }

                            Notify (\_PR.CPU1, 0x80)
                        }

                        Store (MBTS, Local0)
                        If (LEqual (Local0, 0x01))
                        {
                            Store (0x01, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                            Notify (\_SB.PCI0.SBRG.EC.BAT1, 0x00)
                        }
                        Else
                        {
                            Store (0x00, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                            Notify (\_SB.PCI0.SBRG.EC.ADP1, 0x00)
                            Notify (\_SB.PCI0.SBRG.EC.BAT1, 0x01)
                        }

                        Notify (\_SB.PCI0.SBRG.EC.ADP1, 0x00)
                    }

                    Method (_Q88, 0, NotSerialized)
                    {
                        Store (0x88, DBG8)
                    }

                    Method (_Q89, 0, NotSerialized)
                    {
                        Store (0x89, DBG8)
                    }

                    Method (_Q8A, 0, NotSerialized)
                    {
                        Store (0x8A, DBG8)
                        Store (0x01, \_SB.PCI0.SBRG.EC.CTSD)
                        Notify (\_TZ.THRM, 0x80)
                    }

                    Method (_Q8B, 0, NotSerialized)
                    {
                        Store (0x8B, DBG8)
                    }

                    Method (_Q8C, 0, NotSerialized)
                    {
                        Store (0x8C, DBG8)
                    }

                    Method (_Q90, 0, NotSerialized)
                    {
                        Store (0x90, DBG8)
                    }

                    Method (_QB4, 0, NotSerialized)
                    {
                        Store (0xB4, DBG8)
                        Store (0xA1, APMC)
                    }

                    Method (_QB5, 0, NotSerialized)
                    {
                        Store (0xB5, DBG8)
                    }

                    Method (_QB6, 0, NotSerialized)
                    {
                        Store (0xB6, DBG8)
                    }

                    Method (_QB7, 0, NotSerialized)
                    {
                        Store (0xB7, DBG8)
                    }

                    Method (_QB8, 0, NotSerialized)
                    {
                        Store (0xB8, DBG8)
                    }

                    Method (_QB9, 0, NotSerialized)
                    {
                        Store (0xB9, DBG8)
                    }
                }

                Scope (\_TZ)
                {
                    ThermalZone (THRM)
                    {
                        Method (KLV, 1, NotSerialized)
                        {
                            Add (Arg0, 0x0111, Local0)
                            Multiply (Local0, 0x0A, Local0)
                            Return (Local0)
                        }

                        Method (_TMP, 0, NotSerialized)
                        {
                            If (\_SB.PCI0.SBRG.EC.MYEC)
                            {
                                Store (\_SB.PCI0.SBRG.EC.CPUT, Local0)
                                Add (Local0, 0x03, Local0)
                                If (\_SB.PCI0.SBRG.EC.CTSD)
                                {
                                    Store (0x00, \_SB.PCI0.SBRG.EC.CTSD)
                                    Return (KLV (0x65))
                                }
                                Else
                                {
                                    Return (KLV (Local0))
                                }
                            }
                            Else
                            {
                                Return (KLV (0x1E))
                            }
                        }

                        Method (_CRT, 0, NotSerialized)
                        {
                            Return (KLV (0x7F))
                        }
                    }
                }
            }

            Device (SMBS)
            {
                Name (_ADR, 0x00140000)
                OperationRegion (SMI0, SystemIO, SBAS, 0x0F)
                Field (SMI0, ByteAcc, NoLock, Preserve)
                {
                    RG00,   8, 
                    RG01,   8, 
                    RG02,   8, 
                    RG03,   8, 
                    RG04,   8, 
                    RG05,   8, 
                    RG06,   8
                }

                OperationRegion (PMIO, SystemIO, 0x0CD6, 0x02)
                Field (PMIO, ByteAcc, NoLock, Preserve)
                {
                    INPM,   8, 
                    DAPM,   8
                }

                IndexField (INPM, DAPM, ByteAcc, NoLock, Preserve)
                {
                        ,   1, 
                    TM1E,   1, 
                    TM2E,   1, 
                    Offset (0x01), 
                        ,   1, 
                    TM1S,   1, 
                    TM2S,   1, 
                    Offset (0x04), 
                        ,   7, 
                    SLPS,   1, 
                    Offset (0x1C), 
                        ,   3, 
                    MKME,   1, 
                    PI3E,   1, 
                    PI2E,   1, 
                    PI1E,   1, 
                    PI0E,   1, 
                        ,   3, 
                    MKMS,   1, 
                    PI3S,   1, 
                    PI2S,   1, 
                    PI1S,   1, 
                    PI0S,   1, 
                    Offset (0x55), 
                    SPRE,   1, 
                    Offset (0x68), 
                        ,   3, 
                    TPDE,   1, 
                        ,   1
                }

                Method (TRMD, 0, NotSerialized)
                {
                    Store (Zero, SPRE)
                    Store (Zero, TPDE)
                }

                Method (HTCD, 0, NotSerialized)
                {
                    Store (Zero, PI2E)
                    Store (Zero, TM2E)
                    Store (PI2S, PI2S)
                    Store (TM2S, TM2S)
                }

                Method (WBYT, 3, NotSerialized)
                {
                    Store (Arg1, RG03)
                    Store (Arg0, RG04)
                    While (RG00)
                    {
                        Store (RG00, RG00)
                    }

                    Store (Arg2, RG05)
                    Store (0x48, RG02)
                    Sleep (0x0A)
                    If (And (RG00, 0x04))
                    {
                        Return (0x00)
                    }

                    While (And (RG00, 0x01))
                    {
                        Sleep (0x01)
                    }

                    Return (0x01)
                }

                Method (RBYT, 2, NotSerialized)
                {
                    Store (Arg1, RG03)
                    Store (Or (Arg0, 0x01), RG04)
                    While (RG00)
                    {
                        Store (RG00, RG00)
                    }

                    Store (0x48, RG02)
                    Sleep (0x0A)
                    If (And (RG00, 0x04))
                    {
                        Return (0x00)
                    }

                    While (And (RG00, 0x01))
                    {
                        Sleep (0x01)
                    }

                    Return (RG05)
                }
            }

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

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

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

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

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

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

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

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

                    Return (BUF)
                }

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

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

                    Return (BUF)
                }

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

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

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

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

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

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

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

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

            Device (POP2)
            {
                Name (_ADR, 0x00140004)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x04, 0x04))
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (PICM)
                    {
                        Return (AR02)
                    }

                    Return (PR02)
                }

                Device (CBC0)
                {
                    Name (_ADR, 0x00040000)
                }

                Device (CBC1)
                {
                    Name (_ADR, 0x00040001)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                    }

                    Method (_S3D, 0, NotSerialized)
                    {
                        Return (0x03)
                    }

                    Method (CEV1, 0, NotSerialized)
                    {
                    }
                }

                Device (ILNK)
                {
                    Name (_ADR, 0x00040002)
                }

                Device (RTL)
                {
                    Name (_ADR, 0x00030000)
                    Method (_PRW, 0, NotSerialized)
                    {
                        Return (GPRW (0x04, 0x04))
                    }
                }
            }

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

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

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

            Device (AC97)
            {
                Name (_ADR, 0x00140005)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0C, 0x03))
                }
            }

            Device (MC97)
            {
                Name (_ADR, 0x00140006)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x0C, 0x04))
                }
            }
        }

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

            Method (_L0C, 0, NotSerialized)
            {
                Notify (\_SB.PCI0.AC97, 0x02)
                Notify (\_SB.PCI0.MC97, 0x02)
                Notify (\_SB.PWRB, 0x02)
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Name (_UID, 0xAA)
            Name (_STA, 0x0B)
        }
    }

    Scope (\_SB)
    {
        OperationRegion (PIRQ, SystemIO, 0x0C00, 0x02)
        Field (PIRQ, ByteAcc, NoLock, Preserve)
        {
            PIDX,   8, 
            PDAT,   8
        }

        IndexField (PIDX, PDAT, ByteAcc, NoLock, Preserve)
        {
            PIRA,   8, 
            PIRB,   8, 
            PIRC,   8, 
            PIRD,   8, 
            PIRS,   8, 
            Offset (0x09), 
            PIRE,   8, 
            PIRF,   8, 
            PIRG,   8, 
            PIRH,   8
        }

        Method (IRQC, 0, NotSerialized)
        {
            Store (0x00, PIRA)
            Store (0x00, PIRB)
            Store (0x00, PIRC)
            Store (0x00, PIRD)
            Store (0x00, PIRS)
            Store (0x00, PIRE)
            Store (0x00, PIRF)
            Store (0x00, PIRG)
            Store (0x00, PIRH)
        }

        Name (BUFA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared) {15}
        })
        Name (IPRA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared) {5,10,11}
        })
        Name (IPRB, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared) {5,10,11}
        })
        Name (IPRC, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared) {5,10,11}
        })
        Name (IPRD, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared) {5,10,11}
        })
        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x01)
            Method (_STA, 0, NotSerialized)
            {
                If (PIRA)
                {
                    Return (0x0B)
                }
                Else
                {
                    Return (0x09)
                }
            }

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRA, IRQX)
                Return (BUFA)
            }

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

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

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRB, IRQX)
                Return (BUFA)
            }

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

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

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRC, IRQX)
                Return (BUFA)
            }

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

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

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRD, IRQX)
                Return (BUFA)
            }

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

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

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRE, IRQX)
                Return (BUFA)
            }

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

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

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRF, IRQX)
                Return (BUFA)
            }

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

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

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRG, IRQX)
                Return (BUFA)
            }

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

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

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

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

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (BUFA, 0x01, IRQX)
                ShiftLeft (0x01, PIRH, IRQX)
                Return (BUFA)
            }

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

    Scope (\_SB)
    {
        Scope (PCI0)
        {
            Name (CRS, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000, // Address Space Granularity
                    0x0000, // Address Range Minimum
                    0x00FF, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0x0100,,,)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, // Address Space Granularity
                    0x0000, // Address Range Minimum
                    0x0CF7, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0x0CF8,,,
                    , TypeStatic)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, // Address Space Granularity
                    0x0D00, // Address Range Minimum
                    0xFFFF, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0xF300,,,
                    , TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, // Address Space Granularity
                    0x000A0000, // Address Range Minimum
                    0x000BFFFF, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0x00020000,,,
                    , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, // Address Space Granularity
                    0x00000000, // Address Range Minimum
                    0x00000000, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0x00000000,,,
                    , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, // Address Space Granularity
                    0x00000000, // Address Range Minimum
                    0x00000000, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0x00000000,,,
                    , AddressRangeMemory, TypeStatic)
            })
            CreateDWordField (CRS, 0x5C, MIN5)
            CreateDWordField (CRS, 0x60, MAX5)
            CreateDWordField (CRS, 0x68, LEN5)
            CreateDWordField (CRS, 0x76, MIN6)
            CreateDWordField (CRS, 0x7A, MAX6)
            CreateDWordField (CRS, 0x82, LEN6)
            Method (_CRS, 0, NotSerialized)
            {
                Store (MG1B, MIN5)
                Store (MG1L, LEN5)
                Store (MG1L, Local0)
                If (Local0)
                {
                    Add (MIN5, Decrement (Local0), MAX5)
                }

                Store (MG2B, MIN6)
                Store (MG2L, LEN6)
                Store (MG2L, Local0)
                Add (MIN6, Decrement (Local0), MAX6)
                Return (CRS)
            }
        }
    }

    Method (_PTS, 1, NotSerialized)
    {
        Store (Arg0, DBG8)
        If (LGreater (Arg0, 0x00))
        {
            \_SB.PCI0.SMBS.TRMD ()
            Store (One, \_SB.PCI0.SMBS.SLPS)
        }

        PTS (Arg0)
        Store (0x00, Index (WAKP, 0x00))
        Store (0x00, Index (WAKP, 0x01))
    }

    Method (_WAK, 1, NotSerialized)
    {
        If (\_SB.PCI0.SBRG.EC.MYEC)
        {
            Store (0x87, DBG8)
            Store (0x00, Local0)
            Store (\_SB.PCI0.SBRG.EC.MBTS, Local0)
            If (LEqual (Local0, 0x01))
            {
                Store (0x01, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                Notify (\_SB.PCI0.SBRG.EC.BAT1, 0x00)
            }
            Else
            {
                Store (0x00, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                Notify (\_SB.PCI0.SBRG.EC.ADP1, 0x00)
                Sleep (0x19)
                Notify (\_SB.PCI0.SBRG.EC.BAT1, 0x01)
            }

            Notify (\_SB.PCI0.SBRG.EC.ADP1, 0x00)
            Store (0x00, Local0)
            Store (\_SB.PCI0.SBRG.EC.POWS, Local0)
            If (LEqual (Local0, 0x01))
            {
                Store (0x01, \_SB.PCI0.SBRG.EC.ADP1.ACP)
            }
            Else
            {
                Store (0x00, \_SB.PCI0.SBRG.EC.ADP1.ACP)
            }

            Notify (\_SB.PCI0.SBRG.EC.ADP1, 0x00)
        }

        If (PICM) {}
        ShiftLeft (Arg0, 0x04, DBG8)
        WAK (Arg0)
        If (DerefOf (Index (WAKP, 0x00)))
        {
            Store (0x00, Index (WAKP, 0x01))
        }
        Else
        {
            Store (Arg0, Index (WAKP, 0x01))
        }

        Return (WAKP)
    }

    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    If (SS1)
    {
        Name (\_S1, Package (0x04)
        {
            0x01, 
            0x00, 
            0x00, 
            0x00
        })
    }

    If (SS3)
    {
        Name (\_S3, Package (0x04)
        {
            0x03, 
            0x00, 
            0x00, 
            0x00
        })
    }

    If (SS4)
    {
        Name (\_S4, Package (0x04)
        {
            0x04, 
            0x00, 
            0x00, 
            0x00
        })
    }

    Name (\_S5, Package (0x04)
    {
        0x05, 
        0x00, 
        0x00, 
        0x00
    })
    Method (PTS, 1, NotSerialized)
    {
        If (Arg0) {}
    }

    Method (WAK, 1, NotSerialized)
    {
    }
}