/*
 * Intel ACPI Component Architecture
 * AML/ASL+ Disassembler version 20161210-64(RM)
 * Copyright (c) 2000 - 2016 Intel Corporation
 * 
 * Disassembling to non-symbolic legacy ASL operators
 *
 * Disassembly of iASLIQomAy.aml, Sun Mar 11 15:42:17 2018
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00004AFB (19195)
 *     Revision         0x01 **** 32-bit table (V1), no 64-bit math support
 *     Checksum         0x8F
 *     OEM ID           "Apple "
 *     OEM Table ID     "dt_ex"
 *     OEM Revision     0x00001000 (4096)
 *     Compiler ID      "INTL"
 *     Compiler Version 0x20050624 (537200164)
 */
DefinitionBlock ("", "DSDT", 1, "Apple ", "dt_ex", 0x00001000)
{
    /*
     * iASL Warning: There was 1 external control method found during
     * disassembly, but only 0 were resolved (1 unresolved). Additional
     * ACPI tables may be required to properly disassemble the code. This
     * resulting disassembler output file may not compile because the
     * disassembler did not know how many arguments to assign to the
     * unresolved methods. Note: SSDTs can be dynamically loaded at
     * runtime and may or may not be available via the host OS.
     *
     * In addition, the -fe option can be used to specify a file containing
     * control method external declarations with the associated method
     * argument counts. Each line of the file must be of the form:
     *     External (<method pathname>, MethodObj, <argument count>)
     * Invocation:
     *     iasl -fe refs.txt -d dsdt.aml
     *
     * The following methods were unresolved and many not compile properly
     * because the disassembler had to guess at the number of arguments
     * required for each:
     */
    External (DTGP, MethodObj)    // Warning: Unknown method, guessing 5 arguments

    Method (DBIN, 0, NotSerialized)
    {
        Noop
    }

    Scope (\)
    {
        Device (_SB.VBTN)
        {
            Name (_HID, EisaId ("PNP0C0C"))  // _HID: Hardware ID
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                One, 
                0x04
            })
        }

        OperationRegion (SSTS, SystemIO, 0x0828, One)
        Field (SSTS, ByteAcc, NoLock, WriteAsZeros)
        {
            TSTS,   1
        }

        OperationRegion (SACT, SystemIO, 0x082A, One)
        Field (SACT, ByteAcc, NoLock, WriteAsZeros)
        {
                ,   2, 
            TPOL,   1
        }
    }

    Scope (_GPE)
    {
        Method (_L00, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            Store (Zero, TPOL)
            Store (One, TSTS)
            Notify (\_SB.VBTN, 0x02)
        }
    }

    Scope (_SB)
    {
        Method (_INI, 0, NotSerialized)  // _INI: Initialize
        {
            If (CondRefOf (_OSI, Local0))
            {
                If (_OSI ("Windows 2001"))
                {
                    Store (0x04, MSOS)
                }
            }
        }
    }

    Scope (\)
    {
        Name (MSOS, Zero)
        Mutex (MTX, 0x01)
        Method (CMRD, 1, NotSerialized)
        {
            Acquire (SMIM, 0xFFFF)
            Store (Arg0, Local0)
            And (Local0, 0x7F, Local0)
            Store (Local0, SMID)
            Store (0x84, SMIC)
            Store (0x85, SMIC)
            Store (SMID, Local0)
            Release (SMIM)
            Return (Local0)
        }

        Method (CMWR, 2, NotSerialized)
        {
            Acquire (SMIM, 0xFFFF)
            Store (Arg0, Local0)
            Or (Local0, 0x80, Local0)
            Store (Local0, SMID)
            Store (0x84, SMIC)
            Store (Arg1, SMID)
            Store (0x85, SMIC)
            Release (SMIM)
        }

        Method (GCKB, 0, NotSerialized)
        {
            Return (And (0x20, CMRD (0x26)))
        }

        Method (GCMS, 0, NotSerialized)
        {
            Return (And (0x40, CMRD (0x6F)))
        }

        Method (GCON, 0, NotSerialized)
        {
            Return (And (0x04, CMRD (0x55)))
        }

        Method (GCUC, 0, NotSerialized)
        {
            And (One, CMRD (0x22), Local0)
            Return (XOr (One, Local0))
        }

        Method (GCS1, 0, NotSerialized)
        {
            Return (And (0x03, CMRD (0x25)))
        }

        Method (GCS2, 0, NotSerialized)
        {
            Return (And (0x0C, CMRD (0x25)))
        }

        Method (GCFD, 0, NotSerialized)
        {
            Return (And (0x18, CMRD (0x55)))
        }

        Method (GCPP, 0, NotSerialized)
        {
            Return (And (0x70, CMRD (0x23)))
        }

        Method (GCTP, 0, NotSerialized)
        {
            Return (And (0x40, CMRD (0x22)))
        }

        Method (GCNC, 0, NotSerialized)
        {
            Return (And (0x03, CMRD (0x59)))
        }

        Method (HACK, 0, NotSerialized)
        {
            If (LEqual (MSOS, 0x04))
            {
                Store (CMRD (0x6F), Local0)
                Or (Local0, 0x04, Local0)
                CMWR (0x6F, Local0)
                Return (One)
            }
            Else
            {
                Store (CMRD (0x6F), Local0)
                And (Local0, 0xFB, Local0)
                CMWR (0x6F, Local0)
            }

            Add (SizeOf (_OS), One, Local0)
            Store (Local0, Local1)
            Name (BUF0, Buffer (Local0) {})
            Name (BUF1, Buffer (Local0) {})
            Name (OSNT, One)
            Name (OS98, One)
            Store (_OS, BUF0)
            Store ("Microsoft Windows NT", BUF1)
            While (Local0)
            {
                Decrement (Local0)
                If (LEqual (DerefOf (Index (BUF0, Local0)), DerefOf (Index (BUF1, Local0)))) {}
                Else
                {
                    Store (Zero, OSNT)
                }
            }

            If (OSNT)
            {
                Store (0x03, MSOS)
                Return (One)
            }
            Else
            {
                Store ("Microsoft Windows", BUF1)
                While (Local1)
                {
                    Decrement (Local1)
                    If (LEqual (DerefOf (Index (BUF0, Local1)), DerefOf (Index (BUF1, Local1)))) {}
                    Else
                    {
                        Store (Zero, OS98)
                    }
                }

                If (OS98)
                {
                    Store (One, MSOS)
                    Return (Zero)
                }
                Else
                {
                    Store (0x02, MSOS)
                    Return (Zero)
                }
            }
        }

        Method (ISLI, 0, NotSerialized)
        {
            If (CondRefOf (_OSI, Local0))
            {
                If (_OSI ("Linux"))
                {
                    Return (One)
                }
                Else
                {
                    Return (Zero)
                }
            }
            Else
            {
                Return (Zero)
            }
        }
    }

    Scope (_SB)
    {
    }

    OperationRegion (CMS, SystemIO, 0x70, 0x02)
    Field (CMS, ByteAcc, NoLock, Preserve)
    {
        CMSI,   8, 
        CMSD,   8
    }

    OperationRegion (SMIR, SystemIO, 0xB2, 0x02)
    Field (SMIR, ByteAcc, NoLock, Preserve)
    {
        SMIC,   8, 
        SMID,   8
    }

    OperationRegion (STON, SystemIO, 0x84, One)
    Field (STON, ByteAcc, NoLock, Preserve)
    {
        MGIC,   8
    }

    OperationRegion (SIO, SystemIO, 0x2E, 0x02)
    Field (SIO, ByteAcc, NoLock, Preserve)
    {
        SIOI,   8, 
        SIOD,   8
    }

    OperationRegion (PM1R, SystemIO, 0x0800, 0x04)
    Field (PM1R, ByteAcc, NoLock, Preserve)
    {
        PMS1,   8, 
        PMS2,   8, 
        PME1,   8, 
        PME2,   8
    }

    OperationRegion (GPST, SystemIO, 0x0820, One)
    Field (GPST, ByteAcc, NoLock, Preserve)
    {
        GST0,   8
    }

    OperationRegion (GLBC, SystemIO, 0x0828, 0x06)
    Field (GLBC, ByteAcc, NoLock, Preserve)
    {
        THRP,   8, 
        GLBT,   8, 
        EOS,    8, 
        LIDP,   8, 
        THME,   8, 
        RIEN,   8
    }

    OperationRegion (GPEC, SystemIO, 0x0842, One)
    Field (GPEC, ByteAcc, NoLock, Preserve)
    {
        THPL,   1, 
        SWGP,   1, 
        Offset (0x01)
    }

    OperationRegion (PMES, SystemIO, 0x0C00, One)
    Field (PMES, ByteAcc, NoLock, Preserve)
    {
        GSTS,   8
    }

    Mutex (SMIM, 0x01)
    Mutex (SMIX, 0x01)
    Name (SXX0, Buffer (0x0100) {})
    Name (SXX1, Buffer (0x08) {})
    CreateWordField (SXX1, Zero, SXX2)
    CreateWordField (SXX1, 0x04, SXX3)
    Method (SMI, 2, NotSerialized)
    {
        Acquire (SMIM, 0xFFFF)
        Store (Arg1, SMID)
        Store (Arg0, SMIC)
        Store (MGIC, Local0)
        Store (SMID, Local1)
        Release (SMIM)
        Return (Local1)
    }

    Method (SMI1, 1, NotSerialized)
    {
        Acquire (SMIM, 0xFFFF)
        Store (Arg0, SMIC)
        Store (MGIC, Local0)
        Store (SMID, Local0)
        Release (SMIM)
        Return (Local0)
    }

    Method (SMI2, 1, NotSerialized)
    {
        Acquire (SMIM, 0xFFFF)
        Store (Arg0, SMIC)
        Store (MGIC, Local0)
        Store (SMIC, Local1)
        Store (SMID, Local0)
        ShiftLeft (Local0, 0x08, Local0)
        Add (Local1, Local0, Local0)
        Release (SMIM)
        Return (Local0)
    }

    Method (SMI4, 1, NotSerialized)
    {
        Add (Arg0, One, Local0)
        Store (SMI2 (Arg0), Local2)
        Store (SMI2 (Local0), Local1)
        ShiftLeft (Local1, 0x10, Local1)
        Add (Local1, Local2, Local0)
        Return (Local0)
    }

    Method (GTMR, 0, NotSerialized)
    {
        Return (SMI4 (0x78))
    }

    Method (GTML, 0, NotSerialized)
    {
        Return (SMI4 (0x74))
    }

    Method (GTMH, 0, NotSerialized)
    {
        Return (SMI4 (0x76))
    }

    Method (GTOM, 0, NotSerialized)
    {
        Return (SMI4 (0x81))
    }

    Method (GUSB, 0, NotSerialized)
    {
        If (ISLI ())
        {
            Return (Zero)
        }
        Else
        {
            Return (SMI2 (0xBA))
        }
    }

    Method (GTPM, 0, NotSerialized)
    {
        Return (SMI (0x9B, Zero))
    }

    Method (SX10, 0, NotSerialized)
    {
        Acquire (SMIX, 0xFFFF)
        Store (Zero, SXX2)
    }

    Method (SX30, 1, NotSerialized)
    {
        Store (SXX2, Local0)
        Increment (Local0)
        If (LLessEqual (Local0, SizeOf (SXX0)))
        {
            CreateByteField (SXX0, SXX2, SX20)
            Store (Arg0, SX20)
            Store (Local0, SXX2)
        }
    }

    Method (SX33, 2, NotSerialized)
    {
        If (LLess (Arg1, SizeOf (Arg0)))
        {
            CreateByteField (Arg0, Arg1, SX20)
            SX30 (SX20)
        }
    }

    Method (SX34, 2, NotSerialized)
    {
        Store (Zero, Local0)
        While (LLess (Local0, Arg1))
        {
            SX33 (Arg0, Local0)
            Increment (Local0)
        }
    }

    Method (SXX6, 2, NotSerialized)
    {
        Store (Arg1, SMID)
        Store (Arg0, SMIC)
        Store (SMIC, Local0)
        While (LNotEqual (Local0, Zero))
        {
            Store (SMIC, Local0)
        }

        Return (SMID)
    }

    Method (SXX5, 2, NotSerialized)
    {
        If (LLess (Arg1, SizeOf (Arg0)))
        {
            CreateByteField (Arg0, Arg1, SX20)
            SXX6 (0x98, SX20)
        }
    }

    Method (SXX4, 0, NotSerialized)
    {
        SXX6 (0x96, Zero)
        Store (Zero, Local0)
        While (LLess (Local0, SXX2))
        {
            SXX5 (SXX0, Local0)
            Increment (Local0)
        }
    }

    Method (SXX8, 2, NotSerialized)
    {
        If (LLess (Arg1, SizeOf (Arg0)))
        {
            CreateByteField (Arg0, Arg1, SX20)
            Store (SXX6 (0x97, Zero), SX20)
        }
    }

    Method (SXX7, 0, NotSerialized)
    {
        Store (Zero, Local0)
        While (LLess (Local0, SXX3))
        {
            Add (SXX2, Local0, Local1)
            SXX8 (SXX0, Local1)
            Increment (Local0)
        }
    }

    Method (SX11, 0, NotSerialized)
    {
        SXX4 ()
        Store (SXX6 (0x99, Zero), SXX3)
        Add (SXX2, SXX3, Local0)
        If (LLess (SizeOf (SXX0), Local0))
        {
            Store (SizeOf (SXX0), Local0)
            Subtract (Local0, SXX2, Local0)
            Store (Local0, SXX3)
        }

        SXX7 ()
    }

    Method (SX40, 0, NotSerialized)
    {
        Store (SXX2, Local0)
        Increment (Local0)
        If (LLessEqual (Local0, SizeOf (SXX0)))
        {
            CreateByteField (SXX0, SXX2, SX20)
            Store (Local0, SXX2)
            Return (SX20)
        }

        Return (Zero)
    }

    Method (SX41, 0, NotSerialized)
    {
        Store (SXX2, Local0)
        Add (Local0, 0x02, Local0)
        If (LLessEqual (Local0, SizeOf (SXX0)))
        {
            CreateWordField (SXX0, SXX2, SX21)
            Store (Local0, SXX2)
            Return (SX21)
        }

        Return (Zero)
    }

    Method (SX42, 0, NotSerialized)
    {
        Store (SXX2, Local0)
        Add (Local0, 0x04, Local0)
        If (LLessEqual (Local0, SizeOf (SXX0)))
        {
            CreateDWordField (SXX0, SXX2, SX22)
            Store (Local0, SXX2)
            Return (SX22)
        }

        Return (Zero)
    }

    Method (SX43, 2, NotSerialized)
    {
        If (LLess (Arg1, SizeOf (Arg0)))
        {
            CreateByteField (Arg0, Arg1, SX20)
            Store (SX40 (), SX20)
        }
    }

    Method (SX44, 2, NotSerialized)
    {
        Store (Zero, Local0)
        While (LLess (Local0, Arg1))
        {
            SX43 (Arg0, Local0)
            Increment (Local0)
        }
    }

    Method (SX12, 0, NotSerialized)
    {
        Release (SMIX)
    }

    Method (GMI0, 0, NotSerialized)
    {
        Store (SMI2 (0xD4), Local0)
        ShiftLeft (Local0, 0x10, Local0)
        Return (Local0)
    }

    Method (GMX0, 0, NotSerialized)
    {
        Store (SMI2 (0xD5), Local0)
        ShiftLeft (Local0, 0x10, Local0)
        If (LNotEqual (Local0, Zero))
        {
            Or (Local0, 0xFFFF, Local0)
        }

        Return (Local0)
    }

    Method (GMI1, 0, NotSerialized)
    {
        Store (SMI2 (0xD0), Local0)
        ShiftLeft (Local0, 0x10, Local0)
        Return (Local0)
    }

    Method (GMX1, 0, NotSerialized)
    {
        Store (SMI2 (0xD1), Local0)
        ShiftLeft (Local0, 0x10, Local0)
        If (LNotEqual (Local0, Zero))
        {
            Or (Local0, 0xFFFF, Local0)
        }

        Return (Local0)
    }

    Method (GIB0, 0, NotSerialized)
    {
        Store (SMI2 (0xD6), Local0)
        And (Local0, 0xFFFF, Local0)
        Return (Local0)
    }

    Method (GIX0, 0, NotSerialized)
    {
        Store (SMI2 (0xD7), Local0)
        And (Local0, 0xFFFF, Local0)
        Return (Local0)
    }

    Method (GIB1, 0, NotSerialized)
    {
        Store (SMI2 (0xD2), Local0)
        And (Local0, 0xFFFF, Local0)
        Return (Local0)
    }

    Method (GIX1, 0, NotSerialized)
    {
        Store (SMI2 (0xD3), Local0)
        And (Local0, 0xFFFF, Local0)
        Return (Local0)
    }

    Scope (_SB)
    {
        Device (AMW0)
        {
            Mutex (WMIX, 0x01)
            Name (_HID, "*pnp0c14")  // _HID: Hardware ID
            Name (_UID, Zero)  // _UID: Unique ID
            Method (STBY, 3, NotSerialized)
            {
                CreateByteField (Arg0, Arg1, TMP)
                Store (Arg2, TMP)
            }

            Method (STWD, 3, NotSerialized)
            {
                CreateWordField (Arg0, Arg1, TMP)
                Store (Arg2, TMP)
            }

            Method (STDW, 3, NotSerialized)
            {
                CreateDWordField (Arg0, Arg1, TMP)
                Store (Arg2, TMP)
            }

            Method (CLBY, 1, NotSerialized)
            {
                Store (Zero, Local0)
                While (LLess (Local0, SizeOf (Arg0)))
                {
                    STBY (Arg0, Local0, Zero)
                    Increment (Local0)
                }
            }

            Name (_WDG, Buffer (0x64)
            {
                /* 0000 */  0xBC, 0xDC, 0x9D, 0x8D, 0x97, 0xA9, 0xDA, 0x11,
                /* 0008 */  0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92,
                /* 0010 */  0x41, 0x41, 0x01, 0x00, 0xCE, 0x93, 0x05, 0xA8,
                /* 0018 */  0x97, 0xA9, 0xDA, 0x11, 0xB0, 0x12, 0xB6, 0x22,
                /* 0020 */  0xA1, 0xEF, 0x54, 0x92, 0x42, 0x41, 0x01, 0x02,
                /* 0028 */  0x94, 0x59, 0xBB, 0x9D, 0x97, 0xA9, 0xDA, 0x11,
                /* 0030 */  0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92,
                /* 0038 */  0xD0, 0x00, 0x01, 0x08, 0xE0, 0x6C, 0x77, 0xA3,
                /* 0040 */  0x88, 0x1E, 0xDB, 0x11, 0xA9, 0x8B, 0x08, 0x00,
                /* 0048 */  0x20, 0x0C, 0x9A, 0x66, 0x42, 0x43, 0x01, 0x00,
                /* 0050 */  0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11,
                /* 0058 */  0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10,
                /* 0060 */  0x4D, 0x4F, 0x01, 0x00                         
            })
            Name (INFO, Buffer (0x80) {})
            Name (ECD0, Zero)
            Method (WED0, 1, NotSerialized)
            {
                Store (Arg0, ECD0)
                Return (Zero)
            }

            Method (WCAA, 1, NotSerialized)
            {
                Return (Zero)
            }

            Method (WQAA, 1, NotSerialized)
            {
                Acquire (WMIX, 0xFFFF)
                CLBY (INFO)
                If (LNotEqual (Arg0, Zero))
                {
                    Store (INFO, Local1)
                }
                Else
                {
                    STDW (INFO, Zero, 0x4C4C4544)
                    STDW (INFO, 0x04, 0x494D5720)
                    STDW (INFO, 0x08, One)
                    STDW (INFO, 0x0C, 0x1000)
                    Store (INFO, Local1)
                }

                Release (WMIX)
                Return (Local1)
            }

            Method (WSAA, 2, NotSerialized)
            {
                Return (Arg1)
            }

            Method (WMBA, 3, NotSerialized)
            {
                CreateDWordField (Arg2, 0x28, WBUF)
                Add (WBUF, 0x2C, Local1)
                If (LLessEqual (Local1, 0x1000))
                {
                    Store (WMI (Arg2, Local1), Local0)
                }

                Return (Local0)
            }

            Name (WMI2, Buffer (0x80) {})
            Name (WMI3, Zero)
            Method (WMI6, 0, NotSerialized)
            {
                Acquire (WMIX, 0xFFFF)
                Store (Zero, WMI3)
                CLBY (WMI2)
            }

            Method (WMI7, 0, NotSerialized)
            {
                Acquire (WMIX, 0xFFFF)
                Store (Zero, WMI3)
            }

            Method (WMI8, 1, NotSerialized)
            {
                Store (WMI3, Local0)
                Add (Local0, 0x02, Local0)
                If (LLessEqual (Local0, SizeOf (WMI2)))
                {
                    CreateWordField (WMI2, WMI3, WMI9)
                    Store (Arg0, WMI9)
                    Store (Local0, WMI3)
                }
            }

            Method (_WED, 1, NotSerialized)  // _Wxx: Wake Event
            {
                WMI6 ()
                If (LOr (LNotEqual (Arg0, 0xD0), LEqual (ECD0, Zero)))
                {
                    WMI7 ()
                    Return (WMI2)
                }
                Else
                {
                    SX10 ()
                    SX30 (One)
                    SX11 ()
                    Store (SX41 (), Local0)
                    While (LGreater (Local0, Zero))
                    {
                        WMI8 (Local0)
                        While (LGreater (Local0, Zero))
                        {
                            WMI8 (SX41 ())
                            Subtract (Local0, One, Local0)
                        }

                        Store (SX41 (), Local0)
                    }

                    WMI8 (Zero)
                    SX12 ()
                }

                WMI7 ()
                Return (WMI2)
            }

            Name (WQMO, Buffer (0x056F)
            {
                /* 0000 */  0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00,
                /* 0008 */  0x5F, 0x05, 0x00, 0x00, 0x88, 0x1C, 0x00, 0x00,
                /* 0010 */  0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54,
                /* 0018 */  0x18, 0xD5, 0x8D, 0x00, 0x01, 0x06, 0x18, 0x42,
                /* 0020 */  0x10, 0x0F, 0x10, 0x22, 0x21, 0x04, 0x12, 0x01,
                /* 0028 */  0xA1, 0xC8, 0x2C, 0x0C, 0x86, 0x10, 0x38, 0x2E,
                /* 0030 */  0x84, 0x1C, 0x40, 0x48, 0x1C, 0x14, 0x4A, 0x08,
                /* 0038 */  0x84, 0xFA, 0x13, 0xC8, 0xAF, 0x00, 0x84, 0x0E,
                /* 0040 */  0x05, 0xC8, 0x14, 0x60, 0x50, 0x80, 0x53, 0x04,
                /* 0048 */  0x11, 0xF4, 0x2A, 0xC0, 0xA6, 0x00, 0x93, 0x02,
                /* 0050 */  0x2C, 0x0A, 0xD0, 0x2E, 0xC0, 0xB2, 0x00, 0xDD,
                /* 0058 */  0x02, 0xA4, 0xC3, 0x12, 0x91, 0xE0, 0x28, 0x31,
                /* 0060 */  0xE0, 0x28, 0x9D, 0xD8, 0xC2, 0x0D, 0x1B, 0xBC,
                /* 0068 */  0x50, 0x14, 0xCD, 0x20, 0x4A, 0x82, 0xCA, 0x05,
                /* 0070 */  0xF8, 0x46, 0x10, 0x78, 0xB9, 0x02, 0x24, 0x4F,
                /* 0078 */  0x40, 0x9A, 0x05, 0x18, 0x16, 0x60, 0x5D, 0x80,
                /* 0080 */  0xEC, 0x21, 0x50, 0xA9, 0x43, 0x40, 0xC9, 0x19,
                /* 0088 */  0x02, 0x6A, 0x00, 0xAD, 0x4E, 0x40, 0xF8, 0x95,
                /* 0090 */  0x4E, 0x09, 0x49, 0x10, 0xCE, 0x58, 0xC5, 0xE3,
                /* 0098 */  0x6B, 0x16, 0x4D, 0xCF, 0x49, 0xCE, 0x31, 0xE4,
                /* 00A0 */  0x78, 0x5C, 0xE8, 0x41, 0xF0, 0x40, 0x0A, 0x40,
                /* 00A8 */  0x58, 0x78, 0x08, 0x45, 0x80, 0x41, 0x49, 0x18,
                /* 00B0 */  0x0B, 0x75, 0x31, 0x6A, 0xD4, 0x48, 0xD9, 0x80,
                /* 00B8 */  0x0C, 0x51, 0xDA, 0xA8, 0xD1, 0x03, 0x3A, 0xBF,
                /* 00C0 */  0x23, 0x39, 0xBB, 0xA3, 0x3B, 0x92, 0x04, 0x46,
                /* 00C8 */  0x3D, 0xA6, 0x63, 0x2C, 0x6C, 0x46, 0x42, 0x8D,
                /* 00D0 */  0xD1, 0x1C, 0x14, 0x81, 0xC6, 0x0D, 0xDA, 0x12,
                /* 00D8 */  0x61, 0x35, 0xAE, 0xD8, 0x67, 0x66, 0xE1, 0xC3,
                /* 00E0 */  0x12, 0xC6, 0x11, 0x1C, 0x58, 0x82, 0x46, 0xD1,
                /* 00E8 */  0x34, 0xC7, 0xB3, 0x0D, 0x91, 0xE0, 0x20, 0x42,
                /* 00F0 */  0x63, 0x64, 0x40, 0xC8, 0xF3, 0xB0, 0x05, 0x7A,
                /* 00F8 */  0xE4, 0x09, 0xEC, 0x1E, 0x51, 0x0A, 0x11, 0x34,
                /* 0100 */  0xDF, 0x13, 0xA9, 0x51, 0x80, 0x36, 0x0C, 0xD9,
                /* 0108 */  0x3A, 0x1B, 0x68, 0xA8, 0xB1, 0x1A, 0x43, 0x11,
                /* 0110 */  0x44, 0x84, 0xA0, 0x51, 0x0C, 0x16, 0x21, 0x54,
                /* 0118 */  0x88, 0xFF, 0x7F, 0x94, 0xA8, 0xA7, 0x14, 0x24,
                /* 0120 */  0x6A, 0x65, 0x20, 0x42, 0x0B, 0x66, 0x04, 0x66,
                /* 0128 */  0x7F, 0x10, 0x24, 0xC6, 0x99, 0x41, 0x87, 0x05,
                /* 0130 */  0xCB, 0x00, 0x91, 0x11, 0x41, 0xA3, 0x61, 0x67,
                /* 0138 */  0x01, 0x0F, 0xC7, 0x33, 0x69, 0x7E, 0x62, 0x1A,
                /* 0140 */  0x9C, 0x09, 0xC6, 0x86, 0x90, 0x06, 0x08, 0x89,
                /* 0148 */  0x3A, 0x38, 0x50, 0x02, 0x4B, 0x19, 0x38, 0xB1,
                /* 0150 */  0x3D, 0x2E, 0x8D, 0xEF, 0x8C, 0xA3, 0x86, 0x38,
                /* 0158 */  0xF5, 0x33, 0xF3, 0x3F, 0xC2, 0x5B, 0xF0, 0x11,
                /* 0160 */  0x80, 0x8F, 0xC1, 0x83, 0x3D, 0x84, 0x80, 0x47,
                /* 0168 */  0xC8, 0xCE, 0x00, 0x06, 0xC4, 0x7B, 0x9F, 0x34,
                /* 0170 */  0x99, 0x8B, 0xCF, 0x02, 0x30, 0x86, 0x0F, 0xD7,
                /* 0178 */  0xF8, 0x28, 0x34, 0x1E, 0x76, 0x3E, 0x60, 0xE3,
                /* 0180 */  0xE2, 0xF0, 0x3E, 0x14, 0x9C, 0x70, 0xB1, 0x20,
                /* 0188 */  0x0A, 0x00, 0x21, 0x59, 0xE7, 0x03, 0xF4, 0xAC,
                /* 0190 */  0x8F, 0x2D, 0xE0, 0xC3, 0x40, 0xB3, 0x77, 0x08,
                /* 0198 */  0x42, 0xF0, 0x22, 0xE0, 0xA3, 0x83, 0x8F, 0x1B,
                /* 01A0 */  0x1E, 0xF7, 0xF3, 0x06, 0x18, 0x0E, 0x07, 0x1E,
                /* 01A8 */  0x8E, 0x4F, 0x1B, 0xC0, 0x65, 0x04, 0x5C, 0xDA,
                /* 01B0 */  0x93, 0xC2, 0x04, 0x92, 0xFC, 0x04, 0x90, 0x18,
                /* 01B8 */  0x18, 0xD4, 0x81, 0xC0, 0x07, 0x0B, 0xB8, 0x92,
                /* 01C0 */  0xE0, 0x50, 0xC3, 0xF3, 0xC4, 0x1E, 0x10, 0xFE,
                /* 01C8 */  0xFF, 0x47, 0x79, 0x22, 0x2F, 0x06, 0x9E, 0xFE,
                /* 01D0 */  0x63, 0x00, 0x8C, 0x03, 0x82, 0xA7, 0x75, 0x52,
                /* 01D8 */  0xBE, 0x79, 0x3C, 0x48, 0x78, 0x50, 0x61, 0x12,
                /* 01E0 */  0xF8, 0x94, 0xC0, 0xD0, 0xF8, 0x71, 0x03, 0xAC,
                /* 01E8 */  0xA3, 0xC6, 0x1F, 0x10, 0xE0, 0x9D, 0x24, 0xCE,
                /* 01F0 */  0xAF, 0xCF, 0x01, 0xE8, 0xD0, 0x70, 0x8A, 0x0C,
                /* 01F8 */  0xE4, 0x35, 0xE0, 0xA4, 0x4F, 0xC9, 0xE3, 0x4B,
                /* 0200 */  0xE0, 0x33, 0x07, 0xEC, 0xBB, 0xC1, 0x61, 0x1C,
                /* 0208 */  0x4C, 0x88, 0x08, 0xEF, 0x01, 0x4F, 0x1D, 0xBE,
                /* 0210 */  0x6B, 0x3C, 0x0A, 0x04, 0x8A, 0xD0, 0xDB, 0x99,
                /* 0218 */  0x83, 0x9E, 0x42, 0x8C, 0x12, 0xED, 0xAC, 0xC2,
                /* 0220 */  0x3C, 0x70, 0x44, 0xF1, 0x91, 0xC3, 0x08, 0xEF,
                /* 0228 */  0x1E, 0xBE, 0x13, 0x3C, 0x80, 0xB4, 0x36, 0x39,
                /* 0230 */  0xE1, 0x06, 0x7A, 0xE6, 0x60, 0xD1, 0xCE, 0x2C,
                /* 0238 */  0xB2, 0x00, 0xA2, 0x48, 0xA3, 0x41, 0x9D, 0x11,
                /* 0240 */  0x7C, 0x1A, 0xF0, 0xB4, 0x9E, 0x62, 0x7C, 0x94,
                /* 0248 */  0x30, 0xC8, 0x19, 0x1E, 0xD8, 0x73, 0xC2, 0x63,
                /* 0250 */  0x80, 0x07, 0xCC, 0xEE, 0x07, 0x3E, 0x4E, 0xF8,
                /* 0258 */  0x5C, 0x80, 0x77, 0x0D, 0xA8, 0x19, 0xFA, 0xB0,
                /* 0260 */  0x01, 0xE7, 0xD0, 0x81, 0x3F, 0x4D, 0xE0, 0x0F,
                /* 0268 */  0x16, 0xF8, 0xF1, 0xF8, 0x9A, 0xC3, 0x26, 0x9C,
                /* 0270 */  0xC0, 0xF2, 0x07, 0x81, 0x1A, 0x99, 0xA1, 0x3D,
                /* 0278 */  0xCB, 0xD3, 0x7A, 0x0D, 0xF0, 0x69, 0xC7, 0x04,
                /* 0280 */  0x3E, 0x6F, 0xF8, 0xFF, 0xFF, 0xCF, 0xF1, 0x78,
                /* 0288 */  0xC0, 0xAF, 0xF8, 0x74, 0x41, 0xEE, 0x0A, 0x9E,
                /* 0290 */  0xAF, 0xCF, 0x2E, 0xCC, 0xC6, 0x78, 0x50, 0xA3,
                /* 0298 */  0xF0, 0x01, 0x07, 0x77, 0x76, 0xF1, 0x11, 0xC0,
                /* 02A0 */  0x67, 0x17, 0xE0, 0x39, 0x89, 0x67, 0x09, 0xF0,
                /* 02A8 */  0x1E, 0x02, 0x7C, 0x22, 0x89, 0xF7, 0xB0, 0x05,
                /* 02B0 */  0x63, 0xC4, 0x78, 0xC8, 0x33, 0xAE, 0x7A, 0x18,
                /* 02B8 */  0xBA, 0x08, 0x58, 0xDD, 0x7D, 0x05, 0x75, 0xF4,
                /* 02C0 */  0x02, 0x13, 0xD4, 0x6B, 0x06, 0xEE, 0xF4, 0x02,
                /* 02C8 */  0x7C, 0x4E, 0x59, 0xF0, 0xFE, 0xFF, 0xA7, 0x2C,
                /* 02D0 */  0xE0, 0x7E, 0x55, 0xE0, 0x47, 0x14, 0x30, 0x40,
                /* 02D8 */  0x76, 0x76, 0x3A, 0x11, 0xC2, 0x7B, 0xC9, 0x73,
                /* 02E0 */  0x88, 0x6F, 0x57, 0x3E, 0x98, 0x04, 0x79, 0x0E,
                /* 02E8 */  0x88, 0xF0, 0x94, 0xC5, 0xEF, 0x03, 0x51, 0x62,
                /* 02F0 */  0x1E, 0x50, 0xA4, 0x28, 0x46, 0x0C, 0xF2, 0x84,
                /* 02F8 */  0xE5, 0xEB, 0x49, 0x0C, 0x43, 0x07, 0x0B, 0x17,
                /* 0300 */  0x3E, 0xC2, 0x53, 0x16, 0x60, 0xF1, 0x92, 0x85,
                /* 0308 */  0x39, 0x65, 0xC1, 0x7C, 0x1B, 0xF8, 0x94, 0x05,
                /* 0310 */  0x8E, 0xFF, 0xFF, 0x29, 0x0B, 0x5C, 0xE3, 0x7E,
                /* 0318 */  0xCA, 0x02, 0x66, 0xD2, 0x9F, 0x02, 0x3E, 0xD5,
                /* 0320 */  0xF8, 0x09, 0xA0, 0xE8, 0x07, 0x0B, 0x0A, 0xE3,
                /* 0328 */  0x53, 0x16, 0xE0, 0x4A, 0xDE, 0x01, 0x01, 0x34,
                /* 0330 */  0x67, 0x27, 0xDF, 0x16, 0x0C, 0x76, 0xCC, 0xBE,
                /* 0338 */  0x64, 0xF8, 0x94, 0x08, 0x86, 0x43, 0x86, 0xEF,
                /* 0340 */  0x54, 0x87, 0xF2, 0xC8, 0xF1, 0x14, 0xE0, 0x23,
                /* 0348 */  0x16, 0xD8, 0xE3, 0x1C, 0x03, 0x74, 0x5C, 0xF1,
                /* 0350 */  0x11, 0xCB, 0xFF, 0xFF, 0x23, 0x16, 0xC0, 0x8D,
                /* 0358 */  0x03, 0x08, 0xFE, 0xD4, 0x01, 0xEB, 0x1E, 0x10,
                /* 0360 */  0xD6, 0x87, 0x0E, 0xE0, 0x21, 0xFB, 0x21, 0xA0,
                /* 0368 */  0x33, 0x8C, 0x25, 0x83, 0xC8, 0xC6, 0xB9, 0x86,
                /* 0370 */  0x8E, 0xD1, 0xE2, 0x17, 0xAA, 0x9B, 0x42, 0xEC,
                /* 0378 */  0x83, 0xE1, 0xB2, 0x81, 0x04, 0xEA, 0xE1, 0x5A,
                /* 0380 */  0x30, 0x85, 0x44, 0xD1, 0x68, 0x34, 0x06, 0x26,
                /* 0388 */  0x30, 0x82, 0x33, 0x88, 0x01, 0x9D, 0x11, 0x42,
                /* 0390 */  0x87, 0x32, 0x9C, 0x8A, 0xF3, 0x10, 0xEA, 0xFF,
                /* 0398 */  0x4F, 0x30, 0xD4, 0x8D, 0x89, 0xCE, 0xCE, 0xF3,
                /* 03A0 */  0xE7, 0xB7, 0x11, 0x9F, 0x08, 0x0C, 0xEC, 0x2B,
                /* 03A8 */  0xC4, 0x5B, 0x06, 0x58, 0x86, 0xE5, 0xC5, 0x3D,
                /* 03B0 */  0x01, 0x1C, 0xE3, 0x49, 0x26, 0xA8, 0xE6, 0x58,
                /* 03B8 */  0x83, 0x9A, 0x83, 0xAF, 0x02, 0x6F, 0x64, 0x26,
                /* 03C0 */  0xF0, 0x15, 0x0C, 0x6C, 0xA7, 0x19, 0x8C, 0xBE,
                /* 03C8 */  0x3B, 0x01, 0x28, 0x80, 0x7C, 0x14, 0xF0, 0x7D,
                /* 03D0 */  0xF9, 0x6D, 0x80, 0xCD, 0xE2, 0x95, 0xD9, 0x68,
                /* 03D8 */  0x3E, 0x7F, 0x22, 0x86, 0x8E, 0x12, 0x33, 0x74,
                /* 03E0 */  0x0A, 0xE2, 0xA1, 0x3B, 0xE8, 0xD0, 0xD1, 0xC7,
                /* 03E8 */  0x01, 0x9F, 0xAC, 0x70, 0xC1, 0x0E, 0x5F, 0xD0,
                /* 03F0 */  0x26, 0x77, 0xB4, 0x27, 0xE6, 0x59, 0x78, 0x9E,
                /* 03F8 */  0xB8, 0xB9, 0x83, 0xE9, 0x88, 0x04, 0x63, 0xF0,
                /* 0400 */  0x98, 0xC9, 0x83, 0x59, 0xE0, 0xE4, 0x41, 0xF1,
                /* 0408 */  0xFF, 0x9F, 0x3C, 0x4C, 0x78, 0x4C, 0xD8, 0xC3,
                /* 0410 */  0x21, 0x3D, 0x74, 0x78, 0x64, 0x7C, 0x9C, 0x3E,
                /* 0418 */  0xFD, 0x30, 0xEC, 0xD3, 0x39, 0x97, 0xA2, 0x67,
                /* 0420 */  0xA4, 0x3B, 0xC6, 0x33, 0x17, 0x06, 0xD6, 0x23,
                /* 0428 */  0xE7, 0xB0, 0x46, 0x0B, 0x7B, 0xC0, 0xCF, 0x21,
                /* 0430 */  0xBE, 0xC3, 0xF8, 0xC0, 0xC3, 0x60, 0x7D, 0x7A,
                /* 0438 */  0x01, 0xC7, 0xF1, 0x0B, 0xFE, 0x69, 0x00, 0x3C,
                /* 0440 */  0x07, 0x10, 0x8F, 0xE1, 0x05, 0x84, 0x1F, 0x5F,
                /* 0448 */  0x74, 0xFE, 0xA5, 0x42, 0x17, 0x27, 0x79, 0x30,
                /* 0450 */  0xA8, 0xD3, 0x14, 0xE0, 0xEA, 0xF4, 0x06, 0x9E,
                /* 0458 */  0xAB, 0x3E, 0xEE, 0x2C, 0x85, 0xFB, 0xFF, 0x9F,
                /* 0460 */  0xA5, 0x60, 0x1C, 0x7E, 0x7D, 0x81, 0xF7, 0x5D,
                /* 0468 */  0xCA, 0x08, 0x07, 0xF2, 0x2C, 0x05, 0xF6, 0xD8,
                /* 0470 */  0xCF, 0x10, 0x1D, 0x02, 0x7C, 0x96, 0x02, 0xF8,
                /* 0478 */  0xF1, 0xFA, 0xF0, 0x79, 0x06, 0x6E, 0xE0, 0xD3,
                /* 0480 */  0x2F, 0xD0, 0xFA, 0xFF, 0x9F, 0x42, 0xC0, 0x7F,
                /* 0488 */  0x8C, 0xF0, 0x11, 0x07, 0x77, 0xF4, 0x05, 0x6E,
                /* 0490 */  0x07, 0x63, 0x7E, 0xC6, 0xC0, 0x1D, 0xC7, 0x80,
                /* 0498 */  0xC7, 0xC9, 0x19, 0x77, 0x9A, 0xF0, 0x10, 0xF8,
                /* 04A0 */  0x00, 0x5A, 0x9D, 0x1E, 0x39, 0xF5, 0x9C, 0x12,
                /* 04A8 */  0xEE, 0x38, 0xC0, 0xA7, 0x84, 0x1B, 0x00, 0x26,
                /* 04B0 */  0xC0, 0x19, 0x13, 0x50, 0xF5, 0xFF, 0x3F, 0x63,
                /* 04B8 */  0x02, 0x63, 0x90, 0x08, 0xEF, 0x0A, 0x51, 0xDF,
                /* 04C0 */  0x91, 0x0D, 0xF1, 0x8C, 0xCC, 0x70, 0xDE, 0x1A,
                /* 04C8 */  0x1E, 0x5F, 0x9E, 0x91, 0xC1, 0x79, 0xC6, 0x04,
                /* 04D0 */  0xF8, 0xF3, 0xFF, 0x3F, 0xD2, 0x63, 0x6F, 0x0A,
                /* 04D8 */  0xC1, 0x9F, 0x42, 0x80, 0x89, 0xF8, 0x33, 0x26,
                /* 04E0 */  0x15, 0x7E, 0xC6, 0x84, 0x36, 0x17, 0x4F, 0xDB,
                /* 04E8 */  0x67, 0x4C, 0x80, 0x7B, 0xFF, 0xFF, 0x33, 0x26,
                /* 04F0 */  0xE0, 0x3B, 0xF2, 0x19, 0x13, 0xD0, 0x73, 0xA4,
                /* 04F8 */  0xC2, 0x9D, 0x31, 0xC1, 0x30, 0xCE, 0xF7, 0x27,
                /* 0500 */  0x83, 0x3C, 0x8F, 0xF8, 0x40, 0xE0, 0xA3, 0x0C,
                /* 0508 */  0x53, 0x68, 0xD3, 0xA7, 0x46, 0xA3, 0x56, 0x0D,
                /* 0510 */  0xCA, 0xD4, 0x28, 0xD3, 0xA0, 0x56, 0x9F, 0x4A,
                /* 0518 */  0x8D, 0x19, 0x3B, 0x3A, 0x59, 0xC4, 0x5A, 0x35,
                /* 0520 */  0x58, 0x87, 0x5A, 0xAF, 0x40, 0x2C, 0xE9, 0x89,
                /* 0528 */  0x21, 0x10, 0xFF, 0xFF, 0x45, 0x79, 0x00, 0x61,
                /* 0530 */  0x71, 0x4D, 0x80, 0x30, 0xE1, 0xAB, 0x12, 0x88,
                /* 0538 */  0x63, 0x83, 0x50, 0xB1, 0x3A, 0x20, 0x1A, 0x19,
                /* 0540 */  0xA2, 0x41, 0x04, 0xE4, 0x10, 0x3E, 0x80, 0x58,
                /* 0548 */  0x24, 0x10, 0x81, 0x13, 0x25, 0xA0, 0xD4, 0x09,
                /* 0550 */  0x08, 0x13, 0xBA, 0x16, 0x81, 0x58, 0x9E, 0x17,
                /* 0558 */  0x10, 0x16, 0x0E, 0x84, 0x4A, 0x32, 0x03, 0xCE,
                /* 0560 */  0xF4, 0x81, 0x08, 0xC8, 0x52, 0x5F, 0x21, 0x02,
                /* 0568 */  0xB2, 0x70, 0x10, 0x01, 0xF9, 0xFF, 0x0F       
            })
        }
    }

    Mutex (WMIS, 0x01)
    Name (WM00, Zero)
    Method (WM02, 0, NotSerialized)
    {
        SX10 ()
        SX30 (Zero)
        SX11 ()
        Store (SX42 (), WM00)
        SX12 ()
    }

    Method (WM03, 3, NotSerialized)
    {
        OperationRegion (WWPR, SystemMemory, Arg0, One)
        Field (WWPR, ByteAcc, Lock, Preserve)
        {
            MEMW,   8
        }

        CreateByteField (Arg1, Arg2, WVAL)
        Store (WVAL, MEMW)
    }

    Method (WM05, 3, NotSerialized)
    {
        OperationRegion (WWPR, SystemMemory, Arg0, 0x04)
        Field (WWPR, ByteAcc, Lock, Preserve)
        {
            MW32,   32
        }

        CreateDWordField (Arg1, Arg2, WVAL)
        Store (WVAL, MW32)
    }

    Method (WM04, 3, NotSerialized)
    {
        OperationRegion (WRPR, SystemMemory, Arg0, One)
        Field (WRPR, ByteAcc, Lock, Preserve)
        {
            MEMR,   8
        }

        CreateByteField (Arg1, Arg2, WVAL)
        Store (MEMR, WVAL)
        Store (Zero, MEMR)
    }

    Method (WM06, 3, NotSerialized)
    {
        OperationRegion (WRPR, SystemMemory, Arg0, 0x04)
        Field (WRPR, ByteAcc, Lock, Preserve)
        {
            MR32,   32
        }

        CreateDWordField (Arg1, Arg2, WVAL)
        Store (MR32, WVAL)
        Store (Zero, MR32)
    }

    Method (WM07, 2, NotSerialized)
    {
        If (LLessEqual (Arg1, 0x0100))
        {
            Store (WM00, Local0)
            Store (Zero, Local1)
            While (LLess (Local1, Arg1))
            {
                WM05 (Local0, Arg0, Local1)
                Add (Local0, 0x04, Local0)
                Add (Local1, 0x04, Local1)
            }

            SXX6 (0x9A, Zero)
            Store (WM00, Local0)
            Store (Zero, Local1)
            While (LLess (Local1, Arg1))
            {
                WM06 (Local0, Arg0, Local1)
                Add (Local0, 0x04, Local0)
                Add (Local1, 0x04, Local1)
            }
        }

        Return (Arg0)
    }

    Method (WMI, 2, NotSerialized)
    {
        Acquire (WMIS, 0xFFFF)
        If (LEqual (WM00, Zero))
        {
            WM02 ()
        }

        WM07 (Arg0, Arg1)
        Release (WMIS)
        Return (Arg0)
    }

    Scope (_PR)
    {
        Processor (CPU1, 0x01, 0x00000810, 0x06) {}
        Processor (CPU2, 0x02, 0x00000000, 0x00) {}
        Processor (CPU3, 0x03, 0x00000000, 0x00) {}
        Processor (CPU4, 0x04, 0x00000000, 0x00) {}
        Processor (CPU5, 0x05, 0x00000000, 0x00) {}
        Processor (CPU6, 0x06, 0x00000000, 0x00) {}
        Processor (CPU7, 0x07, 0x00000000, 0x00) {}
        Processor (CPU8, 0x08, 0x00000000, 0x00) {}
        Processor (CPU9, 0x09, 0x00000000, 0x00) {}
        Processor (CP10, 0x0A, 0x00000000, 0x00) {}
        Processor (CP11, 0x0B, 0x00000000, 0x00) {}
        Processor (CP12, 0x0C, 0x00000000, 0x00) {}
        Processor (CP13, 0x0D, 0x00000000, 0x00) {}
        Processor (CP14, 0x0E, 0x00000000, 0x00) {}
        Processor (CP15, 0x0F, 0x00000000, 0x00) {}
        Processor (CP16, 0x10, 0x00000000, 0x00) {}
        Processor (CP17, 0x11, 0x00000000, 0x00) {}
        Processor (CP18, 0x12, 0x00000000, 0x00) {}
        Processor (CP19, 0x13, 0x00000000, 0x00) {}
        Processor (CP20, 0x14, 0x00000000, 0x00) {}
        Processor (CP21, 0x15, 0x00000000, 0x00) {}
        Processor (CP22, 0x16, 0x00000000, 0x00) {}
        Processor (CP23, 0x17, 0x00000000, 0x00) {}
        Processor (CP24, 0x18, 0x00000000, 0x00) {}
        Processor (CP25, 0x19, 0x00000000, 0x00) {}
        Processor (CP26, 0x1A, 0x00000000, 0x00) {}
        Processor (CP27, 0x1B, 0x00000000, 0x00) {}
        Processor (CP28, 0x1C, 0x00000000, 0x00) {}
        Processor (CP29, 0x1D, 0x00000000, 0x00) {}
        Processor (CP30, 0x1E, 0x00000000, 0x00) {}
        Processor (CP31, 0x1F, 0x00000000, 0x00) {}
        Processor (CP32, 0x20, 0x00000000, 0x00) {}
    }

    Scope (\)
    {
        Name (SSTX, Zero)
        Method (_PTS, 1, NotSerialized)  // _PTS: Prepare To Sleep
        {
            If (LEqual (Arg0, 0x05)) {}
            Else
            {
                PSKM (Arg0)
            }
        }
    }

    Method (_GPE._L02, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
    {
        Notify (\_SB.AMW0, 0xD0)
        Store (GST0, Local0)
        And (Local0, 0x04, Local0)
        Store (Local0, GST0)
    }

    Method (_GPE._L08, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
    {
        GPKM ()
        If (Not (LEqual (SSTX, One)))
        {
            Notify (\_SB.VBTN, 0x02)
        }

        Notify (\_SB.PCI0.ISA.KBD, 0x02)
    }

    Method (_GPE._L1B, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
    {
        XOr (LIDP, 0x08, LIDP)
        Or (PME2, One, PME2)
        Notify (\_SB.PCI0.PCI5, 0x02)
    }

    Method (_GPE._L1C, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
    {
        XOr (LIDP, 0x08, LIDP)
        Or (PME2, One, PME2)
        If (LEqual (\_SB.PCI0.PCI2.XME2 (), One))
        {
            Notify (\_SB.PCI0.PCI2, 0x02)
        }
        ElseIf (LEqual (\_SB.PCI0.PCI3.XME3 (), One))
        {
            Notify (\_SB.PCI0.PCI3, 0x02)
        }
    }

    Method (_GPE._L1D, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
    {
        XOr (LIDP, 0x20, LIDP)
    }

    Method (_GPE._L1F, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
    {
        XOr (LIDP, 0x08, LIDP)
        Or (PME2, One, PME2)
        If (LEqual (\_SB.PCI0.PCI4.XME4 (), One))
        {
            Notify (\_SB.PCI0.PCI4, 0x02)
        }
    }

    Method (_WAK, 1, NotSerialized)  // _WAK: Wake
    {
        If (LEqual (Arg0, 0x04))
        {
            GUSB ()
        }
        ElseIf (LEqual (Arg0, 0x03))
        {
            If (And (0x20, CMRD (0x49)))
            {
                GUSB ()
            }
        }

        CMWR (0x49, And (0xDF, CMRD (0x49)))
        If (Or (And (PMS2, One), Or (And (LNot (HACK ()), And (GLBT, 0x11)), And (LNot (HACK ()), And (THRP, 0x18)))))
        {
            Notify (\_SB.VBTN, 0x02)
        }

        Return (Zero)
    }

    Scope (_SI)
    {
        Method (_SST, 1, NotSerialized)  // _SST: System Status
        {
            Store (Arg0, SSTX)
            If (LEqual (Arg0, 0x03))
            {
                And (LED2, 0xFD, LED2)
            }

            If (LEqual (Arg0, One))
            {
                Or (LED2, 0x02, LED2)
            }
        }
    }

    Scope (_SB)
    {
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))  // _HID: Hardware ID
            Name (_UID, 0x00)  // _UID: Unique ID
            Name (_BBN, Zero)  // _BBN: BIOS Bus Number
            Name (_ADR, Zero)  // _ADR: Address
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                0x0D, 
                0x05
            })
            Method (_S1D, 0, NotSerialized)  // _S1D: S1 Device State
            {
                Return (One)
            }

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

            Name (PIC0, Package (0x40)
            {
                Package (0x04)
                {
                    0xFFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0003FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0003FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0003FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0003FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

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

                Package (0x04)
                {
                    0x0004FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

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

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

                Package (0x04)
                {
                    0x0005FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

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

                Package (0x04)
                {
                    0x0007FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

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

                Package (0x04)
                {
                    0x0009FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

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

                Package (0x04)
                {
                    0x000AFFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x02, 
                    LNKG, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    0x02, 
                    LNKG, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001BFFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    Zero, 
                    LNKA, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    Zero, 
                    LNKH, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x02, 
                    LNKC, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x03, 
                    LNKD, 
                    Zero
                }, 

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

                Package (0x04)
                {
                    0x001FFFFF, 
                    One, 
                    LNKB, 
                    Zero
                }, 

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x02, 
                    LNKE, 
                    Zero
                }
            })
            Name (API0, Package (0x40)
            {
                Package (0x04)
                {
                    0xFFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0xFFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

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

                Package (0x04)
                {
                    0x0001FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

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

                Package (0x04)
                {
                    0x0002FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

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

                Package (0x04)
                {
                    0x0003FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

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

                Package (0x04)
                {
                    0x0004FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

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

                Package (0x04)
                {
                    0x0005FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

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

                Package (0x04)
                {
                    0x0006FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

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

                Package (0x04)
                {
                    0x0007FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

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

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

                Package (0x04)
                {
                    0x0008FFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0016FFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    0x02, 
                    Zero, 
                    0x16
                }, 

                Package (0x04)
                {
                    0x001AFFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x001BFFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    Zero, 
                    Zero, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x001CFFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    Zero, 
                    Zero, 
                    0x17
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x02, 
                    Zero, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x03, 
                    Zero, 
                    0x13
                }, 

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

                Package (0x04)
                {
                    0x001FFFFF, 
                    One, 
                    Zero, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x02, 
                    Zero, 
                    0x14
                }
            })
            Device (PCI1)
            {
                Method (_S1D, 0, NotSerialized)  // _S1D: S1 Device State
                {
                    Return (One)
                }

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

                Method (_S4D, 0, NotSerialized)  // _S4D: S4 Device State
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_S5D, 0, NotSerialized)
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_ADR, 0, NotSerialized)  // _ADR: Address
                {
                    Store (0x00010000, Local0)
                    Return (Local0)
                }

                Name (_UID, 0x20)  // _UID: Unique ID
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x1C, 
                    0x05
                })
                OperationRegion (RSTS, PCI_Config, 0xB0, 0x04)
                Field (RSTS, ByteAcc, NoLock, Preserve)
                {
                    PID0,   8, 
                    PID1,   8, 
                    PMXS,   8, 
                    PNUS,   8
                }

                Method (XME1, 0, NotSerialized)
                {
                    Store (PMXS, Local0)
                    And (Local0, One, Local0)
                    Store (Local0, PMXS)
                    Return (Local0)
                }

                Name (PIC1, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKD, 
                        Zero
                    }
                })
                Name (API1, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x1C
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x28
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        Zero, 
                        0x29
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x2F
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    Store (API1, Local0)
                    If (LNot (PICF))
                    {
                        Store (PIC1, Local0)
                    }

                    Return (Local0)
                }
            }

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

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

                Method (_S4D, 0, NotSerialized)  // _S4D: S4 Device State
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_S5D, 0, NotSerialized)
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_ADR, 0, NotSerialized)  // _ADR: Address
                {
                    Store (0x00030000, Local0)
                    Return (Local0)
                }

                Name (_UID, 0x21)  // _UID: Unique ID
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x1C, 
                    0x05
                })
                OperationRegion (RSTS, PCI_Config, 0xB0, 0x04)
                Field (RSTS, ByteAcc, NoLock, Preserve)
                {
                    PID0,   8, 
                    PID1,   8, 
                    PMXS,   8, 
                    PNUS,   8
                }

                Method (XME2, 0, NotSerialized)
                {
                    Store (PMXS, Local0)
                    And (Local0, One, Local0)
                    Store (Local0, PMXS)
                    Return (Local0)
                }

                Name (PIC2, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKD, 
                        Zero
                    }
                })
                Name (API2, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x18
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x22
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        Zero, 
                        0x23
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x24
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    Store (API2, Local0)
                    If (LNot (PICF))
                    {
                        Store (PIC2, Local0)
                    }

                    Return (Local0)
                }
            }

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

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

                Method (_S4D, 0, NotSerialized)  // _S4D: S4 Device State
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_S5D, 0, NotSerialized)
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_ADR, 0, NotSerialized)  // _ADR: Address
                {
                    Store (0x00070000, Local0)
                    Return (Local0)
                }

                Name (_UID, 0x22)  // _UID: Unique ID
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x1C, 
                    0x05
                })
                OperationRegion (RSTS, PCI_Config, 0xB0, 0x04)
                Field (RSTS, ByteAcc, NoLock, Preserve)
                {
                    PID0,   8, 
                    PID1,   8, 
                    PMXS,   8, 
                    PNUS,   8
                }

                Method (XME3, 0, NotSerialized)
                {
                    Store (PMXS, Local0)
                    And (Local0, One, Local0)
                    Store (Local0, PMXS)
                    If (Local0)
                    {
                        Return (One)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Name (PIC3, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKD, 
                        Zero
                    }
                })
                Name (API3, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x1E
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x25
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        Zero, 
                        0x27
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x26
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    Store (API3, Local0)
                    If (LNot (PICF))
                    {
                        Store (PIC3, Local0)
                    }

                    Return (Local0)
                }
            }

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

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

                Method (_S4D, 0, NotSerialized)  // _S4D: S4 Device State
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_S5D, 0, NotSerialized)
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_ADR, 0, NotSerialized)  // _ADR: Address
                {
                    Store (0x001C0000, Local0)
                    Return (Local0)
                }

                Name (_UID, 0x23)  // _UID: Unique ID
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x1F, 
                    0x05
                })
                OperationRegion (RSTS, PCI_Config, 0x60, 0x04)
                Field (RSTS, ByteAcc, NoLock, Preserve)
                {
                    PID0,   8, 
                    PID1,   8, 
                    PMXS,   8, 
                    PNUS,   8
                }

                Method (XME4, 0, NotSerialized)
                {
                    Store (PMXS, Local0)
                    And (Local0, One, Local0)
                    Store (Local0, PMXS)
                    If (Local0)
                    {
                        Return (One)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Name (PIC4, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        LNKB, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x02, 
                        LNKC, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        LNKD, 
                        Zero
                    }
                })
                Name (API4, Package (0x04)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x10
                    }, 

                    Package (0x04)
                    {
                        0xFFFF, 
                        One, 
                        Zero, 
                        0x11
                    }, 

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

                    Package (0x04)
                    {
                        0xFFFF, 
                        0x03, 
                        Zero, 
                        0x13
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    Store (API4, Local0)
                    If (LNot (PICF))
                    {
                        Store (PIC4, Local0)
                    }

                    Return (Local0)
                }
            }

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

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

                Method (_S4D, 0, NotSerialized)  // _S4D: S4 Device State
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_S5D, 0, NotSerialized)
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_ADR, 0, NotSerialized)  // _ADR: Address
                {
                    Store (0x001C0005, Local0)
                    Return (Local0)
                }

                Name (_UID, 0x24)  // _UID: Unique ID
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x1B, 
                    0x05
                })
                OperationRegion (RSTS, PCI_Config, 0x60, 0x04)
                Field (RSTS, ByteAcc, NoLock, Preserve)
                {
                    PID0,   8, 
                    PID1,   8, 
                    PMXS,   8, 
                    PNUS,   8
                }

                Method (XME5, 0, NotSerialized)
                {
                    Store (PMXS, Local0)
                    And (Local0, One, Local0)
                    Store (Local0, PMXS)
                    If (Local0)
                    {
                        Return (One)
                    }
                    Else
                    {
                        Return (Zero)
                    }
                }

                Name (PIC5, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        LNKB, 
                        Zero
                    }
                })
                Name (API5, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF, 
                        Zero, 
                        Zero, 
                        0x11
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    Store (API5, Local0)
                    If (LNot (PICF))
                    {
                        Store (PIC5, Local0)
                    }

                    Return (Local0)
                }
            }

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

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

                Method (_S4D, 0, NotSerialized)  // _S4D: S4 Device State
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_S5D, 0, NotSerialized)
                {
                    If (HACK ())
                    {
                        Return (0x03)
                    }
                    Else
                    {
                        Return (0x02)
                    }
                }

                Method (_ADR, 0, NotSerialized)  // _ADR: Address
                {
                    Store (0x001E0000, Local0)
                    Return (Local0)
                }

                Name (_UID, 0x25)  // _UID: Unique ID
                Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
                {
                    0x0B, 
                    0x05
                })
                Name (PIC6, Package (0x08)
                {
                    Package (0x04)
                    {
                        0x0004FFFF, 
                        Zero, 
                        LNKA, 
                        Zero
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        One, 
                        LNKB, 
                        Zero
                    }, 

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

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

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        One, 
                        LNKC, 
                        Zero
                    }, 

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x03, 
                        LNKA, 
                        Zero
                    }
                })
                Name (API6, Package (0x08)
                {
                    Package (0x04)
                    {
                        0x0004FFFF, 
                        Zero, 
                        Zero, 
                        0x10
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        One, 
                        Zero, 
                        0x11
                    }, 

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

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        Zero, 
                        Zero, 
                        0x11
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        One, 
                        Zero, 
                        0x12
                    }, 

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

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x03, 
                        Zero, 
                        0x10
                    }
                })
                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    Store (API6, Local0)
                    If (LNot (PICF))
                    {
                        Store (PIC6, Local0)
                    }

                    Return (Local0)
                }
            }

            Device (HDM0)
            {
                Name (_ADR, 0x00030000)  // _ADR: Address
                Device (HDAU)
                {
                    Name (_ADR, One)  // _ADR: Address
                    Method (_DSM, 4, NotSerialized)  // _DSM: Device-Specific Method
                    {
                        Store (Package (0x06)
                            {
                                "hda-gfx", 
                                Buffer (0x0A)
                                {
                                    "onboard-1"
                                }, 

                                "layout-id", 
                                Buffer (0x04)
                                {
                                     0x01, 0x00, 0x00, 0x00                         
                                }, 

                                "PinConfigurations", 
                                Buffer (0x04)
                                {
                                     0xE0, 0x00, 0x56, 0x28                         
                                }
                            }, Local0)
                        DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                        Return (Local0)
                    }
                }
            }
        }
    }

    Scope (\)
    {
        Method (_GPE._L03, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            If (Not (LEqual (SSTX, One)))
            {
                Notify (\_SB.VBTN, 0x02)
            }

            Sleep (0x14)
            XOr (THRP, 0x08, THRP)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0.USB0, 0x02)
        }

        Method (_GPE._L04, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            If (Not (LEqual (SSTX, One)))
            {
                Notify (\_SB.VBTN, 0x02)
            }

            Sleep (0x14)
            XOr (THRP, 0x10, THRP)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0.USB1, 0x02)
        }

        Method (_GPE._L0C, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            If (Not (LEqual (SSTX, One)))
            {
                Notify (\_SB.VBTN, 0x02)
            }

            Sleep (0x14)
            XOr (GLBT, 0x10, GLBT)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0.USB2, 0x02)
        }

        Method (_GPE._L0E, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            If (Not (LEqual (SSTX, One)))
            {
                Notify (\_SB.VBTN, 0x02)
            }

            Sleep (0x14)
            XOr (GLBT, 0x40, GLBT)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0.USB3, 0x02)
        }

        Method (_GPE._L05, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            If (Not (LEqual (SSTX, One)))
            {
                Notify (\_SB.VBTN, 0x02)
            }

            Sleep (0x14)
            XOr (THRP, 0x20, THRP)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0.USB4, 0x02)
        }

        Method (_GPE._L20, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            If (Not (LEqual (SSTX, One)))
            {
                Notify (\_SB.VBTN, 0x02)
            }

            Sleep (0x14)
            XOr (THRP, 0x20, THRP)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0.USB5, 0x02)
        }

        Method (_GPE._L0D, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            Sleep (0x14)
            XOr (GLBT, 0x20, GLBT)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0, 0x02)
        }

        Method (_GPE._L0B, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
        {
            XOr (GLBT, 0x08, GLBT)
            Or (PME2, One, PME2)
            Notify (\_SB.PCI0.PCI6, 0x02)
        }
    }

    Scope (_SB.PCI0)
    {
        Device (ISA)
        {
            Name (_ADR, 0x001F0000)  // _ADR: Address
            Name (_UID, 0x0A)  // _UID: Unique ID
            OperationRegion (P40C, PCI_Config, 0x60, 0x04)
            OperationRegion (P41C, PCI_Config, 0x68, 0x04)
            Device (MBIO)
            {
                Name (_HID, EisaId ("PNP0C01"))  // _HID: Hardware ID
                Name (_UID, 0x0B)  // _UID: Unique ID
                Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                {
                    Name (MIO1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0062,             // Range Minimum
                            0x0062,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0065,             // Range Minimum
                            0x0065,             // Range Maximum
                            0x01,               // Alignment
                            0x0B,               // Length
                            )
                        IO (Decode16,
                            0x00E0,             // Range Minimum
                            0x00E0,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0800,             // Range Minimum
                            0x0800,             // Range Maximum
                            0x01,               // Alignment
                            0x60,               // Length
                            )
                        IO (Decode16,
                            0x0C00,             // Range Minimum
                            0x0C00,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x0860,             // Range Minimum
                            0x0860,             // Range Maximum
                            0x01,               // Alignment
                            0xA0,               // Length
                            )
                    })
                    Name (MIO2, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Range Minimum
                            0x0060,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0064,             // Range Minimum
                            0x0064,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0062,             // Range Minimum
                            0x0062,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0065,             // Range Minimum
                            0x0065,             // Range Maximum
                            0x01,               // Alignment
                            0x0B,               // Length
                            )
                        IO (Decode16,
                            0x00E0,             // Range Minimum
                            0x00E0,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0800,             // Range Minimum
                            0x0800,             // Range Maximum
                            0x01,               // Alignment
                            0x60,               // Length
                            )
                        IO (Decode16,
                            0x0C00,             // Range Minimum
                            0x0C00,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x0860,             // Range Minimum
                            0x0860,             // Range Maximum
                            0x01,               // Alignment
                            0xA0,               // Length
                            )
                    })
                    If (Or (GCKB (), GCMS ()))
                    {
                        Return (MIO1)
                    }
                    Else
                    {
                        Return (MIO2)
                    }
                }
            }
        }
    }

    Scope (_SB.PCI0)
    {
        Device (USB0)
        {
            Name (_ADR, 0x001D0000)  // _ADR: Address
            Name (_UID, 0x05)  // _UID: Unique ID
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                0x03, 
                0x03
            })
            OperationRegion (UPC1, PCI_Config, 0xC1, One)
            Field (UPC1, ByteAcc, NoLock, Preserve)
            {
                LEGK,   8
            }

            Method (_INI, 0, NotSerialized)  // _INI: Initialize
            {
                If (HACK ()) {}
                Else
                {
                    Store (LEGK, Local0)
                    And (Local0, 0x60, Local0)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LEGK)
                }

                GUSB ()
            }

            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (GCUC ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

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

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

        Device (USB1)
        {
            Name (_ADR, 0x001D0001)  // _ADR: Address
            Name (_UID, 0x06)  // _UID: Unique ID
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                0x04, 
                0x03
            })
            OperationRegion (UPC1, PCI_Config, 0xC1, One)
            Field (UPC1, ByteAcc, NoLock, Preserve)
            {
                LEGK,   8
            }

            Method (_INI, 0, NotSerialized)  // _INI: Initialize
            {
                If (HACK ()) {}
                Else
                {
                    Store (LEGK, Local0)
                    And (Local0, 0x60, Local0)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LEGK)
                }
            }

            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (GCUC ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

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

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

        Device (USB2)
        {
            Name (_ADR, 0x001D0002)  // _ADR: Address
            Name (_UID, 0x14)  // _UID: Unique ID
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                0x0C, 
                0x03
            })
            OperationRegion (UPC1, PCI_Config, 0xC1, One)
            Field (UPC1, ByteAcc, NoLock, Preserve)
            {
                LEGK,   8
            }

            Method (_INI, 0, NotSerialized)  // _INI: Initialize
            {
                If (HACK ()) {}
                Else
                {
                    Store (LEGK, Local0)
                    And (Local0, 0x60, Local0)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LEGK)
                }
            }

            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (GCUC ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

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

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

        Device (USB3)
        {
            Name (_ADR, 0x001A0000)  // _ADR: Address
            Name (_UID, 0x15)  // _UID: Unique ID
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                0x0E, 
                0x03
            })
            OperationRegion (UPC1, PCI_Config, 0xC1, One)
            Field (UPC1, ByteAcc, NoLock, Preserve)
            {
                LEGK,   8
            }

            Method (_INI, 0, NotSerialized)  // _INI: Initialize
            {
                If (HACK ()) {}
                Else
                {
                    Store (LEGK, Local0)
                    And (Local0, 0x60, Local0)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LEGK)
                }
            }

            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (GCUC ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

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

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

        Device (USB4)
        {
            Name (_ADR, 0x001A0001)  // _ADR: Address
            Name (_UID, 0x16)  // _UID: Unique ID
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                0x05, 
                0x03
            })
            OperationRegion (UPC1, PCI_Config, 0xC1, One)
            Field (UPC1, ByteAcc, NoLock, Preserve)
            {
                LEGK,   8
            }

            Method (_INI, 0, NotSerialized)  // _INI: Initialize
            {
                If (HACK ()) {}
                Else
                {
                    Store (LEGK, Local0)
                    And (Local0, 0x60, Local0)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LEGK)
                }
            }

            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (GCUC ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

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

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

        Device (USB5)
        {
            Name (_ADR, 0x001A0002)  // _ADR: Address
            Name (_UID, 0x1A)  // _UID: Unique ID
            Name (_PRW, Package (0x02)  // _PRW: Power Resources for Wake
            {
                0x20, 
                0x03
            })
            OperationRegion (UPC1, PCI_Config, 0xC1, One)
            Field (UPC1, ByteAcc, NoLock, Preserve)
            {
                LEGK,   8
            }

            Method (_INI, 0, NotSerialized)  // _INI: Initialize
            {
                If (HACK ()) {}
                Else
                {
                    Store (LEGK, Local0)
                    And (Local0, 0x60, Local0)
                    Or (Local0, 0x20, Local0)
                    Store (Local0, LEGK)
                }
            }

            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (GCUC ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

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

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

    Scope (\)
    {
        Name (PICF, Zero)
        Method (_PIC, 1, NotSerialized)  // _PIC: Interrupt Model
        {
            Store (Arg0, PICF)
        }
    }

    Scope (_SB.PCI0)
    {
        Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
        {
            Store (API0, Local0)
            If (LNot (PICF))
            {
                Store (PIC0, Local0)
            }

            Return (Local0)
        }

        Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
        {
            OperationRegion (ORMF, SystemMemory, 0x000FFF6C, 0x04)
            Field (ORMF, WordAcc, NoLock, Preserve)
            {
                ORGP,   16, 
                ORND,   16
            }

            Name (MEMP, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x00FF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0100,             // Length
                    ,, )
                IO (Decode16,
                    0x0CF8,             // Range Minimum
                    0x0CF8,             // Range Maximum
                    0x01,               // Alignment
                    0x08,               // Length
                    )
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x0CF7,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0CF8,             // Length
                    ,, , TypeStatic, DenseTranslation)
                WordIO (ResourceProducer, MinNotFixed, MaxNotFixed, PosDecode, EntireRange,
                    0x0000,             // Granularity
                    0x0D00,             // Range Minimum
                    0xFFFF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0xF300,             // Length
                    ,, , TypeStatic, DenseTranslation)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000A0000,         // Range Minimum
                    0x000BFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00020000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C8000,         // Range Minimum
                    0x000DFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00018000,         // Length
                    ,, _Y00, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E0000,         // Range Minimum
                    0x000FFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00020000,         // Length
                    ,, _Y01, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinNotFixed, MaxNotFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0xF7FFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    ,, _Y02, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinNotFixed, MaxNotFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xFF980000,         // Range Minimum
                    0xFF980FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00001000,         // Length
                    ,, _Y03, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinNotFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xFF97C000,         // Range Minimum
                    0xFF97FFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xFED20000,         // Range Minimum
                    0xFED9FFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00080000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
            })
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y00._MIN, PMIN)  // _MIN: Minimum Base Address
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y00._MAX, PMAX)  // _MAX: Maximum Base Address
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y00._LEN, PLEN)  // _LEN: Length
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y01._MIN, BMIN)  // _MIN: Minimum Base Address
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y01._LEN, BLEN)  // _LEN: Length
            ShiftLeft (ORGP, 0x04, BMIN)
            Subtract (0x00100000, BMIN, BLEN)
            Store (0x000C0000, PMIN)
            Subtract (BMIN, One, PMAX)
            Subtract (BMIN, PMIN, PLEN)
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y02._MIN, MEMM)  // _MIN: Minimum Base Address
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y02._MAX, MEMA)  // _MAX: Maximum Base Address
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y02._LEN, MEML)  // _LEN: Length
            Store (GTOM (), MEMM)
            Subtract (MEMA, MEMM, MEML)
            Increment (MEML)
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y03._MIN, UMIN)  // _MIN: Minimum Base Address
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y03._MAX, UMAX)  // _MAX: Maximum Base Address
            CreateDWordField (MEMP, \_SB.PCI0._CRS._Y03._LEN, ULEN)  // _LEN: Length
            If (GCUC ()) {}
            Else
            {
                Store (Zero, UMIN)
                Store (Zero, UMAX)
                Store (Zero, ULEN)
            }

            Return (MEMP)
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        Device (DMA)
        {
            Name (_HID, EisaId ("PNP0200"))  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (DMAB, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0080,             // Range Minimum
                        0x0080,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                    IO (Decode16,
                        0x00C0,             // Range Minimum
                        0x00C0,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                    DMA (Compatibility, NotBusMaster, Transfer16, )
                        {4}
                })
                Return (DMAB)
            }
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        Device (FPU)
        {
            Name (_HID, EisaId ("PNP0C04"))  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (FPUB, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x00F0,             // Range Minimum
                        0x00F0,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IRQNoFlags ()
                        {13}
                })
                Return (FPUB)
            }
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        Device (PIC)
        {
            Name (_HID, EisaId ("PNP0000"))  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PICB, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0020,             // Range Minimum
                        0x0020,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                    IO (Decode16,
                        0x00A0,             // Range Minimum
                        0x00A0,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                    IO (Decode16,
                        0x04D0,             // Range Minimum
                        0x04D0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IRQNoFlags ()
                        {2}
                })
                Return (PICB)
            }
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        Device (SPK)
        {
            Name (_HID, EisaId ("PNP0800"))  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (SPKB, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0061,             // Range Minimum
                        0x0061,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                })
                Return (SPKB)
            }
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        Device (RTC)
        {
            Name (_HID, EisaId ("PNP0B00"))  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (RTCB, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IRQNoFlags ()
                        {8}
                })
                Return (RTCB)
            }
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        Device (TMR)
        {
            Name (_HID, EisaId ("PNP0100"))  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (TMRB, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                    IRQNoFlags ()
                        {0}
                })
                Return (TMRB)
            }
        }
    }

    Scope (_SB)
    {
        Field (PCI0.ISA.P40C, ByteAcc, NoLock, Preserve)
        {
            PRQ0,   8, 
            PRQ1,   8, 
            PRQ2,   8, 
            PRQ3,   8
        }

        Field (PCI0.ISA.P41C, ByteAcc, NoLock, Preserve)
        {
            PRQ4,   8, 
            PRQ5,   8, 
            PRQ6,   8, 
            PRQ7,   8
        }

        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x0C)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ0, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ0, 0x80, PRQ0)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR0, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR0, One, IQR)
                Store (PRQ0, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR0)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ0)
            }
        }

        Device (LNKB)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x0D)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ1, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ1, 0x80, PRQ1)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR1, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR1, One, IQR)
                Store (PRQ1, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR1)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ1)
            }
        }

        Device (LNKC)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x0E)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ2, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ2, 0x80, PRQ2)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR2, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR2, One, IQR)
                Store (PRQ2, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR2)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ2)
            }
        }

        Device (LNKD)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x0F)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ3, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ3, 0x80, PRQ3)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR3, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR3, One, IQR)
                Store (PRQ3, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR3)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ3)
            }
        }

        Device (LNKE)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x10)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ4, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ4, 0x80, PRQ4)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR4, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR4, One, IQR)
                Store (PRQ4, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR4)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ4)
            }
        }

        Device (LNKF)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x11)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ5, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ5, 0x80, PRQ5)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR5, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR5, One, IQR)
                Store (PRQ5, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR5)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ5)
            }
        }

        Device (LNKG)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x12)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ6, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ6, 0x80, PRQ6)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR6, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR6, One, IQR)
                Store (PRQ6, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR6)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ6)
            }
        }

        Device (LNKH)
        {
            Name (_HID, EisaId ("PNP0C0F"))  // _HID: Hardware ID
            Name (_UID, 0x13)  // _UID: Unique ID
            Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
            {
                IRQ (Level, ActiveLow, Shared, )
                    {3,4,5,6,7,9,10,11,12,15}
            })
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Store (0x0B, Local0)
                If (And (0x80, PRQ7, Local1))
                {
                    Store (0x09, Local0)
                }

                Return (Local0)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Or (PRQ7, 0x80, PRQ7)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PRR7, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared, )
                        {4}
                })
                CreateWordField (PRR7, One, IQR)
                Store (PRQ7, Local0)
                If (LGreaterEqual (Local0, 0x80))
                {
                    Store (Zero, IQR)
                }
                Else
                {
                    ShiftLeft (One, Local0, IQR)
                }

                Return (PRR7)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, One, IQR)
                FindSetRightBit (IQR, Local0)
                Decrement (Local0)
                Store (Local0, PRQ7)
            }
        }
    }

    Scope (_SB)
    {
        Device (HPET)
        {
            Name (_HID, EisaId ("PNP0103"))  // _HID: Hardware ID
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (HBAB, ResourceTemplate ()
                {
                    Memory32Fixed (ReadOnly,
                        0xFED00000,         // Address Base
                        0x00000400,         // Address Length
                        )
                })
                Return (HBAB)
            }
        }
    }

    Scope (\)
    {
        OperationRegion (WENX, SystemIO, 0x0C0A, 0x06)
        Field (WENX, ByteAcc, NoLock, Preserve)
        {
            WEN1,   8, 
            WEN2,   8, 
            WEN3,   8, 
            WEN4,   8, 
            WEN5,   8, 
            WEN6,   8
        }

        OperationRegion (WSTX, SystemIO, 0x0C00, 0x0A)
        Field (WSTX, ByteAcc, NoLock, Preserve)
        {
            WST0,   8, 
            PMEJ,   8, 
            PENA,   8, 
            PENJ,   8, 
            WST1,   8, 
            WST2,   8, 
            WST3,   8, 
            WST4,   8, 
            WST5,   8, 
            WST6,   8
        }

        OperationRegion (SGPX, SystemIO, 0x0C4B, 0x06)
        Field (SGPX, ByteAcc, NoLock, Preserve)
        {
            SGP1,   8, 
            SGP2,   8, 
            SGP3,   8, 
            SGP4,   8, 
            SGP5,   8, 
            SGP6,   8
        }

        OperationRegion (LEDX, SystemIO, 0x0C5D, 0x02)
        Field (LEDX, ByteAcc, NoLock, Preserve)
        {
            LED1,   8, 
            LED2,   8
        }

        Method (PSKM, 1, NotSerialized)
        {
            If (Or (LEqual (Arg0, 0x03), LEqual (Arg0, One)))
            {
                Store (0x55, SIOI)
                Store (0x07, SIOI)
                Store (0x07, SIOD)
                Store (0xF0, SIOI)
                Store (SIOD, Local0)
                Or (Local0, 0x60, SIOD)
                Store (0xAA, SIOI)
                Store (WST1, Local0)
                And (Local0, 0x18, WST1)
                Store (GSTS, Local0)
                And (Local0, One, GSTS)
                Store (WEN1, Local0)
                Or (Local0, 0x18, WEN1)
            }
        }

        Method (GPKM, 0, NotSerialized)
        {
            Store (WEN1, Local0)
            And (Local0, 0xE7, WEN1)
            Store (WST1, Local0)
            And (Local0, 0x18, WST1)
            Store (GSTS, Local0)
            And (Local0, One, GSTS)
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        OperationRegion (NSIO, SystemIO, 0x2E, 0x02)
        Field (NSIO, ByteAcc, NoLock, Preserve)
        {
            INDX,   8, 
            DATA,   8
        }

        IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
        {
            Offset (0x02), 
            CFG,    8, 
            Offset (0x07), 
            LDN,    8, 
            Offset (0x20), 
            SIID,   8, 
            Offset (0x30), 
            ACTR,   8, 
            Offset (0x60), 
            IOAH,   8, 
            IOAL,   8, 
            Offset (0x70), 
            INTR,   8, 
            Offset (0x74), 
            DMCH,   8, 
            Offset (0xF0), 
            OPT1,   8, 
            OPT2,   8, 
            OPT3,   8
        }

        OperationRegion (COM, PCI_Config, 0x80, One)
        Field (COM, ByteAcc, NoLock, Preserve)
        {
            NSCA,   3, 
                ,   1, 
            NSCB,   3, 
            Offset (0x01)
        }

        OperationRegion (FDPA, PCI_Config, 0x81, One)
        Field (FDPA, ByteAcc, NoLock, Preserve)
        {
            LPTO,   2, 
                ,   2, 
            FDDC,   1, 
            Offset (0x01)
        }

        Mutex (MTX, 0x01)
        Method (SIOD, 1, NotSerialized)
        {
            CSIO (0x55)
            Store (Arg0, LDN)
            CSIO (0xAA)
        }

        Method (CSIO, 1, NotSerialized)
        {
            Store (Arg0, INDX)
        }

        Device (FDC)
        {
            Name (_HID, EisaId ("PNP0700"))  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Name (RET, Zero)
                Acquire (MTX, 0xFFFF)
                SIOD (Zero)
                If (GCFD ())
                {
                    CSIO (0x55)
                    If (ACTR)
                    {
                        CSIO (0xAA)
                        Store (0x0F, RET)
                    }
                    Else
                    {
                        CSIO (0xAA)
                        Store (0x0D, RET)
                    }
                }
                Else
                {
                    CSIO (0xAA)
                    Store (Zero, RET)
                }

                Release (MTX)
                Return (RET)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Acquire (MTX, 0xFFFF)
                SIOD (Zero)
                CSIO (0x55)
                Store (Zero, INTR)
                Store (Zero, ACTR)
                CSIO (0xAA)
                Release (MTX)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (FDB0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x03F0,             // Range Minimum
                        0x03F0,             // Range Maximum
                        0x08,               // Alignment
                        0x06,               // Length
                        _Y04)
                    IO (Decode16,
                        0x03F7,             // Range Minimum
                        0x03F7,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        _Y05)
                    IRQNoFlags (_Y06)
                        {6}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y07)
                        {2}
                })
                CreateByteField (FDB0, \_SB.PCI0.ISA.FDC._CRS._Y04._MIN, IOL0)  // _MIN: Minimum Base Address
                CreateByteField (FDB0, 0x03, IOH0)
                CreateByteField (FDB0, \_SB.PCI0.ISA.FDC._CRS._Y04._MAX, IOL1)  // _MAX: Maximum Base Address
                CreateByteField (FDB0, 0x05, IOH1)
                CreateByteField (FDB0, \_SB.PCI0.ISA.FDC._CRS._Y05._MIN, I2L0)  // _MIN: Minimum Base Address
                CreateByteField (FDB0, 0x0B, I2H0)
                CreateByteField (FDB0, \_SB.PCI0.ISA.FDC._CRS._Y05._MAX, I2L1)  // _MAX: Maximum Base Address
                CreateByteField (FDB0, 0x0D, I2H1)
                CreateWordField (FDB0, \_SB.PCI0.ISA.FDC._CRS._Y06._INT, IQR)  // _INT: Interrupts
                CreateByteField (FDB0, \_SB.PCI0.ISA.FDC._CRS._Y07._DMA, DAM)  // _DMA: Direct Memory Access
                Acquire (MTX, 0xFFFF)
                SIOD (Zero)
                CSIO (0x55)
                Store (IOAH, IOH0)
                Store (IOAH, IOH1)
                Store (IOAL, IOL0)
                Store (IOAL, IOL1)
                Store (IOAH, I2H0)
                Store (IOAH, I2H1)
                Add (IOAL, 0x07, I2L0)
                Add (IOAL, 0x07, I2L1)
                ShiftLeft (One, INTR, IQR)
                ShiftLeft (One, DMCH, DAM)
                CSIO (0xAA)
                Release (MTX)
                Return (FDB0)
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Name (FDB1, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F0,             // Range Minimum
                            0x03F0,             // Range Maximum
                            0x08,               // Alignment
                            0x06,               // Length
                            )
                        IO (Decode16,
                            0x03F7,             // Range Minimum
                            0x03F7,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {6}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {2}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F0,             // Range Minimum
                            0x03F0,             // Range Maximum
                            0x08,               // Alignment
                            0x06,               // Length
                            )
                        IO (Decode16,
                            0x03F7,             // Range Minimum
                            0x03F7,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,6,7,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {1,2,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0370,             // Range Minimum
                            0x0370,             // Range Maximum
                            0x08,               // Alignment
                            0x06,               // Length
                            )
                        IO (Decode16,
                            0x0377,             // Range Minimum
                            0x0377,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,6,7,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {1,2,3}
                    }
                    EndDependentFn ()
                })
                Return (FDB1)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateByteField (Arg0, 0x02, IOLO)
                CreateByteField (Arg0, 0x03, IOHI)
                CreateWordField (Arg0, 0x11, IQR)
                CreateByteField (Arg0, 0x14, DAM)
                Acquire (MTX, 0xFFFF)
                SIOD (Zero)
                CSIO (0x55)
                Store (IOLO, IOAL)
                Store (IOHI, IOAH)
                CSIO (0xAA)
                If (LEqual (IOLO, 0x70))
                {
                    Store (One, FDDC)
                }

                If (LEqual (IOLO, 0xF0))
                {
                    Store (Zero, FDDC)
                }

                CSIO (0x55)
                FindSetRightBit (IQR, Local0)
                Subtract (Local0, One, INTR)
                FindSetRightBit (DAM, Local0)
                Subtract (Local0, One, DMCH)
                Store (One, ACTR)
                CSIO (0xAA)
                Release (MTX)
            }
        }

        Device (KBD)
        {
            Name (_HID, EisaId ("PNP0303"))  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Name (RET, Zero)
                Store (Zero, RET)
                If (GCKB ())
                {
                    Store (0x0F, RET)
                }

                Return (RET)
            }

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

        Device (MOU)
        {
            Name (_HID, EisaId ("PNP0F13"))  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Name (RET, Zero)
                Store (Zero, RET)
                If (GCON ())
                {
                    If (GCMS ())
                    {
                        Store (0x0F, RET)
                    }
                }

                Return (RET)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (MOUB, ResourceTemplate ()
                {
                    IRQNoFlags ()
                        {12}
                })
                Name (MOKB, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0060,             // Range Minimum
                        0x0060,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                    IO (Decode16,
                        0x0064,             // Range Minimum
                        0x0064,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                    IRQNoFlags ()
                        {12}
                })
                If (GCKB ())
                {
                    Return (MOUB)
                }
                Else
                {
                    Return (MOKB)
                }
            }
        }

        Device (PRT)
        {
            Name (_HID, EisaId ("PNP0401"))  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Name (RET, Zero)
                Acquire (MTX, 0xFFFF)
                SIOD (0x03)
                If (GCPP ())
                {
                    CSIO (0x55)
                    If (ACTR)
                    {
                        CSIO (0xAA)
                        Store (0x0F, RET)
                    }
                    Else
                    {
                        CSIO (0xAA)
                        Store (0x0D, RET)
                    }
                }
                Else
                {
                    CSIO (0xAA)
                    Store (Zero, RET)
                }

                Release (MTX)
                Return (RET)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Acquire (MTX, 0xFFFF)
                SIOD (0x03)
                CSIO (0x55)
                Store (Zero, INTR)
                Store (0x04, DMCH)
                Store (Zero, ACTR)
                CSIO (0xAA)
                Release (MTX)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (PTB0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0378,             // Range Minimum
                        0x0378,             // Range Maximum
                        0x08,               // Alignment
                        0x08,               // Length
                        _Y08)
                    IO (Decode16,
                        0x0778,             // Range Minimum
                        0x0778,             // Range Maximum
                        0x08,               // Alignment
                        0x08,               // Length
                        _Y09)
                    IRQNoFlags (_Y0A)
                        {7}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y0B)
                        {}
                })
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y08._MIN, IOL0)  // _MIN: Minimum Base Address
                CreateByteField (PTB0, 0x03, IOH0)
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y08._MAX, IOL1)  // _MAX: Maximum Base Address
                CreateByteField (PTB0, 0x05, IOH1)
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y08._ALN, LALN)  // _ALN: Alignment
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y08._LEN, LLEN)  // _LEN: Length
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y09._MIN, I2L0)  // _MIN: Minimum Base Address
                CreateByteField (PTB0, 0x0B, I2H0)
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y09._MAX, I2L1)  // _MAX: Maximum Base Address
                CreateByteField (PTB0, 0x0D, I2H1)
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y09._ALN, HALN)  // _ALN: Alignment
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y09._LEN, HLEN)  // _LEN: Length
                CreateWordField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y0A._INT, IQR)  // _INT: Interrupts
                CreateByteField (PTB0, \_SB.PCI0.ISA.PRT._CRS._Y0B._DMA, DAM)  // _DMA: Direct Memory Access
                Acquire (MTX, 0xFFFF)
                SIOD (0x03)
                CSIO (0x55)
                Store (IOAH, IOH0)
                Store (IOAH, IOH1)
                Store (IOAL, IOL0)
                Store (IOAL, IOL1)
                Add (IOAH, 0x04, I2H0)
                Add (IOAH, 0x04, I2H1)
                Store (IOAL, I2L0)
                Store (IOAL, I2L1)
                ShiftLeft (One, INTR, IQR)
                ShiftLeft (One, DMCH, DAM)
                If (LEqual (IOL0, 0xBC))
                {
                    Store (0x04, LALN)
                    Store (0x04, LLEN)
                    Store (0x04, HALN)
                    Store (0x04, HLEN)
                }

                If (LEqual (DMCH, 0x04))
                {
                    Store (Zero, DAM)
                }

                If (LEqual (INTR, Zero))
                {
                    Store (Zero, IQR)
                }

                CSIO (0xAA)
                Release (MTX)
                Return (PTB0)
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Name (PTB1, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {7}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {5}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,6,7,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,6,7,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {1,2,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,6,7,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,6,7,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {1,2,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x04,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x07BC,             // Range Minimum
                            0x07BC,             // Range Maximum
                            0x04,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x04,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x07BC,             // Range Minimum
                            0x07BC,             // Range Maximum
                            0x04,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {7}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    }
                    EndDependentFn ()
                })
                Return (PTB1)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateByteField (Arg0, 0x02, IOLO)
                CreateByteField (Arg0, 0x03, IOHI)
                CreateWordField (Arg0, 0x11, IQR)
                CreateByteField (Arg0, 0x14, DAM)
                Acquire (MTX, 0xFFFF)
                SIOD (0x03)
                CSIO (0x55)
                Store (IOLO, IOAL)
                Store (IOHI, IOAH)
                If (LEqual (IOLO, 0xBC))
                {
                    Store (0x02, LPTO)
                }

                If (LEqual (IOLO, 0x78))
                {
                    If (LEqual (IOHI, 0x02))
                    {
                        Store (One, LPTO)
                    }

                    If (LEqual (IOHI, 0x03))
                    {
                        Store (Zero, LPTO)
                    }
                }

                If (LEqual (IQR, Zero))
                {
                    Store (Zero, INTR)
                }
                Else
                {
                    FindSetRightBit (IQR, Local0)
                    Subtract (Local0, One, INTR)
                }

                If (LEqual (DAM, Zero))
                {
                    Store (0x04, DMCH)
                }
                Else
                {
                    FindSetRightBit (DAM, Local0)
                    Subtract (Local0, One, DMCH)
                }

                Store (One, ACTR)
                CSIO (0xAA)
                Release (MTX)
            }
        }

        Device (COMA)
        {
            Name (_HID, EisaId ("PNP0501"))  // _HID: Hardware ID
            Name (_UID, One)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Name (RET, Zero)
                Acquire (MTX, 0xFFFF)
                SIOD (0x04)
                If (GCS1 ())
                {
                    CSIO (0x55)
                    If (ACTR)
                    {
                        CSIO (0xAA)
                        Store (0x0F, RET)
                    }
                    Else
                    {
                        CSIO (0xAA)
                        Store (0x0D, RET)
                    }
                }
                Else
                {
                    CSIO (0xAA)
                    Store (Zero, RET)
                }

                Release (MTX)
                Return (RET)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Acquire (MTX, 0xFFFF)
                SIOD (0x04)
                CSIO (0x55)
                Store (Zero, INTR)
                Store (Zero, ACTR)
                CSIO (0xAA)
                Release (MTX)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (CMA0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x03F8,             // Range Minimum
                        0x03F8,             // Range Maximum
                        0x08,               // Alignment
                        0x08,               // Length
                        _Y0C)
                    IRQNoFlags (_Y0D)
                        {4}
                })
                CreateByteField (CMA0, \_SB.PCI0.ISA.COMA._CRS._Y0C._MIN, IOL0)  // _MIN: Minimum Base Address
                CreateByteField (CMA0, 0x03, IOH0)
                CreateByteField (CMA0, \_SB.PCI0.ISA.COMA._CRS._Y0C._MAX, IOL1)  // _MAX: Maximum Base Address
                CreateByteField (CMA0, 0x05, IOH1)
                CreateWordField (CMA0, \_SB.PCI0.ISA.COMA._CRS._Y0D._INT, IQR)  // _INT: Interrupts
                Acquire (MTX, 0xFFFF)
                SIOD (0x04)
                CSIO (0x55)
                Store (IOAL, IOL0)
                Store (IOAL, IOL1)
                Store (IOAH, IOH0)
                Store (IOAH, IOH1)
                ShiftLeft (One, INTR, IQR)
                CSIO (0xAA)
                Release (MTX)
                Return (CMA0)
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Name (CMA1, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3}
                    }
                    EndDependentFn ()
                })
                Return (CMA1)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateByteField (Arg0, 0x02, IOLO)
                CreateByteField (Arg0, 0x03, IOHI)
                CreateWordField (Arg0, 0x09, IQR)
                Acquire (MTX, 0xFFFF)
                SIOD (0x04)
                CSIO (0x55)
                Store (IOLO, IOAL)
                Store (IOHI, IOAH)
                FindSetRightBit (IQR, Local0)
                Subtract (Local0, One, INTR)
                If (LEqual (IOHI, 0x03))
                {
                    If (LEqual (IOLO, 0xF8))
                    {
                        Store (Zero, NSCA)
                    }

                    If (LEqual (IOLO, 0xE8))
                    {
                        Store (0x07, NSCA)
                    }
                }

                If (LEqual (IOHI, 0x02))
                {
                    If (LEqual (IOLO, 0xF8))
                    {
                        Store (One, NSCA)
                    }

                    If (LEqual (IOLO, 0xE8))
                    {
                        Store (0x05, NSCA)
                    }
                }

                Store (One, ACTR)
                CSIO (0xAA)
                Release (MTX)
            }
        }

        Device (COMB)
        {
            Name (_HID, EisaId ("PNP0501"))  // _HID: Hardware ID
            Name (_UID, 0x02)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Name (RET, Zero)
                Acquire (MTX, 0xFFFF)
                SIOD (0x05)
                If (GCS2 ())
                {
                    CSIO (0x55)
                    If (ACTR)
                    {
                        CSIO (0xAA)
                        Store (0x0F, RET)
                    }
                    Else
                    {
                        CSIO (0xAA)
                        Store (0x0D, RET)
                    }
                }
                Else
                {
                    CSIO (0xAA)
                    Store (Zero, RET)
                }

                Release (MTX)
                Return (RET)
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                Acquire (MTX, 0xFFFF)
                SIOD (0x05)
                CSIO (0x55)
                Store (Zero, INTR)
                Store (OPT1, Local0)
                Or (Local0, 0x20, Local0)
                Store (Local0, OPT1)
                Store (Zero, ACTR)
                CSIO (0xAA)
                Release (MTX)
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Name (CMB0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x03F8,             // Range Minimum
                        0x03F8,             // Range Maximum
                        0x08,               // Alignment
                        0x08,               // Length
                        _Y0E)
                    IRQNoFlags (_Y0F)
                        {4}
                })
                CreateByteField (CMB0, \_SB.PCI0.ISA.COMB._CRS._Y0E._MIN, IOL0)  // _MIN: Minimum Base Address
                CreateByteField (CMB0, 0x03, IOH0)
                CreateByteField (CMB0, \_SB.PCI0.ISA.COMB._CRS._Y0E._MAX, IOL1)  // _MAX: Maximum Base Address
                CreateByteField (CMB0, 0x05, IOH1)
                CreateWordField (CMB0, \_SB.PCI0.ISA.COMB._CRS._Y0F._INT, IQR)  // _INT: Interrupts
                Acquire (MTX, 0xFFFF)
                SIOD (0x05)
                CSIO (0x55)
                Store (IOAL, IOL0)
                Store (IOAL, IOL1)
                Store (IOAH, IOH0)
                Store (IOAH, IOH1)
                ShiftLeft (One, INTR, IQR)
                CSIO (0xAA)
                Release (MTX)
                Return (CMB0)
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Name (CMB1, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {4}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x08,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {4}
                    }
                    EndDependentFn ()
                })
                Return (CMB1)
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateByteField (Arg0, 0x02, IOLO)
                CreateByteField (Arg0, 0x03, IOHI)
                CreateWordField (Arg0, 0x09, IQR)
                Acquire (MTX, 0xFFFF)
                SIOD (0x05)
                CSIO (0x55)
                Store (IOLO, IOAL)
                Store (IOHI, IOAH)
                FindSetRightBit (IQR, Local0)
                Subtract (Local0, One, INTR)
                If (LEqual (IOHI, 0x03))
                {
                    If (LEqual (IOLO, 0xF8))
                    {
                        Store (Zero, NSCB)
                    }

                    If (LEqual (IOLO, 0xE8))
                    {
                        Store (0x07, NSCB)
                    }
                }

                If (LEqual (IOHI, 0x02))
                {
                    If (LEqual (IOLO, 0xF8))
                    {
                        Store (One, NSCB)
                    }

                    If (LEqual (IOLO, 0xE8))
                    {
                        Store (0x05, NSCB)
                    }
                }

                Store (One, ACTR)
                Store (OPT1, Local0)
                And (Local0, 0xDF, Local0)
                Store (Local0, OPT1)
                CSIO (0xAA)
                Release (MTX)
            }
        }
    }

    Scope (_SB.PCI0.ISA)
    {
        Device (TPM)
        {
            Name (_HID, EisaId ("PNP0C31"))  // _HID: Hardware ID
            Name (_CID, EisaId ("PNP0C31"))  // _CID: Compatible ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (GTPM ())
                {
                    Return (Zero)
                }

                If (GCTP ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                If (GTPM ())
                {
                    Return (Zero)
                }

                If (GCTP ())
                {
                    Return (ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0xFED40000,         // Address Base
                            0x00005000,         // Address Length
                            )
                        IO (Decode16,
                            0x0CB0,             // Range Minimum
                            0x0CB0,             // Range Maximum
                            0x08,               // Alignment
                            0x10,               // Length
                            )
                    })
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (_DSM, 4, NotSerialized)  // _DSM: Device-Specific Method
            {
                If (LEqual (ToBuffer (Arg0), ToUUID ("3dddfaa6-361b-4eb4-a424-8d10089d1653") /* Physical Presence Interface */))
                {
                    Name (_T_0, Zero)  // _T_x: Emitted by ASL Compiler
                    Store (ToInteger (Arg2), _T_0)
                    If (LEqual (_T_0, Zero))
                    {
                        Return (Buffer (One)
                        {
                             0x3F                                           
                        })
                    }
                    ElseIf (LEqual (_T_0, One))
                    {
                        Return ("1.0")
                    }
                    ElseIf (LEqual (_T_0, 0x02))
                    {
                        Store (ToInteger (Arg3), Local0)
                        And (Local0, 0x0F, Local0)
                        CMWR (0x7E, Local0)
                        Return (Zero)
                    }
                    ElseIf (LEqual (_T_0, 0x03))
                    {
                        Store (CMRD (0x7E), Local0)
                        And (Local0, 0x0F, Local0)
                        Return (PPR2 (Local0))
                    }
                    ElseIf (LEqual (_T_0, 0x04))
                    {
                        Return (0x02)
                    }
                    ElseIf (LEqual (_T_0, 0x05))
                    {
                        Store (CMRD (0x7E), Local0)
                        ShiftRight (Local0, 0x04, Local0)
                        Store (CMRD (0x7F), Local1)
                        And (Local1, 0x7F, Local1)
                        Return (PPR3 (Local0, Local1))
                    }
                    ElseIf (LEqual (_T_0, 0x06))
                    {
                        Name (_T_1, "")  // _T_x: Emitted by ASL Compiler
                        Store (ToString (Arg3, Ones), _T_1)
                        If (LEqual (_T_1, "en"))
                        {
                            Return (Zero)
                        }
                        Else
                        {
                            Return (One)
                        }
                    }
                    Else
                    {
                        Return (Buffer (One)
                        {
                             0x00                                           
                        })
                    }
                }

                If (LEqual (ToBuffer (Arg0), ToUUID ("376054ed-cc13-4675-901c-4756d7f2d45d")))
                {
                    Name (_T_2, Zero)  // _T_x: Emitted by ASL Compiler
                    Store (ToInteger (Arg2), _T_2)
                    If (LEqual (_T_2, Zero))
                    {
                        Return (Buffer (One)
                        {
                             0x01                                           
                        })
                    }
                    ElseIf (LEqual (_T_2, One))
                    {
                        Store (SMI (0xBC, And (ToInteger (Arg3), One)), Local1)
                        Return (ToInteger (Local1))
                    }
                }

                Return (Buffer (One)
                {
                     0x00                                           
                })
            }

            Method (PPR2, 1, NotSerialized)
            {
                Name (_T_0, Zero)  // _T_x: Emitted by ASL Compiler
                Store (ToInteger (Arg0), _T_0)
                If (LEqual (_T_0, Zero))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        Zero
                    })
                }
                ElseIf (LEqual (_T_0, One))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        One
                    })
                }
                ElseIf (LEqual (_T_0, 0x02))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x02
                    })
                }
                ElseIf (LEqual (_T_0, 0x03))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x03
                    })
                }
                ElseIf (LEqual (_T_0, 0x04))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x04
                    })
                }
                ElseIf (LEqual (_T_0, 0x05))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x05
                    })
                }
                ElseIf (LEqual (_T_0, 0x06))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x06
                    })
                }
                ElseIf (LEqual (_T_0, 0x07))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x07
                    })
                }
                ElseIf (LEqual (_T_0, 0x08))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x08
                    })
                }
                ElseIf (LEqual (_T_0, 0x09))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x09
                    })
                }
                ElseIf (LEqual (_T_0, 0x0A))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x0A
                    })
                }
                ElseIf (LEqual (_T_0, 0x0B))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x0B
                    })
                }
                ElseIf (LEqual (_T_0, 0x0C))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x0C
                    })
                }
                ElseIf (LEqual (_T_0, 0x0D))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x0D
                    })
                }
                ElseIf (LEqual (_T_0, 0x0E))
                {
                    Return (Package (0x02)
                    {
                        Zero, 
                        0x0E
                    })
                }

                Return (Package (0x02)
                {
                    One, 
                    Zero
                })
            }

            Method (PPR3, 2, NotSerialized)
            {
                If (LEqual (Arg1, Zero))
                {
                    Name (_T_0, Zero)  // _T_x: Emitted by ASL Compiler
                    Store (ToInteger (Arg0), _T_0)
                    If (LEqual (_T_0, Zero))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            Zero, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, One))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            One, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x02))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x02, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x03))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x03, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x04))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x04, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x05))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x05, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x06))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x06, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x07))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x07, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x08))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x08, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x09))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x09, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x0A))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0A, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x0B))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0B, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x0C))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0C, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x0D))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0D, 
                            Zero
                        })
                    }
                    ElseIf (LEqual (_T_0, 0x0E))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0E, 
                            Zero
                        })
                    }

                    Return (Package (0x03)
                    {
                        One, 
                        Zero, 
                        Zero
                    })
                }
                Else
                {
                    Name (_T_1, Zero)  // _T_x: Emitted by ASL Compiler
                    Store (ToInteger (Arg0), _T_1)
                    If (LEqual (_T_1, Zero))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            Zero, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, One))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            One, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x02))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x02, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x03))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x03, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x04))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x04, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x05))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x05, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x06))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x06, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x07))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x07, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x08))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x08, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x09))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x09, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x0A))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0A, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x0B))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0B, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x0C))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0C, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x0D))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0D, 
                            0xFFFFFFF0
                        })
                    }
                    ElseIf (LEqual (_T_1, 0x0E))
                    {
                        Return (Package (0x03)
                        {
                            Zero, 
                            0x0E, 
                            0xFFFFFFF0
                        })
                    }

                    Return (Package (0x03)
                    {
                        One, 
                        Zero, 
                        Zero
                    })
                }
            }
        }

        Device (TCM)
        {
            Name (_HID, EisaId ("ZIC0101"))  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (LNot (GTPM ()))
                {
                    Return (Zero)
                }

                If (GCTP ())
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                If (LAnd (GTPM (), GCTP ()))
                {
                    Return (ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0xFED40000,         // Address Base
                            0x00005000,         // Address Length
                            )
                    })
                }
                Else
                {
                    Return (Zero)
                }
            }
        }
    }
}