dswload-0660: *** Warning: Type override - [DEB_] had invalid type (Integer) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [MLIB] had invalid type (Integer) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [DATA] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [SIO_] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [LEDP] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [GPEN] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [GPST] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [WUES] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [WUSE] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [SBID] had invalid type (String) for Scope operator, changed to (Scope)
 dswload-0660: *** Warning: Type override - [SWCE] had invalid type (String) for Scope operator, changed to (Scope)
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20030619
 *
 * Disassembly of /tmp/acpidump.nSpaUM, Thu Jan 15 10:57:25 2004
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "INTEL", "SWV25", 256)
{
    Name (PMBS, 0x00)
    Name (PMLN, 0x00)
    Name (SMBS, 0x00)
    Name (APCB, 0x00)
    Name (APCL, 0x00)
    Name (IOB1, 0x00)
    Name (IOL1, 0x00)
    Name (IOB2, 0x00)
    Name (IOL2, 0x00)
    Name (FANM, 0x00)
    Scope (\_PR)
    {
        Processor (CPU1, 0x01, 0x00000410, 0x06) {}
        Processor (CPU2, 0x02, 0x00000410, 0x06) {}
        Processor (CPU3, 0x06, 0x00000410, 0x06) {}
        Processor (CPU4, 0x07, 0x00000410, 0x06) {}
    }

    Name (DEB, 0x00)
    Scope (DEB)
    {
        OperationRegion (IODB, SystemIO, 0x80, 0x01)
        Field (IODB, ByteAcc, NoLock, Preserve)
        {
            IO80,   8
        }

        Method (CHPT, 1, NotSerialized)
        {
            Store (Arg0, IO80)
        }

        Method (MESS, 1, NotSerialized)
        {
            Noop
        }

        Method (BP, 1, NotSerialized)
        {
            Noop
        }

        Method (BP80, 3, NotSerialized)
        {
            Noop
        }
    }

    Name (MLIB, 0x01)
    Scope (MLIB)
    {
        Method (CNV3, 1, NotSerialized)
        {
            FindSetRightBit (Arg0, Local0)
            If (Local0)
            {
                Decrement (Local0)
            }

            Return (Local0)
        }

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

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

            Return (One)
        }
    }

    Name (OSFL, 0x00)
    Name (PCFL, 0x00)
    Name (APIC, 0x00)
    Method (_PIC, 1, NotSerialized)
    {
        Store (Arg0, APIC)
    }

    Method (PCIA, 0, NotSerialized)
    {
        If (OSFL)
        {
            Return (Ones)
        }
        Else
        {
            Return (PCFL)
        }
    }

    Method (DTOS, 0, NotSerialized)
    {
        If (\MLIB.MCTH (\_OS, "Microsoft Windows NT"))
        {
            Store (0x00, OSFL)
        }
        Else
        {
            Store (0x01, OSFL)
        }
    }

    Name (DATA, "DATA")
    Scope (DATA)
    {
        Name (SIO, "N417")
        Scope (SIO)
        {
            Name (INDX, 0x2E)
            Name (DATA, 0x2F)
        }

        Name (LEDP, "Front Panel LED")
        Scope (LEDP)
        {
            OperationRegion (LED1, SystemIO, 0x052B, 0x01)
            Field (LED1, ByteAcc, NoLock, Preserve)
            {
                LEDC,   8
            }
        }

        Name (GPEN, "GPEN for PME/SIO")
        Scope (GPEN)
        {
            OperationRegion (GPE1, SystemIO, 0x042F, 0x01)
            Field (GPE1, ByteAcc, NoLock, Preserve)
            {
                GPEX,   8
            }
        }

        Name (GPST, "GPSTS for PME/SIO")
        Scope (GPST)
        {
            OperationRegion (GPS1, SystemIO, 0x042D, 0x01)
            Field (GPS1, ByteAcc, NoLock, Preserve)
            {
                GPSX,   8
            }
        }

        Name (WUES, "Wake-up ESR")
        Scope (WUES)
        {
            OperationRegion (WEVS, SystemIO, 0x0520, 0x01)
            Field (WEVS, ByteAcc, NoLock, Preserve)
            {
                WKES,   8
            }
        }

        Name (WUSE, "Wake-up ESER")
        Scope (WUSE)
        {
            OperationRegion (WUVS, SystemIO, 0x0521, 0x01)
            Field (WUVS, ByteAcc, NoLock, Preserve)
            {
                WKUS,   8
            }
        }

        Name (SBID, "System Board ID")
        Scope (SBID)
        {
            OperationRegion (BID1, SystemIO, 0x052E, 0x01)
            Field (BID1, ByteAcc, NoLock, Preserve)
            {
                BBID,   8
            }
        }

        Name (SWCE, "EC stuff")
        Scope (SWCE)
        {
            OperationRegion (SWCP, SystemIO, 0x0540, 0x20)
            Field (SWCP, ByteAcc, NoLock, Preserve)
            {
                WESL,   8, 
                WSTE,   8
            }
        }
    }

    Method (ARM0, 1, NotSerialized)
    {
        DARM ()
        Store (0x06, \_SB.PCI0.SBRG.LDN)
        Store (0x11, \_SB.PCI0.SBRG.INTR)
        Store (0x05, \_SB.PCI0.SBRG.LDN)
        Store (0x1C, \_SB.PCI0.SBRG.INTR)
        Store (\DATA.GPEN.GPEX, Local0)
        Or (Local0, 0x20, Local0)
        Store (Local0, \DATA.GPEN.GPEX)
    }

    Method (DARM, 0, NotSerialized)
    {
        Store (0x06, \_SB.PCI0.SBRG.LDN)
        Store (0x01, \_SB.PCI0.SBRG.INTR)
        Store (0x05, \_SB.PCI0.SBRG.LDN)
        Store (0x0C, \_SB.PCI0.SBRG.INTR)
        Store (\DATA.GPEN.GPEX, Local0)
        And (Local0, 0xDF, Local0)
        Store (Local0, \DATA.GPEN.GPEX)
        Store (\DATA.GPST.GPSX, Local0)
        Or (Local0, 0x20, Local0)
        Store (Local0, \DATA.GPST.GPSX)
    }

    Method (_PTS, 1, Serialized)
    {
        Store (Arg0, \DEB.IO80)
        \_SB.PCI0.SBRG.EC0.SSLT (Arg0)
        \_SB.PCI0.CHPS (Arg0)
        ARM0 (Arg0)
        If (LEqual (Arg0, 0x01))
        {
            Store (0x30, \DATA.LEDP.LEDC)
        }
    }

    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S1, Package (0x04)
    {
        0x01, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S4, Package (0x04)
    {
        0x06, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S5, Package (0x04)
    {
        0x07, 
        0x00, 
        0x00, 
        0x00
    })
    Method (_WAK, 1, Serialized)
    {
        ShiftLeft (Arg0, 0x04, \DEB.IO80)
        \_SB.PCI0.SBRG.EC0.SSLT (0x00)
        Store (0x70, \DATA.LEDP.LEDC)
        \_SB.PCI0.CHPW (Arg0)
        DARM ()
        Notify (\_SB.PCI0.SBRG.PS2K, 0x00)
        Notify (\_SB.PCI0.SBRG.PS2M, 0x00)
        Store (\_SB.PCI0.SBRG.UAR1._STA (), Local3)
        And (Local3, 0x03, Local3)
        If (LEqual (Local3, 0x01))
        {
            Notify (\_SB.PCI0.SBRG.UAR1, 0x00)
        }

        Store (\_SB.PCI0.SBRG.UAR2._STA (), Local3)
        And (Local3, 0x03, Local3)
        If (LEqual (Local3, 0x01))
        {
            Notify (\_SB.PCI0.SBRG.UAR2, 0x00)
        }
    }

    Scope (\_SB)
    {
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Method (_INI, 0, NotSerialized)
            {
            }

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

            Device (SBRG)
            {
                Name (_ADR, 0x001F0000)
                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (IRES, Buffer (0xCA)
                    {
                        0x47, 0x01, 0x92, 0x00, 0x92, 0x00, 0x01, 0x01, 
                        0x47, 0x01, 0xB2, 0x00, 0xB2, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xF0, 0x03, 0xF0, 0x03, 0x01, 0x02, 
                        0x47, 0x01, 0x00, 0x04, 0x00, 0x04, 0x01, 0xC0, 
                        0x47, 0x01, 0xD0, 0x04, 0xD0, 0x04, 0x01, 0x02, 
                        0x47, 0x01, 0x10, 0x00, 0x10, 0x00, 0x01, 0x10, 
                        0x47, 0x01, 0x0B, 0x04, 0x0B, 0x04, 0x01, 0x01, 
                        0x47, 0x01, 0xD6, 0x04, 0xD6, 0x04, 0x01, 0x01, 
                        0x47, 0x01, 0x14, 0x0C, 0x14, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x49, 0x0C, 0x49, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x52, 0x0C, 0x52, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x6C, 0x0C, 0x6C, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x6F, 0x0C, 0x6F, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x50, 0x0F, 0x50, 0x0F, 0x01, 0x08, 
                        0x47, 0x01, 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x02, 
                        0x47, 0x01, 0x98, 0x0C, 0x98, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0xD6, 0x0C, 0xD6, 0x0C, 0x01, 0x02, 
                        0x47, 0x01, 0x2E, 0x00, 0x2E, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x30, 0x05, 0x30, 0x05, 0x01, 0x02, 
                        0x47, 0x01, 0x00, 0x05, 0x00, 0x05, 0x01, 0x30, 
                        0x47, 0x01, 0x32, 0x05, 0x32, 0x05, 0x01, 0x0E, 
                        0x47, 0x01, 0x40, 0x05, 0x40, 0x05, 0x01, 0x20, 
                        0x47, 0x01, 0x60, 0x05, 0x60, 0x05, 0x01, 0x20, 
                        0x47, 0x01, 0xA0, 0x05, 0xA0, 0x05, 0x01, 0x20, 
                        0x47, 0x01, 0xA2, 0x0C, 0xA2, 0x0C, 0x01, 0x04, 
                        0x79, 0x00
                    })
                    Name (NRES, Buffer (0xD7)
                    {
                        0x47, 0x01, 0x92, 0x00, 0x92, 0x00, 0x01, 0x01, 
                        0x47, 0x01, 0xB2, 0x00, 0xB2, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xF0, 0x03, 0xF0, 0x03, 0x01, 0x02, 
                        0x47, 0x01, 0x00, 0x04, 0x00, 0x04, 0x01, 0xC0, 
                        0x47, 0x01, 0xD0, 0x04, 0xD0, 0x04, 0x01, 0x02, 
                        0x47, 0x01, 0x10, 0x00, 0x10, 0x00, 0x01, 0x10, 
                        0x47, 0x01, 0x0B, 0x04, 0x0B, 0x04, 0x01, 0x01, 
                        0x47, 0x01, 0xD6, 0x04, 0xD6, 0x04, 0x01, 0x01, 
                        0x47, 0x01, 0x14, 0x0C, 0x14, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x49, 0x0C, 0x49, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x52, 0x0C, 0x52, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x6C, 0x0C, 0x6C, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x6F, 0x0C, 0x6F, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0x50, 0x0F, 0x50, 0x0F, 0x01, 0x08, 
                        0x47, 0x01, 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x02, 
                        0x47, 0x01, 0x98, 0x0C, 0x98, 0x0C, 0x01, 0x01, 
                        0x47, 0x01, 0xD6, 0x0C, 0xD6, 0x0C, 0x01, 0x02, 
                        0x47, 0x01, 0x2E, 0x00, 0x2E, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x30, 0x05, 0x30, 0x05, 0x01, 0x02, 
                        0x47, 0x01, 0x00, 0x05, 0x00, 0x05, 0x01, 0x30, 
                        0x47, 0x01, 0x32, 0x05, 0x32, 0x05, 0x01, 0x0E, 
                        0x47, 0x01, 0x40, 0x05, 0x40, 0x05, 0x01, 0x20, 
                        0x47, 0x01, 0x60, 0x05, 0x60, 0x05, 0x01, 0x20, 
                        0x47, 0x01, 0xA0, 0x05, 0xA0, 0x05, 0x01, 0x20, 
                        0x47, 0x01, 0xA2, 0x0C, 0xA2, 0x0C, 0x01, 0x04, 
                        0x89, 0x0A, 0x00, 0x0B, 0x02, 0x05, 0x0B, 0x00, 
                        0x00, 0x00, 0x00, 0x00, 0x00, 0x79, 0x00
                    })
                    CreateDWordField (NRES, 0xCD, CAIA)
                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (\DATA.SBID.BBID, Local0)
                        And (Local0, 0xC0, Local0)
                        If (LEqual (Local0, 0x80))
                        {
                            Store (\DATA.SBID.BBID, Local0)
                            And (Local0, 0x30, Local0)
                            If (LEqual (Local0, 0x10))
                            {
                                Store (0x05, CAIA)
                                Return (NRES)
                            }
                            Else
                            {
                                If (LEqual (Local0, 0x30))
                                {
                                    Store (0x0B, CAIA)
                                    Return (NRES)
                                }
                            }
                        }
                        Else
                        {
                            Return (IRES)
                        }
                    }
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, Buffer (0x8D)
                    {
                        0x47, 0x01, 0x20, 0x00, 0x20, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x24, 0x00, 0x24, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x28, 0x00, 0x28, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x2C, 0x00, 0x2C, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x30, 0x00, 0x30, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x34, 0x00, 0x34, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x38, 0x00, 0x38, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x3C, 0x00, 0x3C, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x50, 0x00, 0x50, 0x00, 0x01, 0x03, 
                        0x47, 0x01, 0xA4, 0x00, 0xA4, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xA8, 0x00, 0xA8, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xAC, 0x00, 0xAC, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xB0, 0x00, 0xB0, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xB4, 0x00, 0xB4, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xB8, 0x00, 0xB8, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xBC, 0x00, 0xBC, 0x00, 0x01, 0x02, 
                        0x22, 0x04, 0x00, 0x79, 0x00
                    })
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, Buffer (0x65)
                    {
                        0x2A, 0x10, 0x04, 0x47, 0x01, 0x00, 0x00, 0x00, 
                        0x00, 0x01, 0x10, 0x47, 0x01, 0x80, 0x00, 0x80, 
                        0x00, 0x01, 0x01, 0x47, 0x01, 0x81, 0x00, 0x81, 
                        0x00, 0x01, 0x03, 0x47, 0x01, 0x84, 0x00, 0x84, 
                        0x00, 0x01, 0x03, 0x47, 0x01, 0x87, 0x00, 0x87, 
                        0x00, 0x01, 0x01, 0x47, 0x01, 0x88, 0x00, 0x88, 
                        0x00, 0x01, 0x01, 0x47, 0x01, 0x89, 0x00, 0x89, 
                        0x00, 0x01, 0x03, 0x47, 0x01, 0x8C, 0x00, 0x8C, 
                        0x00, 0x01, 0x03, 0x47, 0x01, 0x8F, 0x00, 0x8F, 
                        0x00, 0x01, 0x01, 0x47, 0x01, 0x90, 0x00, 0x90, 
                        0x00, 0x01, 0x02, 0x47, 0x01, 0x93, 0x00, 0x93, 
                        0x00, 0x01, 0x0D, 0x47, 0x01, 0xC0, 0x00, 0xC0, 
                        0x00, 0x01, 0x20, 0x79, 0x00
                    })
                }

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0x40, 0x00, 0x40, 0x00, 0x01, 0x04, 
                        0x22, 0x01, 0x00, 0x79, 0x00
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, Buffer (0x25)
                    {
                        0x47, 0x01, 0x70, 0x00, 0x70, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x72, 0x00, 0x72, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x74, 0x00, 0x74, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x76, 0x00, 0x76, 0x00, 0x01, 0x02, 
                        0x22, 0x00, 0x01, 0x79, 0x00
                    })
                }

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800"))
                    Name (_CRS, Buffer (0x0A)
                    {
                        0x47, 0x01, 0x61, 0x00, 0x61, 0x00, 0x01, 0x01, 
                        0x79, 0x00
                    })
                }

                Device (COPR)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0xF0, 0x00, 0xF0, 0x00, 0x01, 0x10, 
                        0x22, 0x00, 0x20, 0x79, 0x00
                    })
                }

                Device (PS2M)
                {
                    OperationRegion (PSRG, SystemMemory, 0x0410, 0x04)
                    Field (PSRG, DWordAcc, NoLock, Preserve)
                    {
                            ,   2, 
                        PS2E,   1
                    }

                    Name (_HID, EisaId ("PNP0F12"))
                    Name (_CID, 0x130FD041)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PS2E)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Name (_CRS, Buffer (0x05)
                    {
                        0x22, 0x00, 0x10, 0x79, 0x00
                    })
                }

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CID, 0x0B03D041)
                    Name (_CRS, Buffer (0x15)
                    {
                        0x47, 0x01, 0x60, 0x00, 0x60, 0x00, 0x01, 0x01, 
                        0x47, 0x01, 0x64, 0x00, 0x64, 0x00, 0x01, 0x01, 
                        0x22, 0x02, 0x00, 0x79, 0x00
                    })
                }

                OperationRegion (SIO, SystemIO, \DATA.SIO.INDX, 0x02)
                Field (SIO, ByteAcc, NoLock, Preserve)
                {
                    INDX,   8, 
                    DATA,   8
                }

                IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x07), 
                    LDN,    8, 
                    Offset (0x22), 
                    SC_2,   8, 
                    SC_3,   8, 
                    Offset (0x30), 
                    ACTR,   1, 
                    Offset (0x60), 
                    IOAH,   8, 
                    IOAL,   8, 
                    Offset (0x70), 
                    INTR,   8, 
                    INTT,   8, 
                    Offset (0x74), 
                    DMA0,   8, 
                    DMA1,   8, 
                    Offset (0xF0), 
                    SCFG,   8
                }

                Name (LFDC, 0x00)
                Name (LLPT, 0x01)
                Name (LCMB, 0x02)
                Name (LCMA, 0x03)
                Name (LPM, 0x04)
                Name (LKBD, 0x05)
                Name (LMIC, 0x06)
                Name (LGIO, 0x07)
                Name (LXBE, 0x0F)
                Name (LRTC, 0x10)
                Method (ENLD, 1, NotSerialized)
                {
                    Store (Arg0, LDN)
                }

                Name (RES1, Buffer (0x0D)
                {
                    0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 
                    0x22, 0x01, 0x00, 0x79, 0x00
                })
                Name (RES2, Buffer (0x18)
                {
                    0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x01, 0x08, 
                    0x47, 0x01, 0x78, 0x07, 0x78, 0x07, 0x01, 0x04, 
                    0x22, 0x80, 0x00, 0x2A, 0x00, 0x00, 0x79, 0x00
                })
                Method (GSTA, 1, NotSerialized)
                {
                    ENLD (Arg0)
                    If (ACTR)
                    {
                        Store (0x0F, Local0)
                    }
                    Else
                    {
                        If (Or (IOAH, IOAL))
                        {
                            Store (0x0D, Local0)
                        }
                        Else
                        {
                            Store (0x00, Local0)
                        }
                    }

                    Return (Local0)
                }

                Method (IRQM, 0, NotSerialized)
                {
                    If (INTR)
                    {
                        ShiftLeft (0x01, INTR, Local0)
                    }
                    Else
                    {
                        Store (0x00, Local0)
                    }

                    Return (Local0)
                }

                Method (PCRS, 3, NotSerialized)
                {
                    CreateByteField (RES1, 0x02, IOLO)
                    CreateByteField (RES1, 0x03, IOHI)
                    CreateWordField (RES1, 0x02, IOHL)
                    CreateWordField (RES1, 0x04, IORL)
                    CreateByteField (RES1, 0x06, ALMN)
                    CreateByteField (RES1, 0x07, LENG)
                    CreateByteField (RES1, 0x09, IRQL)
                    ENLD (Arg0)
                    Store (IOAH, IOHI)
                    Store (IOAL, IOLO)
                    Store (IOHL, IORL)
                    Store (Arg1, ALMN)
                    If (LEqual (IOLO, 0xBC))
                    {
                        Store (0x04, LENG)
                    }
                    Else
                    {
                        Store (Arg2, LENG)
                    }

                    Store (IRQM (), IRQL)
                    Return (RES1)
                }

                Method (MDIS, 1, NotSerialized)
                {
                    ENLD (Arg0)
                    Store (Zero, ACTR)
                }

                Method (PSRS, 4, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, POLB)
                    CreateByteField (Arg0, 0x03, POHB)
                    CreateWordField (Arg0, 0x02, PADR)
                    CreateByteField (Arg0, 0x07, SIZE)
                    CreateByteField (Arg0, 0x09, PIRQ)
                    ENLD (Arg1)
                    Store (POLB, IOAL)
                    Store (POHB, IOAH)
                    Store (\MLIB.CNV3 (PIRQ), INTR)
                    Store (One, ACTR)
                }

                Method (ECRS, 1, NotSerialized)
                {
                    CreateByteField (RES2, 0x02, EPLO)
                    CreateByteField (RES2, 0x03, EPHI)
                    CreateWordField (RES2, 0x02, EPHL)
                    CreateWordField (RES2, 0x04, EPRL)
                    CreateWordField (RES2, 0x06, ALM1)
                    CreateWordField (RES2, 0x0A, E4LO)
                    CreateWordField (RES2, 0x0C, E4RL)
                    CreateWordField (RES2, 0x0E, ALM2)
                    CreateWordField (RES2, 0x11, EIRQ)
                    CreateWordField (RES2, 0x14, EDMA)
                    ENLD (Arg0)
                    Store (IOAH, EPHI)
                    Store (IOAL, EPLO)
                    Store (EPHL, EPRL)
                    Add (EPHL, 0x0400, E4LO)
                    Store (E4LO, E4RL)
                    If (LEqual (EPHL, 0x03BC))
                    {
                        Store (0x0401, ALM1)
                        Store (0x0401, ALM2)
                    }
                    Else
                    {
                        Store (0x0801, ALM1)
                        Store (0x0801, ALM2)
                    }

                    Store (IRQM (), EIRQ)
                    Store (DMA0, Local1)
                    If (LGreater (Local1, 0x03))
                    {
                        Store (Zero, EDMA)
                    }
                    Else
                    {
                        ShiftLeft (0x01, Local1, EDMA)
                    }

                    Return (RES2)
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, Buffer (0x12)
                    {
                        0x47, 0x01, 0xA6, 0x0C, 0xA6, 0x0C, 0x00, 0x01, 
                        0x47, 0x01, 0xA7, 0x0C, 0xA7, 0x0C, 0x00, 0x01, 
                        0x79, 0x00
                    })
                    OperationRegion (ECIO, SystemIO, 0x0CA6, 0x02)
                    Field (ECIO, ByteAcc, Lock, Preserve)
                    {
                        ECDA,   8, 
                        ECMD,   8
                    }

                    Name (_GPE, 0x08)
                    Name (EREF, 0x00)
                    Name (EREG, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, EREG)
                            If (LEqual (EREF, 0x00))
                            {
                                Store (0x01, EREF)
                                SSLT (0x00)
                                ESIN (0x30)
                            }
                        }
                    }

                    Mutex (ECX0, 0x00)
                    OperationRegion (EC0, EmbeddedControl, 0x00, 0x10)
                    Field (EC0, ByteAcc, Lock, Preserve)
                    {
                        SCMD,   8, 
                        SSTS,   8, 
                        SD00,   8, 
                        SD01,   8, 
                        SD02,   8, 
                        SD03,   8, 
                        SD04,   8, 
                        SD05,   8, 
                        SD06,   8, 
                        SD07,   8, 
                        SD08,   8, 
                        SD09,   8, 
                        SD10,   8, 
                        Offset (0x0E), 
                        SLPS,   1, 
                        Offset (0x0F), 
                        SSCR,   8
                    }

                    Method (SREC, 7, NotSerialized)
                    {
                        Store (Package (0x02)
                            {
                                0x00, 
                                0xFF
                            }, Local0)
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (Arg0, SD00)
                                Store (Arg1, SD01)
                                Store (Arg2, SD02)
                                Store (Arg3, SD03)
                                Store (Arg4, SD04)
                                Store (Arg5, SD05)
                                Store (Arg6, SD06)
                                Store (0x03, SCMD)
                                Store (ECCW (0xC8), Index (Local0, 0x01))
                                Store (SCMD, Index (Local0, 0x00))
                                Release (ECX0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (GREC, 1, NotSerialized)
                    {
                        Store (Package (0x08)
                            {
                                0x00, 
                                0xFF, 
                                0x00, 
                                0x00, 
                                0x00, 
                                0x00, 
                                0x00, 
                                0x00
                            }, Local0)
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (Arg0, SD00)
                                Store (0x04, SCMD)
                                Store (ECCW (0xC8), Index (Local0, 0x01))
                                Store (SCMD, Index (Local0, 0x00))
                                Store (SD00, Index (Local0, 0x02))
                                Store (SD01, Index (Local0, 0x03))
                                Store (SD02, Index (Local0, 0x04))
                                Store (SD03, Index (Local0, 0x05))
                                Store (SD04, Index (Local0, 0x06))
                                Store (SD05, Index (Local0, 0x07))
                                Release (ECX0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (SWEC, 7, NotSerialized)
                    {
                        Store (Package (0x02)
                            {
                                0x00, 
                                0xFF
                            }, Local0)
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (Arg0, SD00)
                                Store (Arg1, SD01)
                                Store (Arg2, SD02)
                                Store (Arg3, SD03)
                                Store (Arg4, SD04)
                                Store (Arg5, SD05)
                                Store (Arg6, SD06)
                                Store (0x05, SCMD)
                                Store (ECCW (0xC8), Index (Local0, 0x01))
                                Store (SCMD, Index (Local0, 0x00))
                                Release (ECX0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (GWEC, 1, NotSerialized)
                    {
                        Store (Package (0x08)
                            {
                                0x00, 
                                0xFF, 
                                0x00, 
                                0x00, 
                                0x00, 
                                0x00, 
                                0x00, 
                                0x00
                            }, Local0)
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (Arg0, SD00)
                                Store (0x06, SCMD)
                                Store (ECCW (0xC8), Index (Local0, 0x01))
                                Store (SCMD, Index (Local0, 0x00))
                                Store (SD00, Index (Local0, 0x02))
                                Store (SD01, Index (Local0, 0x03))
                                Store (SD02, Index (Local0, 0x04))
                                Store (SD03, Index (Local0, 0x05))
                                Store (SD04, Index (Local0, 0x06))
                                Store (SD05, Index (Local0, 0x07))
                                Release (ECX0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (SIEC, 1, NotSerialized)
                    {
                        Store (Package (0x02)
                            {
                                0x00, 
                                0xFF
                            }, Local0)
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (Arg0, SD00)
                                Store (0x07, SCMD)
                                Store (ECCW (0xC8), Index (Local0, 0x01))
                                Store (SCMD, Index (Local0, 0x00))
                                Release (ECX0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (GIEC, 0, NotSerialized)
                    {
                        Store (Package (0x03)
                            {
                                0x00, 
                                0xFF, 
                                0x00
                            }, Local0)
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (0x08, SCMD)
                                Store (ECCW (0xC8), Index (Local0, 0x01))
                                Store (SCMD, Index (Local0, 0x00))
                                Store (SD00, Index (Local0, 0x02))
                                Release (ECX0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (ECCW, 1, NotSerialized)
                    {
                        Store (Arg0, Local0)
                        Store (0x01, Local2)
                        Store (0x01, Local1)
                        While (LEqual (Local1, 0x01))
                        {
                            If (LEqual (SCMD, 0x00))
                            {
                                Store (SSTS, Local2)
                                Store (0x00, Local1)
                            }
                            Else
                            {
                                If (LEqual (Local0, 0x00))
                                {
                                    Store (0x01, Local2)
                                    Store (0x00, Local1)
                                }
                                Else
                                {
                                    Sleep (0x01)
                                    Subtract (Local0, 0x01, Local0)
                                }
                            }
                        }

                        Return (Local2)
                    }

                    Method (SSLT, 1, NotSerialized)
                    {
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (Arg0, SSCR)
                                Release (ECX0)
                            }
                        }
                    }

                    Method (SPSW, 1, NotSerialized)
                    {
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (0x01, SLPS)
                                Release (ECX0)
                            }

                            If (LEqual (Arg0, 0x00))
                            {
                                \_SB.PCI0.SBRG.EC0.SWEC (0x00, 0xFF, 0x40, 0xFF, 0xFF, 0xFF, 0xFF)
                                Store (0x0C, \DATA.SWCE.WESL)
                                And (\DATA.SWCE.WSTE, 0xFC, \DATA.SWCE.WSTE)
                            }

                            If (LEqual (Arg0, 0x01))
                            {
                                \_SB.PCI0.SBRG.EC0.SWEC (0x00, 0x03, 0x40, 0xFF, 0xFF, 0xFF, 0xFF)
                                Store (0x0C, \DATA.SWCE.WESL)
                                Or (\DATA.SWCE.WSTE, 0x03, \DATA.SWCE.WSTE)
                            }
                        }
                    }

                    Method (ESIN, 1, NotSerialized)
                    {
                        Store (Package (0x02)
                            {
                                0x00, 
                                0x00
                            }, Local1)
                        If (LEqual (EREG, 0x01))
                        {
                            If (LEqual (Acquire (ECX0, 0xFFFF), 0x00))
                            {
                                Store (SIEC (Arg0), Local1)
                                Store (DerefOf (Index (Local1, 0x01)), Local0)
                                Release (ECX0)
                                Return (Local0)
                            }
                            Else
                            {
                                Return (0xFF)
                            }
                        }
                    }

                    Method (SSLP, 1, NotSerialized)
                    {
                        If (LEqual (EREG, 0x01))
                        {
                            Store (0xFE, Local0)
                            If (LEqual (Arg0, 0x01))
                            {
                                Store (SREC (0x20, 0x03, 0x40, 0xFF, 0xFF, 0xFF, 0xFF), Local0)
                            }

                            If (LEqual (Arg0, 0x00))
                            {
                                Store (SREC (0x20, 0xFF, 0x40, 0xFF, 0xFF, 0xFF, 0xFF), Local0)
                            }

                            Return (Local0)
                        }
                    }

                    Method (_Q00, 0, NotSerialized)
                    {
                        Store ("*** Query Code 0x00 ***", Debug)
                    }

                    Method (_Q30, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.SBRG.UAR2, 0x01)
                    }
                }

                Device (FDC0)
                {
                    Name (_HID, EisaId ("PNP0700"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (GSTA (LFDC))
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        MDIS (LFDC)
                    }

                    Name (_PRS, Buffer (0x23)
                    {
                        0x31, 0x00, 0x47, 0x01, 0xF2, 0x03, 0xF2, 0x03, 
                        0x01, 0x02, 0x47, 0x01, 0xF4, 0x03, 0xF4, 0x03, 
                        0x01, 0x02, 0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03, 
                        0x01, 0x01, 0x22, 0x40, 0x00, 0x2A, 0x04, 0x00, 
                        0x38, 0x79, 0x00
                    })
                    Name (FRES, Buffer (0x20)
                    {
                        0x47, 0x01, 0xF2, 0x03, 0xF2, 0x03, 0x01, 0x02, 
                        0x47, 0x01, 0xF4, 0x03, 0xF4, 0x03, 0x01, 0x02, 
                        0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03, 0x01, 0x01, 
                        0x22, 0x40, 0x00, 0x2A, 0x04, 0x00, 0x79, 0x00
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        Return (FRES)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, FADL)
                        CreateByteField (Arg0, 0x03, FADH)
                        CreateWordField (Arg0, 0x02, FADR)
                        CreateWordField (Arg0, 0x19, FIRQ)
                        CreateWordField (Arg0, 0x1C, FDMA)
                        ENLD (LFDC)
                        Store (FADL, IOAL)
                        Store (FADH, IOAH)
                        Store (\MLIB.CNV3 (FIRQ), INTR)
                        Store (\MLIB.CNV3 (FDMA), DMA0)
                        Store (One, ACTR)
                    }

                    Method (_FDE, 0, NotSerialized)
                    {
                        Name (FDEB, Buffer (0x05)
                        {
                            0x01, 0x00, 0x02, 0x02, 0x02
                        })
                        CreateDWordField (FDEB, 0x00, FDD0)
                        CreateDWordField (FDEB, 0x01, FDD1)
                        Store (0x01, FDD0)
                        Store (0x02, FDD1)
                        Return (FDEB)
                    }
                }

                Device (UAR1)
                {
                    Name (_HID, EisaId ("PNP0501"))
                    Name (_UID, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (GSTA (LCMA))
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        MDIS (LCMA)
                    }

                    Name (_PRS, Buffer (0x40)
                    {
                        0x31, 0x00, 0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 
                        0x04, 0x08, 0x22, 0x10, 0x00, 0x30, 0x47, 0x01, 
                        0xF8, 0x03, 0xF8, 0x03, 0x04, 0x08, 0x22, 0x18, 
                        0x0C, 0x30, 0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02, 
                        0x04, 0x08, 0x22, 0x18, 0x0C, 0x30, 0x47, 0x01, 
                        0xE8, 0x03, 0xE8, 0x03, 0x04, 0x08, 0x22, 0x18, 
                        0x0C, 0x30, 0x47, 0x01, 0xE8, 0x02, 0xE8, 0x02, 
                        0x04, 0x08, 0x22, 0x18, 0x0C, 0x38, 0x79, 0x00
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        Return (PCRS (LCMA, 0x01, 0x08))
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        PSRS (Arg0, LCMA, 0x06, 0x00)
                    }
                }

                Device (UAR2)
                {
                    Method (_HID, 0, NotSerialized)
                    {
                        Return (0x0105D041)
                    }

                    Name (_UID, 0x02)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (GSTA (LCMB))
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        MDIS (LCMB)
                    }

                    Name (_PRS, Buffer (0x40)
                    {
                        0x31, 0x00, 0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02, 
                        0x04, 0x08, 0x22, 0x08, 0x00, 0x30, 0x47, 0x01, 
                        0xF8, 0x02, 0xF8, 0x02, 0x04, 0x08, 0x22, 0x18, 
                        0x0C, 0x30, 0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 
                        0x04, 0x08, 0x22, 0x18, 0x0C, 0x30, 0x47, 0x01, 
                        0xE8, 0x03, 0xE8, 0x03, 0x04, 0x08, 0x22, 0x18, 
                        0x0C, 0x30, 0x47, 0x01, 0xE8, 0x02, 0xE8, 0x02, 
                        0x04, 0x08, 0x22, 0x18, 0x0C, 0x38, 0x79, 0x00
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        Return (PCRS (LCMB, 0x01, 0x08))
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        PSRS (Arg0, LCMB, 0x07, 0x00)
                    }
                }
            }

            Name (_ADR, 0x00)
            Name (_BBN, 0x00)
            Name (_UID, 0x00)
            Name (CRS, Buffer (0xA2)
            {
                0x88, 0x0D, 0x00, 0x02, 0x0C, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 
                0x47, 0x01, 0xF8, 0x0C, 0xF8, 0x0C, 0x01, 0x08, 
                0x88, 0x0D, 0x00, 0x01, 0x0C, 0x03, 0x00, 0x00, 
                0x00, 0x00, 0xF7, 0x0C, 0x00, 0x00, 0xF8, 0x0C, 
                0x88, 0x0D, 0x00, 0x01, 0x0C, 0x03, 0x00, 0x00, 
                0x00, 0x0D, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xF3, 
                0x87, 0x17, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0xFF, 0xFF, 
                0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x02, 0x00, 0x87, 0x17, 0x00, 0x00, 0x0C, 0x03, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x87, 0x17, 0x00, 0x00, 
                0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0x17, 
                0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 
                0x79, 0x00
            })
            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)
            {
                TOPM ()
                Return (CRS)
            }

            Method (CHPS, 1, NotSerialized)
            {
                Noop
            }

            Method (CHPW, 1, NotSerialized)
            {
                Noop
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)
                Name (_S1D, 0x02)
                OperationRegion (BAR0, PCI_Config, 0xC4, 0x01)
                Field (BAR0, ByteAcc, NoLock, Preserve)
                {
                    USBW,   8
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, USBW)
                    }
                    Else
                    {
                        Store (0x00, USBW)
                    }
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)
                Name (_S1D, 0x02)
                OperationRegion (BAR1, PCI_Config, 0xC4, 0x01)
                Field (BAR1, ByteAcc, NoLock, Preserve)
                {
                    USBX,   8
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, USBX)
                    }
                    Else
                    {
                        Store (0x00, USBX)
                    }
                }
            }

            Device (USB3)
            {
                Name (_ADR, 0x001D0002)
                Name (_S1D, 0x02)
                OperationRegion (BAR2, PCI_Config, 0xC4, 0x01)
                Field (BAR2, ByteAcc, NoLock, Preserve)
                {
                    USBY,   8
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, USBY)
                    }
                    Else
                    {
                        Store (0x00, USBY)
                    }
                }
            }

            Device (SMB0)
            {
                Name (_ADR, 0x001F0003)
                Method (_PRW, 0, NotSerialized)
                {
                    Return (GPRW (0x05, 0x03))
                }
            }

            Device (\_SB.PCI0.SBRG.FWH)
            {
                Name (_HID, EisaId ("INT0800"))
                Name (_CRS, Buffer (0x32)
                {
                    0x86, 0x09, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 
                    0x00, 0x00, 0x10, 0x00, 0x86, 0x09, 0x00, 0x01, 
                    0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0x10, 0x00, 
                    0x86, 0x09, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xFF, 
                    0x00, 0x00, 0x10, 0x00, 0x86, 0x09, 0x00, 0x00, 
                    0x00, 0x00, 0xC0, 0xFF, 0x00, 0x00, 0x10, 0x00, 
                    0x79, 0x00
                })
            }

            OperationRegion (OPC4, PCI_Config, 0xC4, 0x02)
            Field (OPC4, AnyAcc, NoLock, Preserve)
            {
                    ,   11, 
                TOLM,   5
            }

            Method (MDET, 0, NotSerialized)
            {
                Store (TOLM, Local0)
                Multiply (Local0, 0x08000000, Local0)
                Return (Local0)
            }

            Method (TOPM, 0, NotSerialized)
            {
                If (FLAG)
                {
                    Store (MDET (), Local0)
                }
                Else
                {
                    Store (0x20000000, Local0)
                }

                Store (Local0, MIN6)
                Store (0xFEBFFFFF, MAX6)
                Subtract (0xFEC00000, MIN6, LEN6)
                Return (Local0)
            }

            OperationRegion (PAMX, PCI_Config, 0x59, 0x07)
            Field (PAMX, ByteAcc, NoLock, Preserve)
            {
                    ,   4, 
                BSEG,   4, 
                PAMS,   48
            }

            Name (ERNG, Package (0x0D)
            {
                0x000C0000, 
                0x000C4000, 
                0x000C8000, 
                0x000CC000, 
                0x000D0000, 
                0x000D4000, 
                0x000D8000, 
                0x000DC000, 
                0x000E0000, 
                0x000E4000, 
                0x000E8000, 
                0x000EC000, 
                0x000F0000
            })
            Name (PAMB, Buffer (0x07) {})
            Method (EROM, 0, NotSerialized)
            {
                If (LEN5)
                {
                    Return (0x00)
                }

                CreateByteField (PAMB, 0x06, BREG)
                Store (PAMS, PAMB)
                Store (BSEG, BREG)
                Store (0x00, MIN5)
                Store (0x00, MAX5)
                Store (0x00, LEN5)
                Store (0x00, Local0)
                While (LLess (Local0, 0x0D))
                {
                    ShiftRight (Local0, 0x01, Local1)
                    Store (DerefOf (Index (PAMB, Local1)), Local2)
                    If (And (Local0, 0x01))
                    {
                        ShiftRight (Local2, 0x04, Local2)
                    }

                    If (And (Local2, 0x03))
                    {
                        If (MIN5)
                        {
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        If (LEqual (MIN5, 0x00))
                        {
                            Store (DerefOf (Index (ERNG, Local0)), MIN5)
                        }

                        Add (DerefOf (Index (ERNG, Local0)), 0x3FFF, MAX5)
                        If (LEqual (MAX5, 0x000F3FFF))
                        {
                            Store (0x000FFFFF, MAX5)
                        }

                        Subtract (MAX5, MIN5, LEN5)
                        Increment (LEN5)
                    }

                    Increment (Local0)
                }
            }

            OperationRegion (\_SB.PCI0.SBRG.BAR0, PCI_Config, 0x40, 0x05)
            OperationRegion (\_SB.PCI0.SBRG.BAR1, PCI_Config, 0x58, 0x05)
            OperationRegion (\_SB.PCI0.SBRG.BAR2, PCI_Config, 0xD1, 0x01)
            OperationRegion (\_SB.PCI0.SBRG.BAR3, PCI_Config, 0xE3, 0x01)
            OperationRegion (\_SB.PCI0.SMB0.BAR4, PCI_Config, 0x00, 0x22)
            Field (\_SB.PCI0.SBRG.BAR0, ByteAcc, NoLock, Preserve)
            {
                PMIO,   16
            }

            Field (\_SB.PCI0.SBRG.BAR1, ByteAcc, NoLock, Preserve)
            {
                GPIO,   16, 
                Offset (0x04), 
                    ,   4, 
                GPEN,   1
            }

            Field (\_SB.PCI0.SBRG.BAR2, ByteAcc, NoLock, Preserve)
            {
                APCD,   1
            }

            Field (\_SB.PCI0.SBRG.BAR3, ByteAcc, NoLock, Preserve)
            {
                MDEC,   8
            }

            Field (\_SB.PCI0.SMB0.BAR4, ByteAcc, NoLock, Preserve)
            {
                Offset (0x04), 
                SMEN,   1, 
                Offset (0x20), 
                SMIO,   16
            }

            Name (DECR, Package (0x08)
            {
                0xFF800000, 
                0xFF880000, 
                0xFF900000, 
                0xFF980000, 
                0xFFA00000, 
                0xFFA80000, 
                0xFFB00000, 
                0xFFB80000
            })
            Method (ROMS, 0, NotSerialized)
            {
                Store (0x00, Local1)
                FindSetRightBit (MDEC, Local0)
                If (Local0)
                {
                    Decrement (Local0)
                    Store (DerefOf (Index (DECR, Local0)), Local1)
                }

                Return (Local1)
            }

            Method (CRES, 0, NotSerialized)
            {
                If (APCD)
                {
                    Store (0x00100000, APCL)
                    Store (0xFEC00000, APCB)
                }

                And (PMIO, 0xFFC0, PMBS)
                Store (0x80, PMLN)
                If (LEqual (And (SMIO, 0x07), 0x01))
                {
                    If (SMEN)
                    {
                        And (SMIO, 0xFFFE, SMBS)
                    }
                }

                If (GPEN)
                {
                    And (GPIO, 0xFFC0, IOB1)
                    Store (0x40, IOL1)
                }
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (APIC)
                {
                    Return (AR00)
                }

                Return (PR00)
            }

            Name (PR00, Package (0x06)
            {
                Package (0x04)
                {
                    0x001DFFFF, 
                    0x00, 
                    LNKA, 
                    0x00
                }, 

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

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

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

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

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x03, 
                    LNKD, 
                    0x00
                }
            })
            Name (AR00, Package (0x06)
            {
                Package (0x04)
                {
                    0x001DFFFF, 
                    0x00, 
                    0x00, 
                    0x10
                }, 

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

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

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

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

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x03, 
                    0x00, 
                    0x13
                }
            })
            Name (PR01, Package (0x04)
            {
                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    LNKB, 
                    0x00
                }, 

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

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

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x00, 
                    LNKD, 
                    0x00
                }
            })
            Name (AR01, Package (0x04)
            {
                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    0x00, 
                    0x11
                }, 

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

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

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x00, 
                    0x00, 
                    0x13
                }
            })
            Name (PR06, Package (0x10)
            {
                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    LNKA, 
                    0x00
                }, 

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

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x01, 
                    LNKA, 
                    0x00
                }, 

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

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

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

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

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

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x03, 
                    LNKA, 
                    0x00
                }
            })
            Name (AR06, Package (0x0E)
            {
                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    0x00, 
                    0x18
                }, 

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    0x00, 
                    0x1C
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x01, 
                    0x00, 
                    0x1D
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    0x00, 
                    0x18
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    0x00, 
                    0x1B
                }, 

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

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x01, 
                    0x00, 
                    0x1F
                }
            })
            Name (PR07, Package (0x0E)
            {
                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    LNKA, 
                    0x00
                }, 

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

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x01, 
                    LNKA, 
                    0x00
                }, 

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

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

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

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x01, 
                    LNKA, 
                    0x00
                }
            })
            Name (AR07, Package (0x0E)
            {
                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    0x00, 
                    0x30
                }, 

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    0x00, 
                    0x34
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x01, 
                    0x00, 
                    0x35
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    0x00, 
                    0x30
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    0x00, 
                    0x33
                }, 

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

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x01, 
                    0x00, 
                    0x31
                }
            })
            OperationRegion (\_SB.PCI0.SBRG.PIX0, PCI_Config, 0x60, 0x04)
            Field (\_SB.PCI0.SBRG.PIX0, ByteAcc, NoLock, Preserve)
            {
                PIRA,   8, 
                PIRB,   8, 
                PIRC,   8, 
                PIRD,   8
            }

            OperationRegion (\_SB.PCI0.SBRG.PIX1, PCI_Config, 0x68, 0x04)
            Field (\_SB.PCI0.SBRG.PIX1, ByteAcc, NoLock, Preserve)
            {
                PIRE,   8, 
                PIRF,   8, 
                PIRG,   8, 
                PIRH,   8
            }

            Name (BUFA, Buffer (0x06)
            {
                0x23, 0x00, 0x80, 0x18, 0x79, 0x00
            })
            CreateWordField (BUFA, 0x01, ICRS)
            Device (LNKA)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    And (PIRA, 0x80, Local0)
                    If (Local0)
                    {
                        Return (0x09)
                    }
                    Else
                    {
                        Return (0x0B)
                    }
                }

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

                Method (_DIS, 0, NotSerialized)
                {
                    Or (PIRA, 0x80, PIRA)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    And (PIRA, 0x0F, Local0)
                    ShiftLeft (0x01, Local0, ICRS)
                    Return (BUFA)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateWordField (Arg0, 0x01, ISRS)
                    FindSetRightBit (ISRS, Local0)
                    Subtract (Local0, 0x01, PIRA)
                }
            }

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

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

                Method (_DIS, 0, NotSerialized)
                {
                    Or (PIRB, 0x80, PIRB)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    And (PIRB, 0x0F, Local0)
                    ShiftLeft (0x01, Local0, ICRS)
                    Return (BUFA)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateWordField (Arg0, 0x01, ISRS)
                    FindSetRightBit (ISRS, Local0)
                    Subtract (Local0, 0x01, PIRB)
                }
            }

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

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

                Method (_DIS, 0, NotSerialized)
                {
                    Or (PIRC, 0x80, PIRC)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    And (PIRC, 0x0F, Local0)
                    ShiftLeft (0x01, Local0, ICRS)
                    Return (BUFA)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateWordField (Arg0, 0x01, ISRS)
                    FindSetRightBit (ISRS, Local0)
                    Subtract (Local0, 0x01, PIRC)
                }
            }

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

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

                Method (_DIS, 0, NotSerialized)
                {
                    Or (PIRD, 0x80, PIRD)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    And (PIRD, 0x0F, Local0)
                    ShiftLeft (0x01, Local0, ICRS)
                    Return (BUFA)
                }

                Method (_SRS, 1, NotSerialized)
                {
                    CreateWordField (Arg0, 0x01, ISRS)
                    FindSetRightBit (ISRS, Local0)
                    Subtract (Local0, 0x01, PIRD)
                }
            }

            Name (PRSA, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Name (PRSB, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Name (PRSC, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Name (PRSD, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Name (PRSE, Buffer (0x06)
            {
                0x23, 0x00, 0xD8, 0x18, 0x79, 0x00
            })
            Name (PRSF, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Name (PRSG, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Name (PRSH, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Device (P0P1)
            {
                Name (_ADR, 0x001E0000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (APIC)
                    {
                        Return (AR01)
                    }

                    Return (PR01)
                }
            }

            Device (P0P5)
            {
                Name (_ADR, 0x00030000)
                Device (P5P6)
                {
                    Name (_ADR, 0x001F0000)
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (APIC)
                        {
                            Return (AR06)
                        }

                        Return (PR06)
                    }

                    Method (_PSW, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x0E, \DATA.WUES.WKES)
                            Store (0x01, \DATA.WUSE.WKUS)
                        }
                        Else
                        {
                            Store (0x0E, \DATA.WUES.WKES)
                            Store (0x00, \DATA.WUSE.WKUS)
                        }
                    }
                }

                Device (P5P7)
                {
                    Name (_ADR, 0x001D0000)
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (APIC)
                        {
                            Return (AR07)
                        }

                        Return (PR07)
                    }

                    Method (_PSW, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x0F, \DATA.WUES.WKES)
                            Store (0x01, \DATA.WUSE.WKUS)
                        }
                        Else
                        {
                            Store (0x0F, \DATA.WUES.WKES)
                            Store (0x00, \DATA.WUSE.WKUS)
                        }
                    }
                }
            }

            Scope (\_SB.PCI0.SBRG.RTC)
            {
                OperationRegion (OP70, SystemIO, 0x72, 0x02)
                Field (OP70, ByteAcc, Lock, Preserve)
                {
                    IDX7,   8, 
                    DAT7,   8
                }

                IndexField (IDX7, DAT7, ByteAcc, Lock, Preserve)
                {
                    Offset (0x03), 
                    CREG,   8
                }
            }

            Scope (\)
            {
                Method (CMOS, 0, NotSerialized)
                {
                    Name (CMSK, 0x03)
                    And (\_SB.PCI0.SBRG.RTC.CREG, CMSK, Local0)
                    Return (Local0)
                }
            }
        }

        Name (\_SB.PCI0.SBRG.UAR1._PRW, Package (0x02)
        {
            0x20, 
            0x05
        })
        Name (\_SB.PCI0.SBRG.UAR2._PRW, Package (0x02)
        {
            0x21, 
            0x05
        })
        Name (\_SB.PCI0.SBRG.PS2K._PRW, Package (0x02)
        {
            0x2A, 
            0x01
        })
        Name (\_SB.PCI0.SBRG.PS2M._PRW, Package (0x02)
        {
            0x2B, 
            0x01
        })
        Name (\_SB.PCI0.USB1._PRW, Package (0x02)
        {
            0x03, 
            0x01
        })
        Name (\_SB.PCI0.USB2._PRW, Package (0x02)
        {
            0x04, 
            0x01
        })
        Name (\_SB.PCI0.P0P1._PRW, Package (0x02)
        {
            0x0B, 
            0x05
        })
        Name (\_SB.PCI0.P0P5.P5P6._PRW, Package (0x02)
        {
            0x1E, 
            0x05
        })
        Name (\_SB.PCI0.P0P5.P5P7._PRW, Package (0x02)
        {
            0x1F, 
            0x05
        })
    }

    Method (GPRW, 2, NotSerialized)
    {
        Name (PRWP, Package (0x02)
        {
            0x00, 
            0x00
        })
        Store (0x01, Local0)
        Store (Arg0, Index (PRWP, 0x00))
        Store (Arg1, Index (PRWP, 0x01))
        Or (Local0, 0x02, Local0)
        If (And (ShiftLeft (0x01, Arg1), Local0)) {}
        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)
    }

    Scope (\_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
        }

        Method (_MSG, 1, NotSerialized)
        {
            Noop
        }
    }
}