/*
 * Intel ACPI Component Architecture
 * AML/ASL+ Disassembler version 20160831-64
 * Copyright (c) 2000 - 2016 Intel Corporation
 * 
 * Disassembling to symbolic ASL+ operators
 *
 * Disassembly of dsdt.dat, Mon Jan  2 15:19:14 2017
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00006909 (26889)
 *     Revision         0x01 **** 32-bit table (V1), no 64-bit math support
 *     Checksum         0xD7
 *     OEM ID           "A0798"
 *     OEM Table ID     "A0798000"
 *     OEM Revision     0x00000000 (0)
 *     Compiler ID      "INTL"
 *     Compiler Version 0x20051117 (537202967)
 */
DefinitionBlock ("", "DSDT", 1, "A0798", "A0798000", 0x00000000)
{
    Scope (\_PR)
    {
        Processor (CPU1, 0x01, 0x00000810, 0x06)
        {
            OperationRegion (STBL, SystemMemory, 0x7F7AE0C0, 0x0214)
            Name (NCPU, 0x02)
            Name (TYPE, 0x80000000)
            Name (HNDL, 0x80000000)
            Name (CFGD, 0x01000009)
            Name (TBLD, 0x80)
            Method (_PDC, 1, NotSerialized)  // _PDC: Processor Driver Capabilities
            {
                CreateDWordField (Arg0, 0x00, REVS)
                CreateDWordField (Arg0, 0x04, SIZE)
                Local0 = SizeOf (Arg0)
                Local1 = (Local0 - 0x08)
                CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP)
                Name (STS0, Buffer (0x04)
                {
                     0x00, 0x00, 0x00, 0x00                           /* .... */
                })
                Concatenate (STS0, TEMP, Local2)
                _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2)
            }

            Method (_OSC, 4, NotSerialized)  // _OSC: Operating System Capabilities
            {
                CreateDWordField (Arg3, 0x00, STS0)
                CreateDWordField (Arg3, 0x04, CAP0)
                CreateDWordField (Arg0, 0x00, IID0)
                CreateDWordField (Arg0, 0x04, IID1)
                CreateDWordField (Arg0, 0x08, IID2)
                CreateDWordField (Arg0, 0x0C, IID3)
                Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953"))
                CreateDWordField (UID0, 0x00, EID0)
                CreateDWordField (UID0, 0x04, EID1)
                CreateDWordField (UID0, 0x08, EID2)
                CreateDWordField (UID0, 0x0C, EID3)
                If (!(((IID0 == EID0) && (IID1 == EID1)) && ((
                    IID2 == EID2) && (IID3 == EID3))))
                {
                    STS0 = 0x06
                    Return (Arg3)
                }

                If (Arg1 != 0x01)
                {
                    STS0 = 0x0A
                    Return (Arg3)
                }

                TYPE = ((TYPE & 0x7FFFFFFF) | CAP0) /* \_PR_.CPU1._OSC.CAP0 */
                If (CFGD & 0x01)
                {
                    If (((CFGD & 0x01000000) && ((TYPE & 0x09) == 
                        0x09)) && !(TBLD & 0x01))
                    {
                        TBLD |= 0x01
                        Load (STBL, HNDL) /* \_PR_.CPU1.HNDL */
                    }
                }

                If (CFGD & 0xF0)
                {
                    If (((CFGD & 0x01000000) && (TYPE & 0x18)) && !
                        (TBLD & 0x02))
                    {
                        TBLD |= 0x02
                    }
                }

                Return (Arg3)
            }
        }
    }

    Scope (\_PR)
    {
        Processor (CPU2, 0x02, 0x00000810, 0x06)
        {
            OperationRegion (STBL, SystemMemory, 0x7F7AE2E0, 0x0143)
            Name (NCPU, 0x02)
            Name (TYPE, 0x80000000)
            Name (HNDL, 0x80000000)
            Name (CFGD, 0x01000009)
            Name (TBLD, 0x80)
            Method (_PDC, 1, NotSerialized)  // _PDC: Processor Driver Capabilities
            {
                CreateDWordField (Arg0, 0x00, REVS)
                CreateDWordField (Arg0, 0x04, SIZE)
                Local0 = SizeOf (Arg0)
                Local1 = (Local0 - 0x08)
                CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP)
                Name (STS1, Buffer (0x04)
                {
                     0x00, 0x00, 0x00, 0x00                           /* .... */
                })
                Concatenate (STS1, TEMP, Local2)
                _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2)
            }

            Method (_OSC, 4, NotSerialized)  // _OSC: Operating System Capabilities
            {
                CreateDWordField (Arg3, 0x00, STS1)
                CreateDWordField (Arg3, 0x04, CAP1)
                CreateDWordField (Arg0, 0x00, IID0)
                CreateDWordField (Arg0, 0x04, IID1)
                CreateDWordField (Arg0, 0x08, IID2)
                CreateDWordField (Arg0, 0x0C, IID3)
                Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953"))
                CreateDWordField (UID0, 0x00, EID0)
                CreateDWordField (UID0, 0x04, EID1)
                CreateDWordField (UID0, 0x08, EID2)
                CreateDWordField (UID0, 0x0C, EID3)
                If (!(((IID0 == EID0) && (IID1 == EID1)) && ((
                    IID2 == EID2) && (IID3 == EID3))))
                {
                    STS1 = 0x06
                    Return (Arg3)
                }

                If (Arg1 != 0x01)
                {
                    STS1 = 0x0A
                    Return (Arg3)
                }

                TYPE = ((TYPE & 0x7FFFFFFF) | CAP1) /* \_PR_.CPU2._OSC.CAP1 */
                If (CFGD & 0x01)
                {
                    If (((CFGD & 0x01000000) && ((TYPE & 0x09) == 
                        0x09)) && !(TBLD & 0x01))
                    {
                        TBLD |= 0x01
                        Load (STBL, HNDL) /* \_PR_.CPU2.HNDL */
                    }
                }

                If (CFGD & 0xF0)
                {
                    If (((CFGD & 0x01000000) && (TYPE & 0x18)) && !
                        (TBLD & 0x02))
                    {
                        TBLD |= 0x02
                    }
                }

                Return (Arg3)
            }
        }
    }

    Scope (\_PR)
    {
        Processor (CPU3, 0x03, 0x00000810, 0x06)
        {
            OperationRegion (STBL, SystemMemory, 0xFFFF0000, 0xFFFF)
            Name (NCPU, 0x80)
            Name (TYPE, 0x80000000)
            Name (HNDL, 0x80000000)
            Name (CFGD, 0x80000000)
            Name (TBLD, 0x80)
            Method (_PDC, 1, NotSerialized)  // _PDC: Processor Driver Capabilities
            {
                CreateDWordField (Arg0, 0x00, REVS)
                CreateDWordField (Arg0, 0x04, SIZE)
                Local0 = SizeOf (Arg0)
                Local1 = (Local0 - 0x08)
                CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP)
                Name (STS2, Buffer (0x04)
                {
                     0x00, 0x00, 0x00, 0x00                           /* .... */
                })
                Concatenate (STS2, TEMP, Local2)
                _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2)
            }

            Method (_OSC, 4, NotSerialized)  // _OSC: Operating System Capabilities
            {
                CreateDWordField (Arg3, 0x00, STS2)
                CreateDWordField (Arg3, 0x04, CAP2)
                CreateDWordField (Arg0, 0x00, IID0)
                CreateDWordField (Arg0, 0x04, IID1)
                CreateDWordField (Arg0, 0x08, IID2)
                CreateDWordField (Arg0, 0x0C, IID3)
                Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953"))
                CreateDWordField (UID0, 0x00, EID0)
                CreateDWordField (UID0, 0x04, EID1)
                CreateDWordField (UID0, 0x08, EID2)
                CreateDWordField (UID0, 0x0C, EID3)
                If (!(((IID0 == EID0) && (IID1 == EID1)) && ((
                    IID2 == EID2) && (IID3 == EID3))))
                {
                    STS2 = 0x06
                    Return (Arg3)
                }

                If (Arg1 != 0x01)
                {
                    STS2 = 0x0A
                    Return (Arg3)
                }

                TYPE = ((TYPE & 0x7FFFFFFF) | CAP2) /* \_PR_.CPU3._OSC.CAP2 */
                If (CFGD & 0x01)
                {
                    If (((CFGD & 0x01000000) && ((TYPE & 0x09) == 
                        0x09)) && !(TBLD & 0x01))
                    {
                        TBLD |= 0x01
                        Load (STBL, HNDL) /* \_PR_.CPU3.HNDL */
                    }
                }

                If (CFGD & 0xF0)
                {
                    If (((CFGD & 0x01000000) && (TYPE & 0x18)) && !
                        (TBLD & 0x02))
                    {
                        TBLD |= 0x02
                    }
                }

                Return (Arg3)
            }
        }
    }

    Scope (\_PR)
    {
        Processor (CPU4, 0x04, 0x00000810, 0x06)
        {
            OperationRegion (STBL, SystemMemory, 0xFFFF0000, 0xFFFF)
            Name (NCPU, 0x80)
            Name (TYPE, 0x80000000)
            Name (HNDL, 0x80000000)
            Name (CFGD, 0x80000000)
            Name (TBLD, 0x80)
            Method (_PDC, 1, NotSerialized)  // _PDC: Processor Driver Capabilities
            {
                CreateDWordField (Arg0, 0x00, REVS)
                CreateDWordField (Arg0, 0x04, SIZE)
                Local0 = SizeOf (Arg0)
                Local1 = (Local0 - 0x08)
                CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP)
                Name (STS3, Buffer (0x04)
                {
                     0x00, 0x00, 0x00, 0x00                           /* .... */
                })
                Concatenate (STS3, TEMP, Local2)
                _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2)
            }

            Method (_OSC, 4, NotSerialized)  // _OSC: Operating System Capabilities
            {
                CreateDWordField (Arg3, 0x00, STS3)
                CreateDWordField (Arg3, 0x04, CAP3)
                CreateDWordField (Arg0, 0x00, IID0)
                CreateDWordField (Arg0, 0x04, IID1)
                CreateDWordField (Arg0, 0x08, IID2)
                CreateDWordField (Arg0, 0x0C, IID3)
                Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953"))
                CreateDWordField (UID0, 0x00, EID0)
                CreateDWordField (UID0, 0x04, EID1)
                CreateDWordField (UID0, 0x08, EID2)
                CreateDWordField (UID0, 0x0C, EID3)
                If (!(((IID0 == EID0) && (IID1 == EID1)) && ((
                    IID2 == EID2) && (IID3 == EID3))))
                {
                    STS3 = 0x06
                    Return (Arg3)
                }

                If (Arg1 != 0x01)
                {
                    STS3 = 0x0A
                    Return (Arg3)
                }

                TYPE = ((TYPE & 0x7FFFFFFF) | CAP3) /* \_PR_.CPU4._OSC.CAP3 */
                If (CFGD & 0x01)
                {
                    If (((CFGD & 0x01000000) && ((TYPE & 0x09) == 
                        0x09)) && !(TBLD & 0x01))
                    {
                        TBLD |= 0x01
                        Load (STBL, HNDL) /* \_PR_.CPU4.HNDL */
                    }
                }

                If (CFGD & 0xF0)
                {
                    If (((CFGD & 0x01000000) && (TYPE & 0x18)) && !
                        (TBLD & 0x02))
                    {
                        TBLD |= 0x02
                    }
                }

                Return (Arg3)
            }
        }
    }

    Name (DP80, 0x80)
    Name (DP90, 0x90)
    Name (SPIO, 0x2E)
    Name (IOHW, 0x0290)
    Name (ACPH, 0xDE)
    Name (PMBS, 0x0800)
    Name (FHDC, 0xD9)
    Name (PMLN, 0x80)
    Name (GPBS, 0x0480)
    Name (GPLN, 0x40)
    Name (SMBS, 0x0400)
    Name (SMBL, 0x20)
    Name (SMBH, 0x00)
    Name (PM30, 0x0830)
    Name (SUSW, 0xFF)
    Name (HTBA, 0xFED1F404)
    Name (APIC, 0x01)
    Name (EAQF, 0x01)
    Name (CQST, 0x3C)
    Name (PCIB, 0xF0000000)
    Name (PCIL, 0x04000000)
    Name (CPUC, 0x04)
    OperationRegion (BIOS, SystemMemory, 0x7F7AE064, 0xFF)
    Field (BIOS, ByteAcc, NoLock, Preserve)
    {
        SS1,    1, 
        SS2,    1, 
        SS3,    1, 
        SS4,    1, 
        Offset (0x01), 
        IOST,   16, 
        TOPM,   32, 
        ROMS,   32, 
        MG1B,   32, 
        MG1L,   32, 
        MG2B,   32, 
        MG2L,   32, 
        Offset (0x1C), 
        DMAX,   8, 
        HPTA,   32, 
        CPB0,   32, 
        CPB1,   32, 
        CPB2,   32, 
        CPB3,   32, 
        ASSB,   8, 
        AOTB,   8, 
        AAXB,   32, 
        SMIF,   8, 
        DTSE,   8, 
        DTS1,   8, 
        DTS2,   8, 
        MPEN,   8, 
        MSC1,   32, 
        MSC2,   32, 
        MSC3,   32, 
        MSC4,   32, 
        MSC5,   32, 
        MSC6,   32, 
        MSC7,   32, 
        MSC8,   32
    }

    Method (RRIO, 4, NotSerialized)
    {
        Debug = "RRIO"
    }

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

    Name (PICM, 0x00)
    Method (_PIC, 1, NotSerialized)  // _PIC: Interrupt Model
    {
        If (Arg0)
        {
            DBG8 = 0xAA
        }
        Else
        {
            DBG8 = 0xAC
        }

        PICM = Arg0
    }

    Name (OSVR, Ones)
    Method (OSFL, 0, NotSerialized)
    {
        If (OSVR != Ones)
        {
            Return (OSVR) /* \OSVR */
        }

        If (PICM == 0x00)
        {
            DBG8 = 0xAC
        }

        OSVR = 0x01
        If (CondRefOf (\_OSI, Local1))
        {
            If (\_OSI ("Windows 2001"))
            {
                OSVR = 0x00
            }
        }
        ElseIf (MCTH (\_OS, "Microsoft Windows NT"))
        {
            OSVR = 0x04
        }
        Else
        {
            If (MCTH (\_OS, "Microsoft WindowsME: Millennium Edition"))
            {
                OSVR = 0x02
            }

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

        Return (OSVR) /* \OSVR */
    }

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

        Local0 = (SizeOf (Arg0) + 0x01)
        Name (BUF0, Buffer (Local0) {})
        Name (BUF1, Buffer (Local0) {})
        BUF0 = Arg0
        BUF1 = Arg1
        While (Local0)
        {
            Local0--
            If (DerefOf (BUF0 [Local0]) != DerefOf (BUF1 [Local0]
                ))
            {
                Return (Zero)
            }
        }

        Return (One)
    }

    Name (PRWP, Package (0x02)
    {
        Zero, 
        Zero
    })
    Method (GPRW, 2, NotSerialized)
    {
        PRWP [0x00] = Arg0
        Local0 = (SS1 << 0x01)
        Local0 |= (SS2 << 0x02)
        Local0 |= (SS3 << 0x03)
        Local0 |= (SS4 << 0x04)
        If ((0x01 << Arg1) & Local0)
        {
            PRWP [0x01] = Arg1
        }
        Else
        {
            Local0 >>= 0x01
            If ((OSFL () == 0x01) || (OSFL () == 0x02))
            {
                FindSetLeftBit (Local0, PRWP [0x01])
            }
            Else
            {
                FindSetRightBit (Local0, PRWP [0x01])
            }
        }

        Return (PRWP) /* \PRWP */
    }

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

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

    Scope (\_SB)
    {
        Name (PR00, Package (0x14)
        {
            Package (0x04)
            {
                0x0001FFFF, 
                0x00, 
                LNKA, 
                0x00
            }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            Package (0x04)
            {
                0x001BFFFF, 
                0x00, 
                LNKD, 
                0x00
            }
        })
        Name (AR00, Package (0x14)
        {
            Package (0x04)
            {
                0x0001FFFF, 
                0x00, 
                0x00, 
                0x10
            }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            Package (0x04)
            {
                0x001BFFFF, 
                0x00, 
                0x00, 
                0x13
            }
        })
        Name (PR01, Package (0x04)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                LNKA, 
                0x00
            }, 

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

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

            Package (0x04)
            {
                0xFFFF, 
                0x03, 
                LNKD, 
                0x00
            }
        })
        Name (AR01, Package (0x04)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                0x00, 
                0x10
            }, 

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

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

            Package (0x04)
            {
                0xFFFF, 
                0x03, 
                0x00, 
                0x13
            }
        })
        Name (PR03, Package (0x09)
        {
            Package (0x04)
            {
                0x0008FFFF, 
                0x00, 
                LNKE, 
                0x00
            }, 

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

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

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

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

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

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

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

            Package (0x04)
            {
                0x0001FFFF, 
                0x03, 
                LNKE, 
                0x00
            }
        })
        Name (AR03, Package (0x09)
        {
            Package (0x04)
            {
                0x0008FFFF, 
                0x00, 
                0x00, 
                0x14
            }, 

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

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

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

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

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

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

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

            Package (0x04)
            {
                0x0001FFFF, 
                0x03, 
                0x00, 
                0x14
            }
        })
        Name (PR09, Package (0x04)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                LNKA, 
                0x00
            }, 

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

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

            Package (0x04)
            {
                0xFFFF, 
                0x03, 
                LNKD, 
                0x00
            }
        })
        Name (AR09, Package (0x04)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                0x00, 
                0x10
            }, 

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

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

            Package (0x04)
            {
                0xFFFF, 
                0x03, 
                0x00, 
                0x13
            }
        })
        Name (PR08, Package (0x01)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                LNKB, 
                0x00
            }
        })
        Name (AR08, Package (0x01)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                0x00, 
                0x11
            }
        })
        Name (PRSA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {3,4,5,6,7,10,11,12,14,15}
        })
        Alias (PRSA, PRSB)
        Alias (PRSA, PRSC)
        Alias (PRSA, PRSD)
        Alias (PRSA, PRSE)
        Alias (PRSA, PRSF)
        Alias (PRSA, PRSG)
        Alias (PRSA, PRSH)
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A08") /* PCI Express Bus */)  // _HID: Hardware ID
            Name (_CID, EisaId ("PNP0A03") /* PCI Bus */)  // _CID: Compatible ID
            Name (_ADR, 0x00)  // _ADR: Address
            Method (^BN00, 0, NotSerialized)
            {
                Return (0x00)
            }

            Method (_BBN, 0, NotSerialized)  // _BBN: BIOS Bus Number
            {
                Return (BN00 ())
            }

            Name (_UID, 0x00)  // _UID: Unique ID
            Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
            {
                If (PICM)
                {
                    Return (AR00) /* \_SB_.AR00 */
                }

                Return (PR00) /* \_SB_.PR00 */
            }

            Method (_S3D, 0, NotSerialized)  // _S3D: S3 Device State
            {
                If ((OSFL () == 0x01) || (OSFL () == 0x02))
                {
                    Return (0x02)
                }
                Else
                {
                    Return (0x03)
                }
            }

            Device (MCH)
            {
                Name (_HID, EisaId ("PNP0C01") /* System Board */)  // _HID: Hardware ID
                Name (_UID, 0x0A)  // _UID: Unique ID
                Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                {
                    Memory32Fixed (ReadWrite,
                        0xFED13000,         // Address Base
                        0x00007000,         // Address Length
                        )
                })
            }

            Method (NPTS, 1, NotSerialized)
            {
            }

            Method (NWAK, 1, NotSerialized)
            {
            }

            Device (P0P1)
            {
                Name (_ADR, 0x00010000)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x09, 0x04))
                }

                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    If (PICM)
                    {
                        Return (AR01) /* \_SB_.AR01 */
                    }

                    Return (PR01) /* \_SB_.PR01 */
                }
            }

            Device (P0P3)
            {
                Name (_ADR, 0x001E0000)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x0B, 0x04))
                }

                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    If (PICM)
                    {
                        Return (AR03) /* \_SB_.AR03 */
                    }

                    Return (PR03) /* \_SB_.PR03 */
                }
            }

            Device (P0P9)
            {
                Name (_ADR, 0x001C0000)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x09, 0x04))
                }

                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    If (PICM)
                    {
                        Return (AR09) /* \_SB_.AR09 */
                    }

                    Return (PR09) /* \_SB_.PR09 */
                }
            }

            Device (P0P8)
            {
                Name (_ADR, 0x001C0001)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x09, 0x04))
                }

                Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
                {
                    If (PICM)
                    {
                        Return (AR08) /* \_SB_.AR08 */
                    }

                    Return (PR08) /* \_SB_.PR08 */
                }
            }

            Device (P0P7)
            {
                Name (_ADR, 0x001C0002)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x09, 0x04))
                }
            }

            Device (P0P6)
            {
                Name (_ADR, 0x001C0003)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x09, 0x04))
                }
            }

            Device (P0P5)
            {
                Name (_ADR, 0x001C0004)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x09, 0x04))
                }
            }

            Device (P0P4)
            {
                Name (_ADR, 0x001C0005)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x09, 0x04))
                }
            }

            Device (SBRG)
            {
                Name (_ADR, 0x001F0000)  // _ADR: Address
                Method (SPTS, 1, NotSerialized)
                {
                    PS1S = One
                    PS1E = One
                    \_SB.SLPS = One
                }

                Method (SWAK, 1, NotSerialized)
                {
                    \_SB.SLPS = Zero
                    PS1E = Zero
                    If (RTCS) {}
                    Else
                    {
                        Notify (\_SB.PWRB, 0x02) // Device Wake
                    }

                    If (AAXB & 0x02)
                    {
                        Notify (\_SB.PWRB, 0x02) // Device Wake
                    }
                }

                OperationRegion (PMS0, SystemIO, PMBS, 0x04)
                Field (PMS0, ByteAcc, NoLock, Preserve)
                {
                        ,   10, 
                    RTCS,   1, 
                        ,   4, 
                    WAKS,   1, 
                    Offset (0x03), 
                    PWBT,   1, 
                    Offset (0x04)
                }

                OperationRegion (SMIE, SystemIO, PM30, 0x08)
                Field (SMIE, ByteAcc, NoLock, Preserve)
                {
                        ,   4, 
                    PS1E,   1, 
                        ,   31, 
                    PS1S,   1, 
                    Offset (0x08)
                }

                Scope (\_SB)
                {
                    Name (SLPS, 0x00)
                    Device (SLPB)
                    {
                        Name (_HID, EisaId ("PNP0C0E") /* Sleep Button Device */)  // _HID: Hardware ID
                        Method (_STA, 0, NotSerialized)  // _STA: Status
                        {
                            If (SUSW != 0xFF)
                            {
                                Return (0x0F)
                            }

                            Return (0x00)
                        }

                        Method (SBEV, 0, NotSerialized)
                        {
                            If (SLPS)
                            {
                                Notify (SLPB, 0x02) // Device Wake
                            }
                            Else
                            {
                                Notify (SLPB, 0x80) // Status Change
                            }
                        }

                        Method (\_GPE._L1B, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
                        {
                            \_SB.SLPB.SBEV ()
                        }

                        Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                        {
                            Return (Package (0x02)
                            {
                                0x1B, 
                                0x04
                            })
                        }
                    }
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */)  // _HID: Hardware ID
                    Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                    {
                        IO (Decode16,
                            0x0020,             // Range Minimum
                            0x0020,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A0,             // Range Minimum
                            0x00A0,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {2}
                    })
                }

                Device (DMAD)
                {
                    Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */)  // _HID: Hardware ID
                    Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                    {
                        DMA (Compatibility, BusMaster, Transfer8, )
                            {4}
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0081,             // Range Minimum
                            0x0081,             // Range Maximum
                            0x00,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0087,             // Range Minimum
                            0x0087,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0089,             // Range Minimum
                            0x0089,             // Range Maximum
                            0x00,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x008F,             // Range Minimum
                            0x008F,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x00C0,             // Range Minimum
                            0x00C0,             // Range Maximum
                            0x00,               // Alignment
                            0x20,               // Length
                            )
                    })
                }

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100") /* PC-class System Timer */)  // _HID: Hardware ID
                    Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                    {
                        IO (Decode16,
                            0x0040,             // Range Minimum
                            0x0040,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {0}
                    })
                }

                Device (RTC0)
                {
                    Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */)  // _HID: Hardware ID
                    Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                    {
                        IO (Decode16,
                            0x0070,             // Range Minimum
                            0x0070,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {8}
                    })
                }

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800") /* Microsoft Sound System Compatible Device */)  // _HID: Hardware ID
                    Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                    {
                        IO (Decode16,
                            0x0061,             // Range Minimum
                            0x0061,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                    })
                }

                Device (COPR)
                {
                    Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */)  // _HID: Hardware ID
                    Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                    {
                        IO (Decode16,
                            0x00F0,             // Range Minimum
                            0x00F0,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IRQNoFlags ()
                            {13}
                    })
                }

                Device (FDC)
                {
                    Name (_HID, EisaId ("PNP0700"))  // _HID: Hardware ID
                    Method (_FDE, 0, NotSerialized)  // _FDE: Floppy Disk Enumerate
                    {
                        Name (FDEP, Package (0x05)
                        {
                            0x00, 
                            0x00, 
                            0x02, 
                            0x02, 
                            0x02
                        })
                        If (_STA ())
                        {
                            FDEP [0x00] = 0x01
                        }

                        Return (FDEP) /* \_SB_.PCI0.SBRG.FDC_._FDE.FDEP */
                    }

                    Method (_STA, 0, NotSerialized)  // _STA: Status
                    {
                        Return (DSTA (0x03))
                    }

                    Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                    {
                        DCNT (0x03, 0x00)
                    }

                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        DCRS (0x03, 0x01)
                        IRQE = IRQM /* \_SB_.PCI0.SBRG.IRQM */
                        DMAE = DMAM /* \_SB_.PCI0.SBRG.DMAM */
                        IO21 = IO11 /* \_SB_.PCI0.SBRG.IO11 */
                        IO22 = IO12 /* \_SB_.PCI0.SBRG.IO12 */
                        LEN2 = 0x06
                        IO31 = (IO21 + 0x07)
                        IO32 = IO31 /* \_SB_.PCI0.SBRG.IO31 */
                        LEN3 = 0x01
                        Return (CRS2) /* \_SB_.PCI0.SBRG.CRS2 */
                    }

                    Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                    {
                        DSRS (Arg0, 0x03)
                        CreateWordField (Arg0, 0x01, IRQE)
                        CreateByteField (Arg0, 0x04, DMAE)
                        ENFG (CGLD (0x03))
                        If (IRQE)
                        {
                            FindSetRightBit (IRQE, Local0)
                            INTR = (Local0 - 0x01)
                        }
                        Else
                        {
                            INTR = 0x00
                        }

                        If (DMAE)
                        {
                            FindSetRightBit (DMAE, Local0)
                            DMCH = (Local0 - 0x01)
                        }
                        Else
                        {
                            DMCH = 0x04
                        }

                        EXFG ()
                    }

                    Name (_PRS, ResourceTemplate ()  // _PRS: Possible Resource Settings
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x03F0,             // Range Minimum
                                0x03F0,             // Range Maximum
                                0x01,               // 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
                                0x01,               // Alignment
                                0x06,               // Length
                                )
                            IO (Decode16,
                                0x03F7,             // Range Minimum
                                0x03F7,             // Range Maximum
                                0x01,               // Alignment
                                0x01,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0370,             // Range Minimum
                                0x0370,             // Range Maximum
                                0x01,               // Alignment
                                0x06,               // Length
                                )
                            IO (Decode16,
                                0x0377,             // Range Minimum
                                0x0377,             // Range Maximum
                                0x01,               // Alignment
                                0x01,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        EndDependentFn ()
                    })
                }

                Device (LPTE)
                {
                    Method (_HID, 0, NotSerialized)  // _HID: Hardware ID
                    {
                        If (LPTM (0x02))
                        {
                            Return (0x0104D041)
                        }
                        Else
                        {
                            Return (0x0004D041)
                        }
                    }

                    Method (_STA, 0, NotSerialized)  // _STA: Status
                    {
                        Return (DSTA (0x02))
                    }

                    Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                    {
                        DCNT (0x02, 0x00)
                    }

                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        DCRS (0x02, 0x01)
                        If (LPTM (0x02))
                        {
                            IRQE = IRQM /* \_SB_.PCI0.SBRG.IRQM */
                            DMAE = DMAM /* \_SB_.PCI0.SBRG.DMAM */
                            IO21 = IO11 /* \_SB_.PCI0.SBRG.IO11 */
                            IO22 = IO12 /* \_SB_.PCI0.SBRG.IO12 */
                            LEN2 = LEN1 /* \_SB_.PCI0.SBRG.LEN1 */
                            IO31 = (IO21 + 0x0400)
                            IO32 = IO31 /* \_SB_.PCI0.SBRG.IO31 */
                            LEN3 = LEN2 /* \_SB_.PCI0.SBRG.LEN2 */
                            Return (CRS2) /* \_SB_.PCI0.SBRG.CRS2 */
                        }
                        Else
                        {
                            Return (CRS1) /* \_SB_.PCI0.SBRG.CRS1 */
                        }
                    }

                    Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                    {
                        DSRS (Arg0, 0x02)
                    }

                    Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                    {
                        If (LPTM (0x02))
                        {
                            Return (EPPR) /* \_SB_.PCI0.SBRG.LPTE.EPPR */
                        }
                        Else
                        {
                            Return (LPPR) /* \_SB_.PCI0.SBRG.LPTE.LPPR */
                        }
                    }

                    Name (LPPR, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                        }
                        EndDependentFn ()
                    })
                    Name (EPPR, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0678,             // Range Minimum
                                0x0678,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IO (Decode16,
                                0x07BC,             // Range Minimum
                                0x07BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        EndDependentFn ()
                    })
                }

                Device (SIOR)
                {
                    Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                    Method (_UID, 0, NotSerialized)  // _UID: Unique ID
                    {
                        Return (SPIO) /* \SPIO */
                    }

                    Name (CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y00)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            )
                        IO (Decode16,
                            0x0290,             // Range Minimum
                            0x0290,             // Range Maximum
                            0x00,               // Alignment
                            0x08,               // Length
                            )
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        If ((SPIO != 0x03F0) && (SPIO > 0xF0))
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._MIN, GP10)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._MAX, GP11)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._LEN, GPL1)  // _LEN: Length
                            GP10 = SPIO /* \SPIO */
                            GP11 = SPIO /* \SPIO */
                            GPL1 = 0x02
                        }

                        Return (CRS) /* \_SB_.PCI0.SBRG.SIOR.CRS_ */
                    }
                }

                Name (DCAT, Package (0x15)
                {
                    0x02, 
                    0x03, 
                    0x01, 
                    0x00, 
                    0xFF, 
                    0x07, 
                    0xFF, 
                    0xFF, 
                    0x07, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0x07, 
                    0x08, 
                    0x09, 
                    0xFF, 
                    0xFF
                })
                Mutex (IOCF, 0x00)
                Method (ENFG, 1, NotSerialized)
                {
                    Acquire (IOCF, 0xFFFF)
                    INDX = 0x87
                    INDX = 0x87
                    LDN = Arg0
                }

                Method (EXFG, 0, NotSerialized)
                {
                    INDX = 0xAA
                    Release (IOCF)
                }

                Method (LPTM, 1, NotSerialized)
                {
                    ENFG (CGLD (Arg0))
                    Local0 = (OPT0 & 0x02)
                    EXFG ()
                    Return (Local0)
                }

                Method (UHID, 1, NotSerialized)
                {
                    If (Arg0 == 0x01)
                    {
                        ENFG (CGLD (Arg0))
                        Local0 = (OPT1 & 0x38)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x1005D041)
                        }
                    }

                    Return (0x0105D041)
                }

                Name (KBFG, 0x01)
                Name (MSFG, 0x01)
                Method (SIOK, 1, NotSerialized)
                {
                    ENFG (0x0A)
                    If (Arg0 > 0x01)
                    {
                        CRE4 |= 0x10
                        CRE0 = 0x00
                        Local0 = CRE3 /* \_SB_.PCI0.SBRG.CRE3 */
                        If (KBFG)
                        {
                            CRE0 |= 0x41
                        }

                        If (MSFG)
                        {
                            CRE0 |= 0x22
                            CRE6 |= 0x80
                        }
                    }
                    ElseIf (Arg0 == 0x01)
                    {
                        OPT6 = 0x00
                        OPT3 |= 0xFF
                        OPT4 |= 0xFF
                        If (KBFG)
                        {
                            OPT6 |= 0x10
                        }

                        If (MSFG)
                        {
                            OPT6 |= 0x20
                        }
                    }

                    Local0 = CRE3 /* \_SB_.PCI0.SBRG.CRE3 */
                    EXFG ()
                }

                Method (SIOS, 1, NotSerialized)
                {
                    Debug = "SIOS"
                    SIOK (Arg0)
                }

                Method (SIOW, 1, NotSerialized)
                {
                    Debug = "SIOW"
                    SIOK (0x00)
                }

                Method (SIOH, 0, NotSerialized)
                {
                    Debug = "SIOH"
                    ENFG (0x0A)
                    If (OPT3 & 0x10)
                    {
                        Notify (PS2K, 0x02) // Device Wake
                    }

                    If (OPT3 & 0x20)
                    {
                        Notify (PS2M, 0x02) // Device Wake
                    }

                    EXFG ()
                    SIOK (Zero)
                }

                OperationRegion (IOID, SystemIO, SPIO, 0x02)
                Field (IOID, ByteAcc, NoLock, Preserve)
                {
                    INDX,   8, 
                    DATA,   8
                }

                IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x07), 
                    LDN,    8, 
                    Offset (0x22), 
                    FDCP,   1, 
                        ,   2, 
                    LPTP,   1, 
                    URAP,   1, 
                    URBP,   1, 
                    Offset (0x30), 
                    ACTR,   8, 
                    Offset (0x60), 
                    IOAH,   8, 
                    IOAL,   8, 
                    IOH2,   8, 
                    IOL2,   8, 
                    Offset (0x70), 
                    INTR,   4, 
                    Offset (0x74), 
                    DMCH,   3, 
                    Offset (0xE0), 
                    CRE0,   8, 
                    CRE1,   8, 
                    CRE2,   8, 
                    CRE3,   8, 
                    CRE4,   8, 
                    CRE5,   8, 
                    CRE6,   8, 
                    Offset (0xF0), 
                    OPT0,   8, 
                    OPT1,   8, 
                    OPT2,   8, 
                    OPT3,   8, 
                    OPT4,   8, 
                    OPT5,   8, 
                    OPT6,   8, 
                    Offset (0xF9), 
                    OPT9,   8
                }

                Method (CGLD, 1, NotSerialized)
                {
                    Return (DerefOf (DCAT [Arg0]))
                }

                Method (DSTA, 1, NotSerialized)
                {
                    ENFG (CGLD (Arg0))
                    Local0 = ACTR /* \_SB_.PCI0.SBRG.ACTR */
                    EXFG ()
                    If (Local0 == 0xFF)
                    {
                        Return (0x00)
                    }

                    If (Arg0 == 0x05)
                    {
                        Local0 >>= 0x02
                    }

                    If (Arg0 == 0x08)
                    {
                        Local0 >>= 0x01
                    }

                    Local0 &= 0x01
                    IOST |= (Local0 << Arg0)
                    If (Local0)
                    {
                        Return (0x0F)
                    }
                    ElseIf ((0x01 << Arg0) & IOST)
                    {
                        Return (0x0D)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Method (DCNT, 2, NotSerialized)
                {
                    ENFG (CGLD (Arg0))
                    If (Arg0 == 0x05)
                    {
                        Local1 = (IOH2 << 0x08)
                        Local1 |= IOL2
                    }
                    Else
                    {
                        Local1 = (IOAH << 0x08)
                        Local1 |= IOAL
                    }

                    RRIO (Arg0, Arg1, Local1, 0x08)
                    If ((DMCH < 0x04) && ((Local1 = (DMCH & 0x03)) != 0x00))
                    {
                        RDMA (Arg0, Arg1, Local1++)
                    }

                    Local1 = Arg1
                    Local2 = 0x01
                    If (Arg0 == 0x05)
                    {
                        Local1 = (Arg1 << 0x02)
                        Local2 <<= 0x02
                    }

                    If (Arg0 == 0x08)
                    {
                        Local1 = (Arg1 << 0x01)
                        Local2 <<= 0x01
                    }

                    Local0 = ACTR /* \_SB_.PCI0.SBRG.ACTR */
                    Local3 = ~Local2
                    Local0 &= Local3
                    Local0 |= Local1
                    ACTR = Local0
                    EXFG ()
                }

                Name (CRS1, ResourceTemplate ()
                {
                    IRQNoFlags (_Y01)
                        {}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y02)
                        {}
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y03)
                })
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y01._INT, IRQM)  // _INT: Interrupts
                CreateByteField (CRS1, \_SB.PCI0.SBRG._Y02._DMA, DMAM)  // _DMA: Direct Memory Access
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y03._MIN, IO11)  // _MIN: Minimum Base Address
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y03._MAX, IO12)  // _MAX: Maximum Base Address
                CreateByteField (CRS1, \_SB.PCI0.SBRG._Y03._LEN, LEN1)  // _LEN: Length
                Name (CRS2, ResourceTemplate ()
                {
                    IRQNoFlags (_Y04)
                        {6}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y05)
                        {2}
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y06)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y07)
                })
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y04._INT, IRQE)  // _INT: Interrupts
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y05._DMA, DMAE)  // _DMA: Direct Memory Access
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y06._MIN, IO21)  // _MIN: Minimum Base Address
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y06._MAX, IO22)  // _MAX: Maximum Base Address
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y06._LEN, LEN2)  // _LEN: Length
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y07._MIN, IO31)  // _MIN: Minimum Base Address
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y07._MAX, IO32)  // _MAX: Maximum Base Address
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y07._LEN, LEN3)  // _LEN: Length
                Method (DCRS, 2, NotSerialized)
                {
                    ENFG (CGLD (Arg0))
                    IO11 = (IOAH << 0x08)
                    IO11 |= IOAL /* \_SB_.PCI0.SBRG.IO11 */
                    IO12 = IO11 /* \_SB_.PCI0.SBRG.IO11 */
                    Local0 = (FindSetRightBit (IO11) - 0x01)
                    LEN1 = (0x01 << Local0)
                    If (INTR)
                    {
                        IRQM = (0x01 << INTR) /* \_SB_.PCI0.SBRG.INTR */
                    }
                    Else
                    {
                        IRQM = 0x00
                    }

                    If ((DMCH > 0x03) || (Arg1 == 0x00))
                    {
                        DMAM = 0x00
                    }
                    Else
                    {
                        Local1 = (DMCH & 0x03)
                        DMAM = (0x01 << Local1)
                    }

                    EXFG ()
                    Return (CRS1) /* \_SB_.PCI0.SBRG.CRS1 */
                }

                Method (DSRS, 2, NotSerialized)
                {
                    CreateWordField (Arg0, 0x01, IRQM)
                    CreateByteField (Arg0, 0x04, DMAM)
                    CreateWordField (Arg0, 0x08, IO11)
                    ENFG (CGLD (Arg1))
                    IOAL = (IO11 & 0xFF)
                    IOAH = (IO11 >> 0x08)
                    If (IRQM)
                    {
                        FindSetRightBit (IRQM, Local0)
                        INTR = (Local0 - 0x01)
                    }
                    Else
                    {
                        INTR = 0x00
                    }

                    If (DMAM)
                    {
                        FindSetRightBit (DMAM, Local0)
                        DMCH = (Local0 - 0x01)
                    }
                    Else
                    {
                        DMCH = 0x07
                    }

                    EXFG ()
                    DCNT (Arg1, 0x01)
                }

                Device (RMSC)
                {
                    Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                    Name (_UID, 0x10)  // _UID: Unique ID
                    Name (CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0010,             // Range Minimum
                            0x0010,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0022,             // Range Minimum
                            0x0022,             // Range Maximum
                            0x00,               // Alignment
                            0x1E,               // Length
                            )
                        IO (Decode16,
                            0x0044,             // Range Minimum
                            0x0044,             // Range Maximum
                            0x00,               // Alignment
                            0x1C,               // Length
                            )
                        IO (Decode16,
                            0x0062,             // Range Minimum
                            0x0062,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0065,             // Range Minimum
                            0x0065,             // Range Maximum
                            0x00,               // Alignment
                            0x0B,               // Length
                            )
                        IO (Decode16,
                            0x0072,             // Range Minimum
                            0x0072,             // Range Maximum
                            0x00,               // Alignment
                            0x0E,               // Length
                            )
                        IO (Decode16,
                            0x0080,             // Range Minimum
                            0x0080,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0084,             // Range Minimum
                            0x0084,             // Range Maximum
                            0x00,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0088,             // Range Minimum
                            0x0088,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x008C,             // Range Minimum
                            0x008C,             // Range Maximum
                            0x00,               // Alignment
                            0x03,               // Length
                            )
                        IO (Decode16,
                            0x0090,             // Range Minimum
                            0x0090,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x00A2,             // Range Minimum
                            0x00A2,             // Range Maximum
                            0x00,               // Alignment
                            0x1E,               // Length
                            )
                        IO (Decode16,
                            0x00E0,             // Range Minimum
                            0x00E0,             // Range Maximum
                            0x00,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x04D0,             // Range Minimum
                            0x04D0,             // Range Maximum
                            0x00,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y08)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y09)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y0A)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y0B)
                        Memory32Fixed (ReadWrite,
                            0xFED1C000,         // Address Base
                            0x00004000,         // Address Length
                            )
                        Memory32Fixed (ReadWrite,
                            0xFED20000,         // Address Base
                            0x00070000,         // Address Length
                            )
                        Memory32Fixed (ReadWrite,
                            0xFFB00000,         // Address Base
                            0x00100000,         // Address Length
                            )
                        Memory32Fixed (ReadWrite,
                            0xFFF00000,         // Address Base
                            0x00100000,         // Address Length
                            )
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y08._MIN, GP00)  // _MIN: Minimum Base Address
                        CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y08._MAX, GP01)  // _MAX: Maximum Base Address
                        CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y08._LEN, GP0L)  // _LEN: Length
                        GP00 = PMBS /* \PMBS */
                        GP01 = PMBS /* \PMBS */
                        GP0L = PMLN /* \PMLN */
                        If (SMBH)
                        {
                            If (SMBS)
                            {
                                CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._MIN, GP10)  // _MIN: Minimum Base Address
                                CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._MAX, GP11)  // _MAX: Maximum Base Address
                                CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._LEN, GP1L)  // _LEN: Length
                                GP10 = SMBS /* \SMBS */
                                GP11 = SMBS /* \SMBS */
                                GP1L = SMBL /* \SMBL */
                            }
                        }

                        If (GPBS)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._MIN, GP20)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._MAX, GP21)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._LEN, GP2L)  // _LEN: Length
                            GP20 = GPBS /* \GPBS */
                            GP21 = GPBS /* \GPBS */
                            GP2L = GPLN /* \GPLN */
                        }

                        If (CPUC >= 0x02)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._MIN, GP30)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._MAX, GP31)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._LEN, GP3L)  // _LEN: Length
                            GP30 = 0x0900
                            GP31 = 0x0900
                            If (CPUC >= 0x04)
                            {
                                GP3L = 0x20
                            }
                            Else
                            {
                                GP3L = 0x10
                            }
                        }

                        Return (CRS) /* \_SB_.PCI0.SBRG.RMSC.CRS_ */
                    }
                }

                Device (P3F6)
                {
                    Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                    Name (_UID, 0x03F6)  // _UID: Unique ID
                    Method (_STA, 0, NotSerialized)  // _STA: Status
                    {
                        Local1 = 0x0F
                        Local0 = \_SB.PCI0.IDE0.PAMD
                        Local0 &= 0xF5
                        If (Local0 == 0x80)
                        {
                            Local1 = 0x00
                        }

                        Local0 = \_SB.PCI0.IDE1.SAMD
                        Local0 &= 0xF5
                        If (Local0 == 0x80)
                        {
                            Local1 = 0x00
                        }

                        Return (Local1)
                    }

                    Name (CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x03F6,             // Range Minimum
                            0x03F6,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        Return (CRS) /* \_SB_.PCI0.SBRG.P3F6.CRS_ */
                    }
                }

                OperationRegion (IODC, PCI_Config, 0x80, 0x0A)
                Field (IODC, ByteAcc, NoLock, Preserve)
                {
                    CADC,   3, 
                        ,   1, 
                    CBDC,   3, 
                    Offset (0x01), 
                    LPDC,   2, 
                        ,   2, 
                    FDDC,   1, 
                    Offset (0x02), 
                    CAEN,   1, 
                    CBEN,   1, 
                    LPEN,   1, 
                    FDEN,   1, 
                    Offset (0x03), 
                    GLEN,   1, 
                    GHEN,   1, 
                    KBEN,   1, 
                    MCEN,   1, 
                    C1EN,   1, 
                    C2EN,   1, 
                    Offset (0x04), 
                    G1EN,   1, 
                        ,   6, 
                    G1D1,   1, 
                    G1D2,   8, 
                    Offset (0x08), 
                    G2EN,   1, 
                        ,   3, 
                    G2D1,   4, 
                    G2D2,   8
                }

                Method (PDEC, 2, NotSerialized)
                {
                    If (Arg0 == 0x00)
                    {
                        If (Arg1 == 0x03F8)
                        {
                            CADC = 0x00
                        }

                        If (Arg1 == 0x02F8)
                        {
                            CADC = 0x01
                        }

                        If (Arg1 == 0x02E8)
                        {
                            CADC = 0x05
                        }

                        If (Arg1 == 0x03E8)
                        {
                            CADC = 0x07
                        }

                        CAEN = One
                    }

                    If (Arg0 == 0x01)
                    {
                        If (Arg1 == 0x03F8)
                        {
                            CBDC = 0x00
                        }

                        If (Arg1 == 0x02F8)
                        {
                            CBDC = 0x01
                        }

                        If (Arg1 == 0x02E8)
                        {
                            CBDC = 0x05
                        }

                        If (Arg1 == 0x03E8)
                        {
                            CBDC = 0x07
                        }

                        CBEN = One
                    }

                    If (Arg0 == 0x02)
                    {
                        If (Arg1 == 0x0378)
                        {
                            LPDC = 0x00
                        }

                        If (Arg1 == 0x0278)
                        {
                            LPDC = 0x01
                        }

                        If (Arg1 == 0x03BC)
                        {
                            LPDC = 0x02
                        }

                        LPEN = One
                    }

                    If (Arg0 == 0x08)
                    {
                        If (Arg1 == 0x0200)
                        {
                            GLEN = One
                            GHEN = Zero
                        }

                        If (Arg1 == 0x0208)
                        {
                            GLEN = Zero
                            GHEN = One
                        }
                    }
                }

                Device (HPET)
                {
                    Name (_HID, EisaId ("PNP0103") /* HPET System Timer */)  // _HID: Hardware ID
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0xFED00000,         // Address Base
                            0x00000400,         // Address Length
                            _Y0C)
                    })
                    OperationRegion (HPTC, SystemMemory, HTBA, 0x04)
                    Field (HPTC, ByteAcc, NoLock, Preserve)
                    {
                        HPTS,   2, 
                            ,   5, 
                        HPTE,   1, 
                        Offset (0x04)
                    }

                    Method (_STA, 0, NotSerialized)  // _STA: Status
                    {
                        If (OSFL () == 0x00)
                        {
                            If (HPTE)
                            {
                                Return (0x0F)
                            }
                        }
                        ElseIf (HPTE)
                        {
                            Return (0x0B)
                        }

                        Return (0x00)
                    }

                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateDWordField (CRS, \_SB.PCI0.SBRG.HPET._Y0C._BAS, HPT)  // _BAS: Base Address
                        Local0 = (HPTS * 0x1000)
                        HPT = (Local0 + 0xFED00000)
                        Return (CRS) /* \_SB_.PCI0.SBRG.HPET.CRS_ */
                    }
                }

                Scope (\)
                {
                    OperationRegion (\RAMW, SystemMemory, (TOPM - 0x00010000), 0x00010000)
                    Field (\RAMW, ByteAcc, NoLock, Preserve)
                    {
                        PAR0,   32, 
                        PAR1,   32
                    }

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

                    Method (ISMI, 1, Serialized)
                    {
                        SMIC = Arg0
                    }

                    Method (GNVS, 1, Serialized)
                    {
                        PAR0 = Arg0
                        ISMI (0x70)
                        Return (PAR1) /* \PAR1 */
                    }

                    Method (SNVS, 2, Serialized)
                    {
                        PAR0 = Arg0
                        PAR1 = Arg1
                        ISMI (0x71)
                    }
                }

                Scope (\_SB.PCI0.SBRG)
                {
                    OperationRegion (DEB2, SystemIO, 0x80, 0x04)
                    Field (DEB2, WordAcc, NoLock, Preserve)
                    {
                        DBGE,   22
                    }

                    Scope (\)
                    {
                        Field (\RAMW, ByteAcc, NoLock, Preserve)
                        {
                            Offset (0x08), 
                            ADSP,   32, 
                            CFEQ,   16, 
                            CFSB,   8, 
                            AITU,   8, 
                            CPMU,   8, 
                            FSBF,   16, 
                            MEMF,   8, 
                            CHTP,   8, 
                            CHTE,   8, 
                            NOST,   4, 
                            NOSS,   4, 
                            NOS1,   4, 
                            NOS2,   4, 
                            OCPI,   4, 
                            OVCP,   4, 
                            CPUQ,   1, 
                            CQFS,   3, 
                            CQFT,   4, 
                            OVID,   8, 
                            UVID,   8, 
                            AIDI,   8, 
                            MMOV,   4, 
                            CPOV,   4, 
                            CHQ1,   1, 
                            CQS1,   3, 
                            CQF1,   4, 
                            VRM1,   8
                        }
                    }

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

                    Device (ASOC)
                    {
                        Mutex (AMTX, 0x00)
                        Name (_HID, "ATK0110")  // _HID: Hardware ID
                        Name (_UID, 0x01010110)  // _UID: Unique ID
                        Method (_STA, 0, NotSerialized)  // _STA: Status
                        {
                            If (AIDI)
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                Return (0x0F)
                            }
                        }

                        Name (MBIF, Package (0x08)
                        {
                            0x01, 
                            "P5GC-MX", 
                            0x01, 
                            0x00, 
                            0x02, 
                            0x00, 
                            0x00, 
                            0x00
                        })
                        Method (ASIF, 0, NotSerialized)
                        {
                            Return (MBIF) /* \_SB_.PCI0.SBRG.ASOC.MBIF */
                        }

                        Name (QCFN, Package (0x05)
                        {
                            0x04060003, 
                            "CPU Q-Fan Control", 
                            0x00, 
                            0x01, 
                            0x00030001
                        })
                        Name (QFLO, Package (0x06)
                        {
                            0x04050004, 
                            "CPU Q-Fan Ratio", 
                            0x3C, 
                            0x5A, 
                            0x05, 
                            0x01
                        })
                        Name (QFTP, Package (0x06)
                        {
                            0x04030005, 
                            "CPU Target Temperature", 
                            0x26, 
                            0x3E, 
                            0x09, 
                            0x00030001
                        })
                        Name (CFE1, Package (0x05)
                        {
                            0x04060006, 
                            "Chassis1 Q-Fan Control", 
                            0x00, 
                            0x01, 
                            0x00
                        })
                        Name (CFR1, Package (0x06)
                        {
                            0x04050007, 
                            "Chassis1 Q-Fan Ratio", 
                            0x3C, 
                            0x5A, 
                            0x05, 
                            0x00
                        })
                        Name (CFT1, Package (0x06)
                        {
                            0x04030008, 
                            "Chassis1 Target Temperature", 
                            0x26, 
                            0x3E, 
                            0x09, 
                            0x00
                        })
                        Name (EACF, Package (0x06)
                        {
                            0x04050009, 
                            "CPU Smart Fan Profile", 
                            0x00, 
                            0x02, 
                            0x03, 
                            0x00
                        })
                        Name (EAFC, Package (0x06)
                        {
                            0x0405000A, 
                            "Chassis Smart Fan Profile", 
                            0x00, 
                            0x02, 
                            0x03, 
                            0x00
                        })
                        Name (OBUF, Package (0x08)
                        {
                            QCFN, 
                            QFLO, 
                            QFTP, 
                            CFE1, 
                            CFR1, 
                            CFT1, 
                            EACF, 
                            EAFC
                        })
                        Method (OCIF, 0, Serialized)
                        {
                            Acquire (AMTX, 0xFFFF)
                            QFLO [0x05] = 0x00
                            QFTP [0x05] = 0x00
                            CFR1 [0x05] = 0x00
                            CFT1 [0x05] = 0x00
                            EACF [0x05] = 0x00010003
                            EAFC [0x05] = 0x00010003
                            Release (AMTX)
                            Return (OBUF) /* \_SB_.PCI0.SBRG.ASOC.OBUF */
                        }

                        Method (OCOP, 1, Serialized)
                        {
                            Acquire (AMTX, 0xFFFF)
                            Local1 = DerefOf (QCFN [0x00])
                            If (Arg0 == Local1)
                            {
                                CQFN [0x02] = CPUQ /* \CPUQ */
                                Release (AMTX)
                                Return (CQFN) /* \_SB_.PCI0.SBRG.ASOC.CQFN */
                            }

                            Local1 = DerefOf (EACF [0x00])
                            If (Arg0 == Local1)
                            {
                                EACC [0x02] = CQFS /* \CQFS */
                                Release (AMTX)
                                Return (EACC) /* \_SB_.PCI0.SBRG.ASOC.EACC */
                            }

                            Local1 = DerefOf (CFE1 [0x00])
                            If (Arg0 == Local1)
                            {
                                CQE1 [0x02] = CHQ1 /* \CHQ1 */
                                Release (AMTX)
                                Return (CQE1) /* \_SB_.PCI0.SBRG.ASOC.CQE1 */
                            }

                            Local1 = DerefOf (EAFC [0x00])
                            If (Arg0 == Local1)
                            {
                                EAFF [0x02] = CQS1 /* \CQS1 */
                                Release (AMTX)
                                Return (EAFF) /* \_SB_.PCI0.SBRG.ASOC.EAFF */
                            }

                            Release (AMTX)
                        }

                        Name (CQFN, Package (0x06)
                        {
                            0x04060003, 
                            0x00, 
                            0x00, 
                            0x01, 
                            "Disabled", 
                            "Enabled"
                        })
                        Name (QFNR, Package (0x09)
                        {
                            0x04050004, 
                            0x5A, 
                            0x00, 
                            0x01, 
                            "Auto", 
                            "90%", 
                            "80%", 
                            "70%", 
                            "60%"
                        })
                        Name (EACC, Package (0x07)
                        {
                            0x04050009, 
                            0x00, 
                            0x00, 
                            0x01, 
                            "Optimal", 
                            "Silent", 
                            "Performance"
                        })
                        Name (EAFF, Package (0x07)
                        {
                            0x0405000A, 
                            0x00, 
                            0x00, 
                            0x00, 
                            "Optimal", 
                            "Silent", 
                            "Performance"
                        })
                        Name (QFNT, Package (0x0F)
                        {
                            0x04030005, 
                            0x42, 
                            0x05, 
                            0x01, 
                            "51", 
                            "54", 
                            "57", 
                            "60", 
                            "63", 
                            "66", 
                            "69", 
                            "72", 
                            "75", 
                            "78", 
                            "81"
                        })
                        Name (CQE1, Package (0x06)
                        {
                            0x04060006, 
                            0x00, 
                            0x00, 
                            0x00, 
                            "Disabled", 
                            "Enabled"
                        })
                        Name (CQR1, Package (0x09)
                        {
                            0x04050007, 
                            0x5A, 
                            0x00, 
                            0x01, 
                            "Auto", 
                            "90%", 
                            "80%", 
                            "70%", 
                            "60%"
                        })
                        Name (CQT1, Package (0x0F)
                        {
                            0x04030008, 
                            0x42, 
                            0x05, 
                            0x01, 
                            "51", 
                            "54", 
                            "57", 
                            "60", 
                            "63", 
                            "66", 
                            "69", 
                            "72", 
                            "75", 
                            "78", 
                            "81"
                        })
                        Name (OCST, Package (0x17)
                        {
                            Package (0x02)
                            {
                                0x01010000, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x01060001, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x02010002, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x07010003, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x05050004, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x08050005, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x08050006, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04040007, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x01020008, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x02020009, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x0702000A, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x0106000B, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x0906000C, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x0806000D, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04060003, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04050004, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04030005, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04060006, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04050007, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04030008, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x04050009, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x0405000A, 
                                0x01
                            }, 

                            Package (0x02)
                            {
                                0x0806000E, 
                                0x01
                            }
                        })
                        Method (PROC, 3, Serialized)
                        {
                            Acquire (AMTX, 0xFFFF)
                            Local1 = DerefOf (QCFN [0x00])
                            If (Arg0 == Local1)
                            {
                                If (Arg1 != CPUQ)
                                {
                                    If (Arg2 == 0x00)
                                    {
                                        DerefOf (OCST [0x0E]) [0x01] = 0x01
                                        Release (AMTX)
                                        Return (0x01)
                                    }
                                    ElseIf (Arg1 == 0x01)
                                    {
                                        Local4 = 0x03
                                    }
                                    Else
                                    {
                                        Local4 = 0x00
                                    }
                                }
                                Else
                                {
                                    DerefOf (OCST [0x0E]) [0x01] = 0x01
                                    Release (AMTX)
                                    Return (0x01)
                                }
                            }

                            Local1 = DerefOf (EACF [0x00])
                            If (Arg0 == Local1)
                            {
                                If (Arg1 != CQFS)
                                {
                                    If (Arg2 == 0x00)
                                    {
                                        DerefOf (OCST [0x14]) [0x01] = 0x01
                                        Release (AMTX)
                                        Return (0x01)
                                    }
                                    Else
                                    {
                                        Local0 = Arg1
                                        CQFS = Local0
                                        Local0 *= 0x0A
                                        Local0 += 0x41
                                        If (Local0 == 0x55)
                                        {
                                            Local0 -= 0x1E
                                        }

                                        ^^SIOR.BSEL = 0x00
                                        ^^SIOR.TRGT = Local0
                                        ^^SIOR.CFNS = 0x00
                                        Sleep (0x64)
                                        ^^SIOR.CFNS = 0x03
                                        DerefOf (OCST [0x14]) [0x01] = 0x01
                                        SMID = 0x0A
                                        SMIC = 0xAB
                                        Release (AMTX)
                                        Return (0x01)
                                    }
                                }
                                Else
                                {
                                    DerefOf (OCST [0x14]) [0x01] = 0x01
                                    Release (AMTX)
                                    Return (0x01)
                                }
                            }

                            Local1 = DerefOf (CFE1 [0x00])
                            If (Arg0 == Local1)
                            {
                                If (Arg1 != CHQ1)
                                {
                                    If (Arg2 == 0x00)
                                    {
                                        DerefOf (OCST [0x11]) [0x01] = 0x01
                                        Release (AMTX)
                                        Return (0x01)
                                    }
                                    Else
                                    {
                                        CHQ1 = Arg1
                                        DerefOf (OCST [0x11]) [0x01] = 0x01
                                        ^^SIOR.BSEL = 0x00
                                        ^^SIOR.CHNS = Arg1
                                        SMID = 0x0E
                                        SMIC = 0xAB
                                        Release (AMTX)
                                        Return (0x01)
                                    }
                                }
                                Else
                                {
                                    DerefOf (OCST [0x11]) [0x01] = 0x01
                                    Release (AMTX)
                                    Return (0x01)
                                }
                            }

                            Local1 = DerefOf (EAFC [0x00])
                            If (Arg0 == Local1)
                            {
                                If (Arg1 != CQS1)
                                {
                                    If (Arg2 == 0x00)
                                    {
                                        DerefOf (OCST [0x15]) [0x01] = 0x01
                                        Release (AMTX)
                                        Return (0x01)
                                    }
                                    Else
                                    {
                                        Local0 = Arg1
                                        CQS1 = Local0
                                        Local2 = (Local0 * 0x0A)
                                        Local2 += 0x28
                                        Local4 = (Local0 * 0x19)
                                        Local4 += 0xB2
                                        If (Local2 == 0x3C)
                                        {
                                            (Local2 - 0x1E)
                                            (Local4 - 0x4B)
                                        }

                                        ^^SIOR.BSEL = 0x00
                                        ^^SIOR.SYST = Local2
                                        ^^SIOR.SSUP = Local4
                                        ^^SIOR.SSDN = Local4
                                        DerefOf (OCST [0x15]) [0x01] = 0x01
                                        SMID = 0x0F
                                        SMIC = 0xAB
                                        Release (AMTX)
                                        Return (0x01)
                                    }
                                }
                                Else
                                {
                                    DerefOf (OCST [0x15]) [0x01] = 0x02
                                    Release (AMTX)
                                    Return (0x01)
                                }
                            }

                            Release (AMTX)
                        }

                        Name (PREB, Package (0x2E)
                        {
                            0x01010000, 
                            0x00, 
                            0x01060001, 
                            0x00, 
                            0x02010002, 
                            0x00, 
                            0x07010003, 
                            0x00, 
                            0x05050004, 
                            0x00, 
                            0x08050005, 
                            0x00, 
                            0x08050006, 
                            0x00, 
                            0x04040007, 
                            0x00, 
                            0x01020008, 
                            0x00, 
                            0x02020009, 
                            0x00, 
                            0x0702000A, 
                            0x00, 
                            0x0106000B, 
                            0x00, 
                            0x0906000C, 
                            0x00, 
                            0x0806000D, 
                            0x00, 
                            0x04060003, 
                            0x00, 
                            0x04050004, 
                            0x00, 
                            0x04030005, 
                            0x00, 
                            0x04060006, 
                            0x00, 
                            0x04050007, 
                            0x00, 
                            0x04030008, 
                            0x00, 
                            0x04050009, 
                            0x00, 
                            0x0405000A, 
                            0x00, 
                            0x0806000E, 
                            0x00
                        })
                        Method (GPRE, 1, Serialized)
                        {
                            Acquire (AMTX, 0xFFFF)
                            If (Arg0 == 0x00)
                            {
                                Release (AMTX)
                                Return (PREB) /* \_SB_.PCI0.SBRG.ASOC.PREB */
                            }
                            Else
                            {
                                PREB [0x1D] = CPUQ /* \CPUQ */
                                PREB [0x1F] = CQFS /* \CQFS */
                                PREB [0x21] = CQFT /* \CQFT */
                                Release (AMTX)
                                Return (PREB) /* \_SB_.PCI0.SBRG.ASOC.PREB */
                            }
                        }

                        Method (SPRE, 2, Serialized)
                        {
                            Acquire (AMTX, 0xFFFF)
                            Local0 = DerefOf (DerefOf (PREB [0x00]) [0x00])
                            Local1 = DerefOf (DerefOf (PREB [0x00]) [0x01])
                            Local2 = PROC (Local0, Local1, 0x00)
                            PROC (Local0, Local1, 0x01)
                            Release (AMTX)
                        }
                    }
                }

                Device (\_SB.PCI0.PCIE)
                {
                    Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                    Name (_UID, 0x11)  // _UID: Unique ID
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0xE0000000,         // Address Base
                            0x10000000,         // Address Length
                            _Y0D)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateDWordField (CRS, \_SB.PCI0.PCIE._Y0D._BAS, BAS1)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.PCI0.PCIE._Y0D._LEN, LEN1)  // _LEN: Length
                        BAS1 = \PCIB
                        LEN1 = \PCIL
                        Return (CRS) /* \_SB_.PCI0.PCIE.CRS_ */
                    }
                }

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */)  // _HID: Hardware ID
                    Name (_CID, EisaId ("PNP030B"))  // _CID: Compatible ID
                    Method (_STA, 0, NotSerialized)  // _STA: Status
                    {
                        Local0 = (0x01 << 0x0A)
                        If (IOST & Local0)
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

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

                Method (PS2K._PSW, 1, NotSerialized)  // _PSW: Power State Wake
                {
                    If (!((OSFL () == 0x01) || (OSFL () == 0x02)))
                    {
                        KBFG = Arg0
                    }
                }

                Method (PS2K._PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x1D, 0x04))
                }

                Device (PS2M)
                {
                    Name (_HID, EisaId ("PNP0F03") /* Microsoft PS/2-style Mouse */)  // _HID: Hardware ID
                    Name (_CID, EisaId ("PNP0F13") /* PS/2 Mouse */)  // _CID: Compatible ID
                    Method (_STA, 0, NotSerialized)  // _STA: Status
                    {
                        Local0 = (0x01 << 0x0C)
                        If (IOST & Local0)
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Name (CRS1, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {12}
                    })
                    Name (CRS2, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Range Minimum
                            0x0060,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0064,             // Range Minimum
                            0x0064,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {12}
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        Local0 = (0x01 << 0x0A)
                        If (IOST & Local0)
                        {
                            Return (CRS1) /* \_SB_.PCI0.SBRG.PS2M.CRS1 */
                        }
                        Else
                        {
                            Return (CRS2) /* \_SB_.PCI0.SBRG.PS2M.CRS2 */
                        }
                    }
                }

                Method (PS2M._PSW, 1, NotSerialized)  // _PSW: Power State Wake
                {
                    If (!((OSFL () == 0x01) || (OSFL () == 0x02)))
                    {
                        MSFG = Arg0
                    }
                }

                Method (PS2M._PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x1D, 0x04))
                }

                Device (OMSC)
                {
                    Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                    Name (_UID, 0x00)  // _UID: Unique ID
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y0E)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y0F)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        If (APIC)
                        {
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0E._LEN, ML01)  // _LEN: Length
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0E._BAS, MB01)  // _BAS: Base Address
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0F._LEN, ML02)  // _LEN: Length
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0F._BAS, MB02)  // _BAS: Base Address
                            MB01 = 0xFEC00000
                            ML01 = 0x1000
                            MB02 = 0xFEE00000
                            ML02 = 0x1000
                        }

                        Return (CRS) /* \_SB_.PCI0.SBRG.OMSC.CRS_ */
                    }
                }

                Device (\_SB.RMEM)
                {
                    Name (_HID, EisaId ("PNP0C01") /* System Board */)  // _HID: Hardware ID
                    Name (_UID, 0x01)  // _UID: Unique ID
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0x00000000,         // Address Base
                            0x000A0000,         // Address Length
                            )
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y10)
                        Memory32Fixed (ReadOnly,
                            0x000E0000,         // Address Base
                            0x00020000,         // Address Length
                            _Y11)
                        Memory32Fixed (ReadWrite,
                            0x00100000,         // Address Base
                            0x00000000,         // Address Length
                            _Y12)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y13)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateDWordField (CRS, \_SB.RMEM._Y10._BAS, BAS1)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.RMEM._Y10._LEN, LEN1)  // _LEN: Length
                        CreateDWordField (CRS, \_SB.RMEM._Y11._BAS, BAS2)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.RMEM._Y11._LEN, LEN2)  // _LEN: Length
                        CreateDWordField (CRS, \_SB.RMEM._Y12._LEN, LEN3)  // _LEN: Length
                        CreateDWordField (CRS, \_SB.RMEM._Y13._BAS, BAS4)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.RMEM._Y13._LEN, LEN4)  // _LEN: Length
                        If (!OSFL ())
                        {
                            If (MG1B)
                            {
                                If (MG1B > 0x000C0000)
                                {
                                    BAS1 = 0x000C0000
                                    LEN1 = (MG1B - BAS1) /* \_SB_.RMEM._CRS.BAS1 */
                                }
                                Else
                                {
                                    BAS1 = MG1B /* \MG1B */
                                    LEN1 = MG1L /* \MG1L */
                                }

                                BAS2 = (MG1B + MG1L) /* \MG1L */
                                LEN2 = (0x00100000 - BAS2) /* \_SB_.RMEM._CRS.BAS2 */
                            }
                        }

                        LEN3 = (MG2B - 0x00100000)
                        BAS4 = (MG2B + MG2L) /* \MG2L */
                        LEN4 = (0x00 - BAS4) /* \_SB_.RMEM._CRS.BAS4 */
                        Return (CRS) /* \_SB_.RMEM.CRS_ */
                    }
                }

                Device (UAR1)
                {
                    Name (_UID, 0x01)  // _UID: Unique ID
                    Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */)  // _HID: Hardware ID
                    Method (_STA, 0, NotSerialized)  // _STA: Status
                    {
                        Return (DSTA (0x00))
                    }

                    Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                    {
                        DCNT (0x00, 0x00)
                    }

                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        Return (DCRS (0x00, 0x00))
                    }

                    Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
                    {
                        DSRS (Arg0, 0x00)
                    }

                    Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
                    {
                        Return (CMPR) /* \_SB_.PCI0.SBRG.UAR1.CMPR */
                    }

                    Name (CMPR, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x00)
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        EndDependentFn ()
                    })
                }

                Method (UAR1._PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x08, 0x04))
                }

                Device (FWH)
                {
                    Name (_HID, EisaId ("INT0800") /* Intel 82802 Firmware Hub Device */)  // _HID: Hardware ID
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y14)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y15)
                    })
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y14._BAS, BS00)  // _BAS: Base Address
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y14._LEN, BL00)  // _LEN: Length
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y15._BAS, BS10)  // _BAS: Base Address
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y15._LEN, BL10)  // _LEN: Length
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        Local0 = 0xFF800000
                        FindSetRightBit (FHD0, Local1)
                        Local1--
                        If (Local1)
                        {
                            Local1 *= 0x00080000
                        }

                        Local2 = (Local0 + Local1)
                        BS00 = Local2
                        BS10 = (BS00 + 0x00400000)
                        BL00 = (0x00 - BS10) /* \_SB_.PCI0.SBRG.FWH_.BS10 */
                        BL10 = BL00 /* \_SB_.PCI0.SBRG.FWH_.BL00 */
                        Return (CRS) /* \_SB_.PCI0.SBRG.FWH_.CRS_ */
                    }
                }

                Device (FWHE)
                {
                    Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                    Name (_UID, 0x03)  // _UID: Unique ID
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y16)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateDWordField (CRS, \_SB.PCI0.SBRG.FWHE._Y16._BAS, BS00)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.PCI0.SBRG.FWHE._Y16._LEN, BL00)  // _LEN: Length
                        If (^^FWH.BS00 == 0x00)
                        {
                            ^^FWH._CRS ()
                        }

                        BS00 = (^^FWH.BS00 + ^^FWH.BL00) /* \_SB_.PCI0.SBRG.FWH_.BL00 */
                        BL00 = (^^FWH.BS10 - BS00) /* \_SB_.PCI0.SBRG.FWHE._CRS.BS00 */
                        Return (CRS) /* \_SB_.PCI0.SBRG.FWHE.CRS_ */
                    }
                }

                OperationRegion (FHR0, PCI_Config, FHDC, 0x01)
                Field (FHR0, ByteAcc, NoLock, Preserve)
                {
                    FHD0,   8
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x04, 0x04))
                }
            }

            Device (USB3)
            {
                Name (_ADR, 0x001D0002)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x0C, 0x04))
                }
            }

            Device (USB4)
            {
                Name (_ADR, 0x001D0003)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x0E, 0x04))
                }
            }

            Device (MC97)
            {
                Name (_ADR, 0x001E0003)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x05, 0x04))
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x03, 0x04))
                }
            }

            Device (EUSB)
            {
                Name (_ADR, 0x001D0007)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x0D, 0x04))
                }
            }

            Device (IDE0)
            {
                Name (_ADR, 0x001F0001)  // _ADR: Address
                Name (\_SB.PCI0.NATA, Package (0x01)
                {
                    0x001F0001
                })
                Name (REGF, 0x01)
                Method (_REG, 2, NotSerialized)  // _REG: Region Availability
                {
                    If (Arg0 == 0x02)
                    {
                        REGF = Arg1
                    }
                }

                Name (TIM0, Package (0x08)
                {
                    Package (0x04)
                    {
                        0x78, 
                        0xB4, 
                        0xF0, 
                        0x0384
                    }, 

                    Package (0x04)
                    {
                        0x23, 
                        0x21, 
                        0x10, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0B, 
                        0x09, 
                        0x04, 
                        0x00
                    }, 

                    Package (0x06)
                    {
                        0x70, 
                        0x49, 
                        0x36, 
                        0x27, 
                        0x19, 
                        0x14
                    }, 

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

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

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

                    Package (0x04)
                    {
                        0x02, 
                        0x01, 
                        0x00, 
                        0x00
                    }
                })
                Name (TMD0, Buffer (0x14) {})
                CreateDWordField (TMD0, 0x00, PIO0)
                CreateDWordField (TMD0, 0x04, DMA0)
                CreateDWordField (TMD0, 0x08, PIO1)
                CreateDWordField (TMD0, 0x0C, DMA1)
                CreateDWordField (TMD0, 0x10, CHNF)
                OperationRegion (CFG2, PCI_Config, 0x40, 0x20)
                Field (CFG2, DWordAcc, NoLock, Preserve)
                {
                    PMPT,   4, 
                    PSPT,   4, 
                    PMRI,   6, 
                    Offset (0x02), 
                    SMPT,   4, 
                    SSPT,   4, 
                    SMRI,   6, 
                    Offset (0x04), 
                    PSRI,   4, 
                    SSRI,   4, 
                    Offset (0x08), 
                    PM3E,   1, 
                    PS3E,   1, 
                    SM3E,   1, 
                    SS3E,   1, 
                    Offset (0x0A), 
                    PMUT,   2, 
                        ,   2, 
                    PSUT,   2, 
                    Offset (0x0B), 
                    SMUT,   2, 
                        ,   2, 
                    SSUT,   2, 
                    Offset (0x0C), 
                    Offset (0x14), 
                    PM6E,   1, 
                    PS6E,   1, 
                    SM6E,   1, 
                    SS6E,   1, 
                    PMCR,   1, 
                    PSCR,   1, 
                    SMCR,   1, 
                    SSCR,   1, 
                        ,   4, 
                    PMAE,   1, 
                    PSAE,   1, 
                    SMAE,   1, 
                    SSAE,   1
                }

                Name (GMPT, 0x00)
                Name (GMUE, 0x00)
                Name (GMUT, 0x00)
                Name (GMCR, 0x00)
                Name (GSPT, 0x00)
                Name (GSUE, 0x00)
                Name (GSUT, 0x00)
                Name (GSCR, 0x00)
                Device (CHN0)
                {
                    Name (_ADR, 0x00)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Local1 = (PSCR << 0x01)
                        Local0 = (PMCR | Local1)
                        Local3 = (PMAE << 0x02)
                        Local4 = (PM6E << 0x01)
                        Local3 |= Local4
                        Local1 = (PM3E | Local3)
                        Local3 = (PMPT << 0x04)
                        Local1 |= Local3
                        Local3 = (PSAE << 0x02)
                        Local4 = (PS6E << 0x01)
                        Local3 |= Local4
                        Local2 = (PS3E | Local3)
                        Local3 = (PSPT << 0x04)
                        Local2 |= Local3
                        Return (GTM (PMRI, Local1, PMUT, PSRI, Local2, PSUT, Local0))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        Debug = Arg0
                        TMD0 = Arg0
                        Local3 = (PMAE << 0x02)
                        Local4 = (PM6E << 0x01)
                        Local3 |= Local4
                        Local0 = (PM3E | Local3)
                        Local3 = (PMPT << 0x04)
                        Local0 |= Local3
                        Local3 = (PSAE << 0x02)
                        Local4 = (PS6E << 0x01)
                        Local3 |= Local4
                        Local1 = (PS3E | Local3)
                        Local3 = (PSPT << 0x04)
                        Local1 |= Local3
                        GMPT = PMRI /* \_SB_.PCI0.IDE0.PMRI */
                        GMUE = Local0
                        GMUT = PMUT /* \_SB_.PCI0.IDE0.PMUT */
                        GMCR = PMCR /* \_SB_.PCI0.IDE0.PMCR */
                        GSPT = PSRI /* \_SB_.PCI0.IDE0.PSRI */
                        GSUE = Local1
                        GSUT = PSUT /* \_SB_.PCI0.IDE0.PSUT */
                        GSCR = PSCR /* \_SB_.PCI0.IDE0.PSCR */
                        STM ()
                        PMRI = GMPT /* \_SB_.PCI0.IDE0.GMPT */
                        Local0 = GMUE /* \_SB_.PCI0.IDE0.GMUE */
                        PMUT = GMUT /* \_SB_.PCI0.IDE0.GMUT */
                        PMCR = GMCR /* \_SB_.PCI0.IDE0.GMCR */
                        Local1 = GSUE /* \_SB_.PCI0.IDE0.GSUE */
                        PSUT = GSUT /* \_SB_.PCI0.IDE0.GSUT */
                        PSCR = GSCR /* \_SB_.PCI0.IDE0.GSCR */
                        If (Local0 & 0x01)
                        {
                            PM3E = 0x01
                        }
                        Else
                        {
                            PM3E = 0x00
                        }

                        If (Local0 & 0x02)
                        {
                            PM6E = 0x01
                        }
                        Else
                        {
                            PM6E = 0x00
                        }

                        If (Local0 & 0x04)
                        {
                            PMAE = 0x01
                        }
                        Else
                        {
                            PMAE = 0x00
                        }

                        If (Local1 & 0x01)
                        {
                            PS3E = 0x01
                        }
                        Else
                        {
                            PS3E = 0x00
                        }

                        If (Local1 & 0x02)
                        {
                            PS6E = 0x01
                        }
                        Else
                        {
                            PS6E = 0x00
                        }

                        If (Local1 & 0x04)
                        {
                            PSAE = 0x01
                        }
                        Else
                        {
                            PSAE = 0x00
                        }

                        ATA0 = GTF (0x00, Arg1)
                        ATA1 = GTF (0x01, Arg2)
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA0), FZTF))
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA1), FZTF))
                        }
                    }
                }

                Device (CHN1)
                {
                    Name (_ADR, 0x01)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Local1 = (SSCR << 0x01)
                        Local0 = (SMCR | Local1)
                        Local3 = (SMAE << 0x02)
                        Local4 = (SM6E << 0x01)
                        Local3 |= Local4
                        Local1 = (SM3E | Local3)
                        Local3 = (SMPT << 0x04)
                        Local1 |= Local3
                        Local3 = (SSAE << 0x02)
                        Local4 = (SS6E << 0x01)
                        Local3 |= Local4
                        Local2 = (SS3E | Local3)
                        Local3 = (SSPT << 0x04)
                        Local2 |= Local3
                        Return (GTM (SMRI, Local1, SMUT, SSRI, Local2, SSUT, Local0))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        Debug = Arg0
                        TMD0 = Arg0
                        Local3 = (SMAE << 0x02)
                        Local4 = (SM6E << 0x01)
                        Local3 |= Local4
                        Local0 = (SM3E | Local3)
                        Local3 = (SMPT << 0x04)
                        Local0 |= Local3
                        Local3 = (SSAE << 0x02)
                        Local4 = (SS6E << 0x01)
                        Local3 |= Local4
                        Local1 = (SS3E | Local3)
                        Local3 = (SSPT << 0x04)
                        Local1 |= Local3
                        GMPT = SMRI /* \_SB_.PCI0.IDE0.SMRI */
                        GMUE = Local0
                        GMUT = SMUT /* \_SB_.PCI0.IDE0.SMUT */
                        GMCR = SMCR /* \_SB_.PCI0.IDE0.SMCR */
                        GSPT = SSRI /* \_SB_.PCI0.IDE0.SSRI */
                        GSUE = Local1
                        GSUT = SSUT /* \_SB_.PCI0.IDE0.SSUT */
                        GSCR = SSCR /* \_SB_.PCI0.IDE0.SSCR */
                        STM ()
                        SMRI = GMPT /* \_SB_.PCI0.IDE0.GMPT */
                        Local0 = GMUE /* \_SB_.PCI0.IDE0.GMUE */
                        SMUT = GMUT /* \_SB_.PCI0.IDE0.GMUT */
                        SMCR = GMCR /* \_SB_.PCI0.IDE0.GMCR */
                        Local1 = GSUE /* \_SB_.PCI0.IDE0.GSUE */
                        SSUT = GSUT /* \_SB_.PCI0.IDE0.GSUT */
                        SSCR = GSCR /* \_SB_.PCI0.IDE0.GSCR */
                        If (Local0 & 0x01)
                        {
                            SM3E = 0x01
                        }
                        Else
                        {
                            SM3E = 0x00
                        }

                        If (Local0 & 0x02)
                        {
                            SM6E = 0x01
                        }
                        Else
                        {
                            SM6E = 0x00
                        }

                        If (Local0 & 0x04)
                        {
                            SMAE = 0x01
                        }
                        Else
                        {
                            SMAE = 0x00
                        }

                        If (Local1 & 0x01)
                        {
                            SS3E = 0x01
                        }
                        Else
                        {
                            SS3E = 0x00
                        }

                        If (Local1 & 0x02)
                        {
                            SS6E = 0x01
                        }
                        Else
                        {
                            SS6E = 0x00
                        }

                        If (Local1 & 0x04)
                        {
                            SSAE = 0x01
                        }
                        Else
                        {
                            SSAE = 0x00
                        }

                        ATA2 = GTF (0x00, Arg1)
                        ATA3 = GTF (0x01, Arg2)
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA2), FZTF))
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA3), FZTF))
                        }
                    }
                }

                Method (GTM, 7, Serialized)
                {
                    PIO0 = Ones
                    PIO1 = Ones
                    DMA0 = Ones
                    DMA1 = Ones
                    CHNF = 0x10
                    If (REGF) {}
                    Else
                    {
                        Return (TMD0) /* \_SB_.PCI0.IDE0.TMD0 */
                    }

                    If (Arg1 & 0x20)
                    {
                        CHNF |= 0x02
                    }

                    Local6 = Match (DerefOf (TIM0 [0x01]), MEQ, Arg0, MTR, 0x00, 
                        0x00)
                    Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6])
                    DMA0 = Local7
                    PIO0 = Local7
                    If (Arg4 & 0x20)
                    {
                        CHNF |= 0x08
                    }

                    Local6 = Match (DerefOf (TIM0 [0x02]), MEQ, Arg3, MTR, 0x00, 
                        0x00)
                    Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6])
                    DMA1 = Local7
                    PIO1 = Local7
                    If (Arg1 & 0x07)
                    {
                        Local5 = Arg2
                        If (Arg1 & 0x02)
                        {
                            Local5 += 0x02
                        }

                        If (Arg1 & 0x04)
                        {
                            Local5 += 0x04
                        }

                        DMA0 = DerefOf (DerefOf (TIM0 [0x03]) [Local5])
                        CHNF |= 0x01
                    }

                    If (Arg4 & 0x07)
                    {
                        Local5 = Arg5
                        If (Arg4 & 0x02)
                        {
                            Local5 += 0x02
                        }

                        If (Arg4 & 0x04)
                        {
                            Local5 += 0x04
                        }

                        DMA1 = DerefOf (DerefOf (TIM0 [0x03]) [Local5])
                        CHNF |= 0x04
                    }

                    Debug = TMD0 /* \_SB_.PCI0.IDE0.TMD0 */
                    Return (TMD0) /* \_SB_.PCI0.IDE0.TMD0 */
                }

                Method (STM, 0, Serialized)
                {
                    If (REGF) {}
                    Else
                    {
                        GMUE = 0x00
                        GMUT = 0x00
                        GSUE = 0x00
                        GSUT = 0x00
                        If (CHNF & 0x01)
                        {
                            Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA0, MTR, 0x00, 
                                0x00)
                            If (Local0 > 0x05)
                            {
                                Local0 = 0x05
                            }

                            GMUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0])
                            GMUE |= 0x01
                            If (Local0 > 0x02)
                            {
                                GMUE |= 0x02
                            }

                            If (Local0 > 0x04)
                            {
                                GMUE &= 0xFD
                                GMUE |= 0x04
                            }
                        }
                        ElseIf ((PIO0 == Ones) | (PIO0 == 0x00))
                        {
                            If ((DMA0 < Ones) & (DMA0 > 0x00))
                            {
                                PIO0 = DMA0 /* \_SB_.PCI0.IDE0.DMA0 */
                                GMUE |= 0x80
                            }
                        }

                        If (CHNF & 0x04)
                        {
                            Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA1, MTR, 0x00, 
                                0x00)
                            If (Local0 > 0x05)
                            {
                                Local0 = 0x05
                            }

                            GSUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0])
                            GSUE |= 0x01
                            If (Local0 > 0x02)
                            {
                                GSUE |= 0x02
                            }

                            If (Local0 > 0x04)
                            {
                                GSUE &= 0xFD
                                GSUE |= 0x04
                            }
                        }
                        ElseIf ((PIO1 == Ones) | (PIO1 == 0x00))
                        {
                            If ((DMA1 < Ones) & (DMA1 > 0x00))
                            {
                                PIO1 = DMA1 /* \_SB_.PCI0.IDE0.DMA1 */
                                GSUE |= 0x80
                            }
                        }

                        If (CHNF & 0x02)
                        {
                            GMUE |= 0x20
                        }

                        If (CHNF & 0x08)
                        {
                            GSUE |= 0x20
                        }

                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO0, MTR, 0x00, 
                            0x00) & 0x07)
                        Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0])
                        GMPT = Local1
                        If (Local0 < 0x03)
                        {
                            GMUE |= 0x50
                        }

                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO1, MTR, 0x00, 
                            0x00) & 0x07)
                        Local1 = DerefOf (DerefOf (TIM0 [0x02]) [Local0])
                        GSPT = Local1
                        If (Local0 < 0x03)
                        {
                            GSUE |= 0x50
                        }
                    }
                }

                Name (AT01, Buffer (0x07)
                {
                     0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF         /* ....... */
                })
                Name (AT02, Buffer (0x07)
                {
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90         /* ....... */
                })
                Name (AT03, Buffer (0x07)
                {
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6         /* ....... */
                })
                Name (AT04, Buffer (0x07)
                {
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91         /* ....... */
                })
                Name (ATA0, Buffer (0x1D) {})
                Name (ATA1, Buffer (0x1D) {})
                Name (ATA2, Buffer (0x1D) {})
                Name (ATA3, Buffer (0x1D) {})
                Name (ATAB, Buffer (0x1D) {})
                CreateByteField (ATAB, 0x00, CMDC)
                Method (GTFB, 3, Serialized)
                {
                    Local0 = (CMDC * 0x38)
                    Local1 = (Local0 + 0x08)
                    CreateField (ATAB, Local1, 0x38, CMDX)
                    Local0 = (CMDC * 0x07)
                    CreateByteField (ATAB, (Local0 + 0x02), A001)
                    CreateByteField (ATAB, (Local0 + 0x06), A005)
                    CMDX = Arg0
                    A001 = Arg1
                    A005 = Arg2
                    CMDC++
                }

                Method (GTF, 2, Serialized)
                {
                    Debug = Arg1
                    CMDC = 0x00
                    Name (ID49, 0x0C00)
                    Name (ID59, 0x00)
                    Name (ID53, 0x04)
                    Name (ID63, 0x0F00)
                    Name (ID88, 0x0F00)
                    Name (IRDY, 0x01)
                    Name (PIOT, 0x00)
                    Name (DMAT, 0x00)
                    If (SizeOf (Arg1) == 0x0200)
                    {
                        CreateWordField (Arg1, 0x62, IW49)
                        ID49 = IW49 /* \_SB_.PCI0.IDE0.GTF_.IW49 */
                        CreateWordField (Arg1, 0x6A, IW53)
                        ID53 = IW53 /* \_SB_.PCI0.IDE0.GTF_.IW53 */
                        CreateWordField (Arg1, 0x7E, IW63)
                        ID63 = IW63 /* \_SB_.PCI0.IDE0.GTF_.IW63 */
                        CreateWordField (Arg1, 0x76, IW59)
                        ID59 = IW59 /* \_SB_.PCI0.IDE0.GTF_.IW59 */
                        CreateWordField (Arg1, 0xB0, IW88)
                        ID88 = IW88 /* \_SB_.PCI0.IDE0.GTF_.IW88 */
                    }

                    Local7 = 0xA0
                    If (Arg0)
                    {
                        Local7 = 0xB0
                        IRDY = (CHNF & 0x08)
                        If (CHNF & 0x10)
                        {
                            PIOT = PIO1 /* \_SB_.PCI0.IDE0.PIO1 */
                        }
                        Else
                        {
                            PIOT = PIO0 /* \_SB_.PCI0.IDE0.PIO0 */
                        }

                        If (CHNF & 0x04)
                        {
                            If (CHNF & 0x10)
                            {
                                DMAT = DMA1 /* \_SB_.PCI0.IDE0.DMA1 */
                            }
                            Else
                            {
                                DMAT = DMA0 /* \_SB_.PCI0.IDE0.DMA0 */
                            }
                        }
                    }
                    Else
                    {
                        IRDY = (CHNF & 0x02)
                        PIOT = PIO0 /* \_SB_.PCI0.IDE0.PIO0 */
                        If (CHNF & 0x01)
                        {
                            DMAT = DMA0 /* \_SB_.PCI0.IDE0.DMA0 */
                        }
                    }

                    If (((ID53 & 0x04) && (ID88 & 0xFF00)) && DMAT)
                    {
                        Local1 = Match (DerefOf (TIM0 [0x03]), MLE, DMAT, MTR, 0x00, 
                            0x00)
                        If (Local1 > 0x05)
                        {
                            Local1 = 0x05
                        }

                        GTFB (AT01, (0x40 | Local1), Local7)
                    }
                    ElseIf ((ID63 & 0xFF00) && PIOT)
                    {
                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, 
                            0x00) & 0x03)
                        Local1 = (0x20 | DerefOf (DerefOf (TIM0 [0x07]) [Local0]))
                        GTFB (AT01, Local1, Local7)
                    }

                    If (IRDY)
                    {
                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, 
                            0x00) & 0x07)
                        Local1 = (0x08 | DerefOf (DerefOf (TIM0 [0x06]) [Local0]))
                        GTFB (AT01, Local1, Local7)
                    }
                    ElseIf (ID49 & 0x0400)
                    {
                        GTFB (AT01, 0x01, Local7)
                    }

                    If ((ID59 & 0x0100) && (ID59 & 0xFF))
                    {
                        GTFB (AT03, (ID59 & 0xFF), Local7)
                    }

                    Debug = ATAB /* \_SB_.PCI0.IDE0.ATAB */
                    Return (ATAB) /* \_SB_.PCI0.IDE0.ATAB */
                }

                Method (RATA, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x00, CMDN)
                    Local0 = (CMDN * 0x38)
                    CreateField (Arg0, 0x08, Local0, RETB)
                    Debug = RETB /* \_SB_.PCI0.IDE0.RATA.RETB */
                    Return (RETB) /* \_SB_.PCI0.IDE0.RATA.RETB */
                }
            }

            Device (IDE1)
            {
                Name (_ADR, 0x001F0002)  // _ADR: Address
                Name (\FZTF, Buffer (0x07)
                {
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF5         /* ....... */
                })
                Name (REGF, 0x01)
                Method (_REG, 2, NotSerialized)  // _REG: Region Availability
                {
                    If (Arg0 == 0x02)
                    {
                        REGF = Arg1
                    }
                }

                Name (TIM0, Package (0x08)
                {
                    Package (0x04)
                    {
                        0x78, 
                        0xB4, 
                        0xF0, 
                        0x0384
                    }, 

                    Package (0x04)
                    {
                        0x23, 
                        0x21, 
                        0x10, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0B, 
                        0x09, 
                        0x04, 
                        0x00
                    }, 

                    Package (0x06)
                    {
                        0x78, 
                        0x5A, 
                        0x3C, 
                        0x28, 
                        0x1E, 
                        0x14
                    }, 

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

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

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

                    Package (0x04)
                    {
                        0x02, 
                        0x01, 
                        0x00, 
                        0x00
                    }
                })
                Name (TMD0, Buffer (0x14) {})
                CreateDWordField (TMD0, 0x00, PIO0)
                CreateDWordField (TMD0, 0x04, DMA0)
                CreateDWordField (TMD0, 0x08, PIO1)
                CreateDWordField (TMD0, 0x0C, DMA1)
                CreateDWordField (TMD0, 0x10, CHNF)
                OperationRegion (CFG2, PCI_Config, 0x40, 0x20)
                Field (CFG2, DWordAcc, NoLock, Preserve)
                {
                    PMPT,   4, 
                    PSPT,   4, 
                    PMRI,   6, 
                    Offset (0x02), 
                    SMPT,   4, 
                    SSPT,   4, 
                    SMRI,   6, 
                    Offset (0x04), 
                    PSRI,   4, 
                    SSRI,   4, 
                    Offset (0x08), 
                    PM3E,   1, 
                    PS3E,   1, 
                    SM3E,   1, 
                    SS3E,   1, 
                    Offset (0x0A), 
                    PMUT,   2, 
                        ,   2, 
                    PSUT,   2, 
                    Offset (0x0B), 
                    SMUT,   2, 
                        ,   2, 
                    SSUT,   2, 
                    Offset (0x0C), 
                    Offset (0x14), 
                    PM6E,   1, 
                    PS6E,   1, 
                    SM6E,   1, 
                    SS6E,   1, 
                    PMCR,   1, 
                    PSCR,   1, 
                    SMCR,   1, 
                    SSCR,   1, 
                        ,   4, 
                    PMAE,   1, 
                    PSAE,   1, 
                    SMAE,   1, 
                    SSAE,   1
                }

                Name (GMPT, 0x00)
                Name (GMUE, 0x00)
                Name (GMUT, 0x00)
                Name (GMCR, 0x00)
                Name (GSPT, 0x00)
                Name (GSUE, 0x00)
                Name (GSUT, 0x00)
                Name (GSCR, 0x00)
                Device (CHN0)
                {
                    Name (_ADR, 0x00)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Local1 = (PSCR << 0x01)
                        Local0 = (PMCR | Local1)
                        Local3 = (PMAE << 0x02)
                        Local4 = (PM6E << 0x01)
                        Local3 |= Local4
                        Local1 = (PM3E | Local3)
                        Local3 = (PMPT << 0x04)
                        Local1 |= Local3
                        Local3 = (PSAE << 0x02)
                        Local4 = (PS6E << 0x01)
                        Local3 |= Local4
                        Local2 = (PS3E | Local3)
                        Local3 = (PSPT << 0x04)
                        Local2 |= Local3
                        Return (GTM (PMRI, Local1, PMUT, PSRI, Local2, PSUT, Local0))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        Debug = Arg0
                        TMD0 = Arg0
                        Local3 = (PMAE << 0x02)
                        Local4 = (PM6E << 0x01)
                        Local3 |= Local4
                        Local0 = (PM3E | Local3)
                        Local3 = (PMPT << 0x04)
                        Local0 |= Local3
                        Local3 = (PSAE << 0x02)
                        Local4 = (PS6E << 0x01)
                        Local3 |= Local4
                        Local1 = (PS3E | Local3)
                        Local3 = (PSPT << 0x04)
                        Local1 |= Local3
                        GMPT = PMRI /* \_SB_.PCI0.IDE1.PMRI */
                        GMUE = Local0
                        GMUT = PMUT /* \_SB_.PCI0.IDE1.PMUT */
                        GMCR = PMCR /* \_SB_.PCI0.IDE1.PMCR */
                        GSPT = PSRI /* \_SB_.PCI0.IDE1.PSRI */
                        GSUE = Local1
                        GSUT = PSUT /* \_SB_.PCI0.IDE1.PSUT */
                        GSCR = PSCR /* \_SB_.PCI0.IDE1.PSCR */
                        STM ()
                        PMRI = GMPT /* \_SB_.PCI0.IDE1.GMPT */
                        Local0 = GMUE /* \_SB_.PCI0.IDE1.GMUE */
                        PMUT = GMUT /* \_SB_.PCI0.IDE1.GMUT */
                        PMCR = GMCR /* \_SB_.PCI0.IDE1.GMCR */
                        Local1 = GSUE /* \_SB_.PCI0.IDE1.GSUE */
                        PSUT = GSUT /* \_SB_.PCI0.IDE1.GSUT */
                        PSCR = GSCR /* \_SB_.PCI0.IDE1.GSCR */
                        If (Local0 & 0x01)
                        {
                            PM3E = 0x01
                        }
                        Else
                        {
                            PM3E = 0x00
                        }

                        If (Local0 & 0x02)
                        {
                            PM6E = 0x01
                        }
                        Else
                        {
                            PM6E = 0x00
                        }

                        If (Local0 & 0x04)
                        {
                            PMAE = 0x01
                        }
                        Else
                        {
                            PMAE = 0x00
                        }

                        If (Local1 & 0x01)
                        {
                            PS3E = 0x01
                        }
                        Else
                        {
                            PS3E = 0x00
                        }

                        If (Local1 & 0x02)
                        {
                            PS6E = 0x01
                        }
                        Else
                        {
                            PS6E = 0x00
                        }

                        If (Local1 & 0x04)
                        {
                            PSAE = 0x01
                        }
                        Else
                        {
                            PSAE = 0x00
                        }

                        ATA0 = GTF (0x00, Arg1)
                        ATA1 = GTF (0x01, Arg2)
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA0), FZTF))
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA1), FZTF))
                        }
                    }
                }

                Device (CHN1)
                {
                    Name (_ADR, 0x01)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Local1 = (SSCR << 0x01)
                        Local0 = (SMCR | Local1)
                        Local3 = (SMAE << 0x02)
                        Local4 = (SM6E << 0x01)
                        Local3 |= Local4
                        Local1 = (SM3E | Local3)
                        Local3 = (SMPT << 0x04)
                        Local1 |= Local3
                        Local3 = (SSAE << 0x02)
                        Local4 = (SS6E << 0x01)
                        Local3 |= Local4
                        Local2 = (SS3E | Local3)
                        Local3 = (SSPT << 0x04)
                        Local2 |= Local3
                        Return (GTM (SMRI, Local1, SMUT, SSRI, Local2, SSUT, Local0))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        Debug = Arg0
                        TMD0 = Arg0
                        Local3 = (SMAE << 0x02)
                        Local4 = (SM6E << 0x01)
                        Local3 |= Local4
                        Local0 = (SM3E | Local3)
                        Local3 = (SMPT << 0x04)
                        Local0 |= Local3
                        Local3 = (SSAE << 0x02)
                        Local4 = (SS6E << 0x01)
                        Local3 |= Local4
                        Local1 = (SS3E | Local3)
                        Local3 = (SSPT << 0x04)
                        Local1 |= Local3
                        GMPT = SMRI /* \_SB_.PCI0.IDE1.SMRI */
                        GMUE = Local0
                        GMUT = SMUT /* \_SB_.PCI0.IDE1.SMUT */
                        GMCR = SMCR /* \_SB_.PCI0.IDE1.SMCR */
                        GSPT = SSRI /* \_SB_.PCI0.IDE1.SSRI */
                        GSUE = Local1
                        GSUT = SSUT /* \_SB_.PCI0.IDE1.SSUT */
                        GSCR = SSCR /* \_SB_.PCI0.IDE1.SSCR */
                        STM ()
                        SMRI = GMPT /* \_SB_.PCI0.IDE1.GMPT */
                        Local0 = GMUE /* \_SB_.PCI0.IDE1.GMUE */
                        SMUT = GMUT /* \_SB_.PCI0.IDE1.GMUT */
                        SMCR = GMCR /* \_SB_.PCI0.IDE1.GMCR */
                        Local1 = GSUE /* \_SB_.PCI0.IDE1.GSUE */
                        SSUT = GSUT /* \_SB_.PCI0.IDE1.GSUT */
                        SSCR = GSCR /* \_SB_.PCI0.IDE1.GSCR */
                        If (Local0 & 0x01)
                        {
                            SM3E = 0x01
                        }
                        Else
                        {
                            SM3E = 0x00
                        }

                        If (Local0 & 0x02)
                        {
                            SM6E = 0x01
                        }
                        Else
                        {
                            SM6E = 0x00
                        }

                        If (Local0 & 0x04)
                        {
                            SMAE = 0x01
                        }
                        Else
                        {
                            SMAE = 0x00
                        }

                        If (Local1 & 0x01)
                        {
                            SS3E = 0x01
                        }
                        Else
                        {
                            SS3E = 0x00
                        }

                        If (Local1 & 0x02)
                        {
                            SS6E = 0x01
                        }
                        Else
                        {
                            SS6E = 0x00
                        }

                        If (Local1 & 0x04)
                        {
                            SSAE = 0x01
                        }
                        Else
                        {
                            SSAE = 0x00
                        }

                        ATA2 = GTF (0x00, Arg1)
                        ATA3 = GTF (0x01, Arg2)
                    }

                    Device (DRV0)
                    {
                        Name (_ADR, 0x00)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA2), FZTF))
                        }
                    }

                    Device (DRV1)
                    {
                        Name (_ADR, 0x01)  // _ADR: Address
                        Method (_GTF, 0, NotSerialized)  // _GTF: Get Task File
                        {
                            Return (Concatenate (RATA (ATA3), FZTF))
                        }
                    }
                }

                Method (GTM, 7, Serialized)
                {
                    PIO0 = Ones
                    PIO1 = Ones
                    DMA0 = Ones
                    DMA1 = Ones
                    CHNF = 0x10
                    If (REGF) {}
                    Else
                    {
                        Return (TMD0) /* \_SB_.PCI0.IDE1.TMD0 */
                    }

                    If (Arg1 & 0x20)
                    {
                        CHNF |= 0x02
                    }

                    Local6 = Match (DerefOf (TIM0 [0x01]), MEQ, Arg0, MTR, 0x00, 
                        0x00)
                    Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6])
                    DMA0 = Local7
                    PIO0 = Local7
                    If (Arg4 & 0x20)
                    {
                        CHNF |= 0x08
                    }

                    Local6 = Match (DerefOf (TIM0 [0x02]), MEQ, Arg3, MTR, 0x00, 
                        0x00)
                    Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6])
                    DMA1 = Local7
                    PIO1 = Local7
                    If (Arg1 & 0x07)
                    {
                        Local5 = Arg2
                        If (Arg1 & 0x02)
                        {
                            Local5 += 0x02
                        }

                        If (Arg1 & 0x04)
                        {
                            Local5 += 0x04
                        }

                        DMA0 = DerefOf (DerefOf (TIM0 [0x03]) [Local5])
                        CHNF |= 0x01
                    }

                    If (Arg4 & 0x07)
                    {
                        Local5 = Arg5
                        If (Arg4 & 0x02)
                        {
                            Local5 += 0x02
                        }

                        If (Arg4 & 0x04)
                        {
                            Local5 += 0x04
                        }

                        DMA1 = DerefOf (DerefOf (TIM0 [0x03]) [Local5])
                        CHNF |= 0x04
                    }

                    Debug = TMD0 /* \_SB_.PCI0.IDE1.TMD0 */
                    Return (TMD0) /* \_SB_.PCI0.IDE1.TMD0 */
                }

                Method (STM, 0, Serialized)
                {
                    If (REGF)
                    {
                        GMUE = 0x00
                        GMUT = 0x00
                        GSUE = 0x00
                        GSUT = 0x00
                        If (CHNF & 0x01)
                        {
                            Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA0, MTR, 0x00, 
                                0x00)
                            If (Local0 > 0x05)
                            {
                                Local0 = 0x05
                            }

                            GMUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0])
                            GMUE |= 0x01
                            If (Local0 > 0x02)
                            {
                                GMUE |= 0x02
                            }

                            If (Local0 > 0x04)
                            {
                                GMUE &= 0xFD
                                GMUE |= 0x04
                            }
                        }
                        ElseIf ((PIO0 == Ones) | (PIO0 == 0x00))
                        {
                            If ((DMA0 < Ones) & (DMA0 > 0x00))
                            {
                                PIO0 = DMA0 /* \_SB_.PCI0.IDE1.DMA0 */
                                GMUE |= 0x80
                            }
                        }

                        If (CHNF & 0x04)
                        {
                            Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA1, MTR, 0x00, 
                                0x00)
                            If (Local0 > 0x05)
                            {
                                Local0 = 0x05
                            }

                            GSUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0])
                            GSUE |= 0x01
                            If (Local0 > 0x02)
                            {
                                GSUE |= 0x02
                            }

                            If (Local0 > 0x04)
                            {
                                GSUE &= 0xFD
                                GSUE |= 0x04
                            }
                        }
                        ElseIf ((PIO1 == Ones) | (PIO1 == 0x00))
                        {
                            If ((DMA1 < Ones) & (DMA1 > 0x00))
                            {
                                PIO1 = DMA1 /* \_SB_.PCI0.IDE1.DMA1 */
                                GSUE |= 0x80
                            }
                        }

                        If (CHNF & 0x02)
                        {
                            GMUE |= 0x20
                        }

                        If (CHNF & 0x08)
                        {
                            GSUE |= 0x20
                        }

                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO0, MTR, 0x00, 
                            0x00) & 0x07)
                        Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0])
                        GMPT = Local1
                        If (Local0 < 0x03)
                        {
                            GMUE |= 0x50
                        }

                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO1, MTR, 0x00, 
                            0x00) & 0x07)
                        Local1 = DerefOf (DerefOf (TIM0 [0x02]) [Local0])
                        GSPT = Local1
                        If (Local0 < 0x03)
                        {
                            GSUE |= 0x50
                        }
                    }
                }

                Name (AT01, Buffer (0x07)
                {
                     0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF         /* ....... */
                })
                Name (AT02, Buffer (0x07)
                {
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90         /* ....... */
                })
                Name (AT03, Buffer (0x07)
                {
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6         /* ....... */
                })
                Name (AT04, Buffer (0x07)
                {
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91         /* ....... */
                })
                Name (ATA0, Buffer (0x1D) {})
                Name (ATA1, Buffer (0x1D) {})
                Name (ATA2, Buffer (0x1D) {})
                Name (ATA3, Buffer (0x1D) {})
                Name (ATAB, Buffer (0x1D) {})
                CreateByteField (ATAB, 0x00, CMDC)
                Method (GTFB, 3, Serialized)
                {
                    Local0 = (CMDC * 0x38)
                    Local1 = (Local0 + 0x08)
                    CreateField (ATAB, Local1, 0x38, CMDX)
                    Local0 = (CMDC * 0x07)
                    CreateByteField (ATAB, (Local0 + 0x02), A001)
                    CreateByteField (ATAB, (Local0 + 0x06), A005)
                    CMDX = Arg0
                    A001 = Arg1
                    A005 = Arg2
                    CMDC++
                }

                Method (GTF, 2, Serialized)
                {
                    Debug = Arg1
                    CMDC = 0x00
                    Name (ID49, 0x0C00)
                    Name (ID59, 0x00)
                    Name (ID53, 0x04)
                    Name (ID63, 0x0F00)
                    Name (ID88, 0x0F00)
                    Name (IRDY, 0x01)
                    Name (PIOT, 0x00)
                    Name (DMAT, 0x00)
                    If (SizeOf (Arg1) == 0x0200)
                    {
                        CreateWordField (Arg1, 0x62, IW49)
                        ID49 = IW49 /* \_SB_.PCI0.IDE1.GTF_.IW49 */
                        CreateWordField (Arg1, 0x6A, IW53)
                        ID53 = IW53 /* \_SB_.PCI0.IDE1.GTF_.IW53 */
                        CreateWordField (Arg1, 0x7E, IW63)
                        ID63 = IW63 /* \_SB_.PCI0.IDE1.GTF_.IW63 */
                        CreateWordField (Arg1, 0x76, IW59)
                        ID59 = IW59 /* \_SB_.PCI0.IDE1.GTF_.IW59 */
                        CreateWordField (Arg1, 0xB0, IW88)
                        ID88 = IW88 /* \_SB_.PCI0.IDE1.GTF_.IW88 */
                    }

                    Local7 = 0xA0
                    If (Arg0)
                    {
                        Local7 = 0xB0
                        IRDY = (CHNF & 0x08)
                        If (CHNF & 0x10)
                        {
                            PIOT = PIO1 /* \_SB_.PCI0.IDE1.PIO1 */
                        }
                        Else
                        {
                            PIOT = PIO0 /* \_SB_.PCI0.IDE1.PIO0 */
                        }

                        If (CHNF & 0x04)
                        {
                            If (CHNF & 0x10)
                            {
                                DMAT = DMA1 /* \_SB_.PCI0.IDE1.DMA1 */
                            }
                            Else
                            {
                                DMAT = DMA0 /* \_SB_.PCI0.IDE1.DMA0 */
                            }
                        }
                    }
                    Else
                    {
                        IRDY = (CHNF & 0x02)
                        PIOT = PIO0 /* \_SB_.PCI0.IDE1.PIO0 */
                        If (CHNF & 0x01)
                        {
                            DMAT = DMA0 /* \_SB_.PCI0.IDE1.DMA0 */
                        }
                    }

                    If (((ID53 & 0x04) && (ID88 & 0xFF00)) && DMAT)
                    {
                        Local1 = Match (DerefOf (TIM0 [0x03]), MLE, DMAT, MTR, 0x00, 
                            0x00)
                        If (Local1 > 0x05)
                        {
                            Local1 = 0x05
                        }

                        GTFB (AT01, (0x40 | Local1), Local7)
                    }
                    ElseIf ((ID63 & 0xFF00) && PIOT)
                    {
                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, 
                            0x00) & 0x03)
                        Local1 = (0x20 | DerefOf (DerefOf (TIM0 [0x07]) [Local0]))
                        GTFB (AT01, Local1, Local7)
                    }

                    If (IRDY)
                    {
                        Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, 
                            0x00) & 0x07)
                        Local1 = (0x08 | DerefOf (DerefOf (TIM0 [0x06]) [Local0]))
                        GTFB (AT01, Local1, Local7)
                    }
                    ElseIf (ID49 & 0x0400)
                    {
                        GTFB (AT01, 0x01, Local7)
                    }

                    If ((ID59 & 0x0100) && (ID59 & 0xFF))
                    {
                        GTFB (AT03, (ID59 & 0xFF), Local7)
                    }

                    Debug = ATAB /* \_SB_.PCI0.IDE1.ATAB */
                    Return (ATAB) /* \_SB_.PCI0.IDE1.ATAB */
                }

                Method (RATA, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x00, CMDN)
                    Local0 = (CMDN * 0x38)
                    CreateField (Arg0, 0x08, Local0, RETB)
                    Debug = RETB /* \_SB_.PCI0.IDE1.RATA.RETB */
                    Return (RETB) /* \_SB_.PCI0.IDE1.RATA.RETB */
                }
            }
        }

        Scope (\_GPE)
        {
            Method (_L09, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.P0P1, 0x02) // Device Wake
                Notify (\_SB.PCI0.P0P9, 0x02) // Device Wake
                Notify (\_SB.PCI0.P0P8, 0x02) // Device Wake
                Notify (\_SB.PCI0.P0P7, 0x02) // Device Wake
                Notify (\_SB.PCI0.P0P6, 0x02) // Device Wake
                Notify (\_SB.PCI0.P0P5, 0x02) // Device Wake
                Notify (\_SB.PCI0.P0P4, 0x02) // Device Wake
            }

            Method (_L0B, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.P0P3, 0x02) // Device Wake
                Notify (\_SB.PWRB, 0x02) // Device Wake
            }

            Method (_L1D, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                \_SB.PCI0.SBRG.SIOH ()
            }

            Method (_L08, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                \_SB.PCI0.SBRG.SIOH ()
            }

            Method (_L04, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.USB2, 0x02) // Device Wake
                Notify (\_SB.PWRB, 0x02) // Device Wake
            }

            Method (_L0C, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.USB3, 0x02) // Device Wake
                Notify (\_SB.PWRB, 0x02) // Device Wake
            }

            Method (_L0E, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.USB4, 0x02) // Device Wake
                Notify (\_SB.PWRB, 0x02) // Device Wake
            }

            Method (_L05, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.MC97, 0x02) // Device Wake
                Notify (\_SB.PWRB, 0x02) // Device Wake
            }

            Method (_L03, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.USB1, 0x02) // Device Wake
                Notify (\_SB.PWRB, 0x02) // Device Wake
            }

            Method (_L0D, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
            {
                Notify (\_SB.PCI0.EUSB, 0x02) // Device Wake
                Notify (\_SB.PWRB, 0x02) // Device Wake
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */)  // _HID: Hardware ID
            Name (_UID, 0xAA)  // _UID: Unique ID
            Name (_STA, 0x0B)  // _STA: Status
        }
    }

    OperationRegion (\_SB.PCI0.SBRG.PIX0, PCI_Config, 0x60, 0x0C)
    Field (\_SB.PCI0.SBRG.PIX0, ByteAcc, NoLock, Preserve)
    {
        PIRA,   8, 
        PIRB,   8, 
        PIRC,   8, 
        PIRD,   8, 
        Offset (0x08), 
        PIRE,   8, 
        PIRF,   8, 
        PIRG,   8, 
        PIRH,   8
    }

    Scope (\_SB)
    {
        Name (BUFA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, _Y17)
                {15}
        })
        CreateWordField (BUFA, \_SB._Y17._INT, IRA0)  // _INT: Interrupts
        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x01)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRA & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSA) /* \_SB_.PRSA */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRA |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRA & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRA = Local0
            }
        }

        Device (LNKB)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x02)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRB & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSB) /* \_SB_.PRSB */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRB |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRB & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRB = Local0
            }
        }

        Device (LNKC)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x03)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRC & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSC) /* \_SB_.PRSC */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRC |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRC & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRC = Local0
            }
        }

        Device (LNKD)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x04)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRD & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSD) /* \_SB_.PRSD */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRD |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRD & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRD = Local0
            }
        }

        Device (LNKE)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x05)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRE & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSE) /* \_SB_.PRSE */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRE |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRE & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRE = Local0
            }
        }

        Device (LNKF)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x06)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRF & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSF) /* \_SB_.PRSF */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRF |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRF & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRF = Local0
            }
        }

        Device (LNKG)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x07)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRG & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSG) /* \_SB_.PRSG */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRG |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRG & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRG = Local0
            }
        }

        Device (LNKH)
        {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */)  // _HID: Hardware ID
            Name (_UID, 0x08)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Local0 = (PIRH & 0x80)
                If (Local0)
                {
                    Return (0x09)
                }
                Else
                {
                    Return (0x0B)
                }
            }

            Method (_PRS, 0, NotSerialized)  // _PRS: Possible Resource Settings
            {
                Return (PRSH) /* \_SB_.PRSH */
            }

            Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
            {
                PIRH |= 0x80
            }

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Local0 = (PIRH & 0x0F)
                IRA0 = (0x01 << Local0)
                Return (BUFA) /* \_SB_.BUFA */
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                CreateWordField (Arg0, 0x01, IRA)
                FindSetRightBit (IRA, Local0)
                Local0--
                PIRH = Local0
            }
        }
    }

    Scope (\_SB)
    {
        Name (XCPD, 0x00)
        Name (XNPT, 0x01)
        Name (XCAP, 0x02)
        Name (XDCP, 0x04)
        Name (XDCT, 0x08)
        Name (XDST, 0x0A)
        Name (XLCP, 0x0C)
        Name (XLCT, 0x10)
        Name (XLST, 0x12)
        Name (XSCP, 0x14)
        Name (XSCT, 0x18)
        Name (XSST, 0x1A)
        Name (XRCT, 0x1C)
        Mutex (MUTE, 0x00)
        Method (RBPE, 1, NotSerialized)
        {
            Acquire (MUTE, 0x03E8)
            Local0 = (Arg0 + \PCIB)
            OperationRegion (PCFG, SystemMemory, Local0, 0x01)
            Field (PCFG, ByteAcc, NoLock, Preserve)
            {
                XCFG,   8
            }

            Release (MUTE)
            Return (XCFG) /* \_SB_.RBPE.XCFG */
        }

        Method (RWPE, 1, NotSerialized)
        {
            Acquire (MUTE, 0x03E8)
            Arg0 &= 0xFFFFFFFE
            Local0 = (Arg0 + \PCIB)
            OperationRegion (PCFG, SystemMemory, Local0, 0x02)
            Field (PCFG, WordAcc, NoLock, Preserve)
            {
                XCFG,   16
            }

            Release (MUTE)
            Return (XCFG) /* \_SB_.RWPE.XCFG */
        }

        Method (RDPE, 1, NotSerialized)
        {
            Acquire (MUTE, 0x03E8)
            Arg0 &= 0xFFFFFFFC
            Local0 = (Arg0 + \PCIB)
            OperationRegion (PCFG, SystemMemory, Local0, 0x04)
            Field (PCFG, DWordAcc, NoLock, Preserve)
            {
                XCFG,   32
            }

            Release (MUTE)
            Return (XCFG) /* \_SB_.RDPE.XCFG */
        }

        Method (WBPE, 2, NotSerialized)
        {
            Acquire (MUTE, 0x0FFF)
            Local0 = (Arg0 + \PCIB)
            OperationRegion (PCFG, SystemMemory, Local0, 0x01)
            Field (PCFG, ByteAcc, NoLock, Preserve)
            {
                XCFG,   8
            }

            XCFG = Arg1
            Release (MUTE)
        }

        Method (WWPE, 2, NotSerialized)
        {
            Acquire (MUTE, 0x03E8)
            Arg0 &= 0xFFFFFFFE
            Local0 = (Arg0 + \PCIB)
            OperationRegion (PCFG, SystemMemory, Local0, 0x02)
            Field (PCFG, WordAcc, NoLock, Preserve)
            {
                XCFG,   16
            }

            XCFG = Arg1
            Release (MUTE)
        }

        Method (WDPE, 2, NotSerialized)
        {
            Acquire (MUTE, 0x03E8)
            Arg0 &= 0xFFFFFFFC
            Local0 = (Arg0 + \PCIB)
            OperationRegion (PCFG, SystemMemory, Local0, 0x04)
            Field (PCFG, DWordAcc, NoLock, Preserve)
            {
                XCFG,   32
            }

            XCFG = Arg1
            Release (MUTE)
        }

        Method (RWDP, 3, NotSerialized)
        {
            Acquire (MUTE, 0x03E8)
            Arg0 &= 0xFFFFFFFC
            Local0 = (Arg0 + \PCIB)
            OperationRegion (PCFG, SystemMemory, Local0, 0x04)
            Field (PCFG, DWordAcc, NoLock, Preserve)
            {
                XCFG,   32
            }

            Local1 = (XCFG & Arg2)
            XCFG = (Local1 | Arg1)
            Release (MUTE)
        }

        Method (RPME, 1, NotSerialized)
        {
            Local0 = (Arg0 + 0x84)
            Local1 = \_SB.RDPE (Local0)
            If (Local1 == 0xFFFFFFFF)
            {
                Return (0x00)
            }
            Else
            {
                If (Local1 && 0x00010000)
                {
                    \_SB.WDPE (Local0, (Local1 & 0x00010000))
                    Return (0x01)
                }

                Return (0x00)
            }
        }
    }

    Name (HBAS, 0x00)
    Name (HLBA, 0x00)
    Name (HDEV, 0x00)
    OperationRegion (REFP, SystemIO, 0x61, 0x01)
    Field (REFP, ByteAcc, NoLock, Preserve)
    {
        P061,   8
    }

    Method (FZHD, 0, NotSerialized)
    {
        Local0 = 0x80
        Local1 = DMAX /* \DMAX */
        While (Local0 <= Local1)
        {
            Local3 = (Local0 & 0x7F)
            Local2 = 0x01
            Local2 <<= Local3
            If (!(\_SB.PCI0.HFZF & Local2))
            {
                If (FZOD (Local0))
                {
                    \_SB.PCI0.HFZF |= Local2
                }
            }

            Local0++
        }
    }

    Method (FZOD, 1, NotSerialized)
    {
        GHET (Arg0)
        If (HBAS == 0x00)
        {
            Return (0x01)
        }

        If (HDEV == 0x00)
        {
            Return (0x01)
        }

        Local1 = HDEV /* \HDEV */
        Local1 &= 0x10
        If (Local1 == 0x00)
        {
            Return (0x01)
        }

        SDRV ()
        Local1 = (HBAS + 0x07)
        OperationRegion (HRGS, SystemIO, Local1, 0x01)
        Field (HRGS, ByteAcc, NoLock, Preserve)
        {
            SREG,   8
        }

        Local1 = SREG /* \FZOD.SREG */
        Local1 &= 0x80
        If (Local1)
        {
            Return (0x00)
        }

        Local1 = (HBAS + 0x07)
        OperationRegion (HRGC, SystemIO, Local1, 0x01)
        Field (HRGC, ByteAcc, NoLock, Preserve)
        {
            CREG,   8
        }

        CREG = 0xF5
        If (WFCF ())
        {
            Local0 = (HBAS + 0x07)
            Local1 = SREG /* \FZOD.SREG */
            Return (!(Local1 & 0x01))
        }
        Else
        {
            Return (0x00)
        }
    }

    OperationRegion (DBGA, SystemIO, 0x80, 0x04)
    Field (DBGA, DWordAcc, NoLock, Preserve)
    {
        DB32,   32
    }

    Method (GHET, 1, NotSerialized)
    {
        Local0 = (Arg0 & 0x7F)
        Local0 <<= 0x05
        Local0 += HPTA /* \HPTA */
        OperationRegion (HDPT, SystemMemory, Local0, 0x20)
        Field (HDPT, ByteAcc, NoLock, Preserve)
        {
            HP00,   16, 
            Offset (0x04), 
            HP04,   8, 
            Offset (0x12), 
            HP0C,   8
        }

        HBAS = HP00 /* \GHET.HP00 */
        HLBA = HP04 /* \GHET.HP04 */
        HDEV = HP0C /* \GHET.HP0C */
    }

    Method (SDRV, 0, NotSerialized)
    {
        Local0 = (HBAS + 0x06)
        OperationRegion (HRGH, SystemIO, Local0, 0x01)
        Field (HRGH, ByteAcc, NoLock, Preserve)
        {
            HREG,   8
        }

        HREG = HLBA /* \HLBA */
    }

    Method (WFCF, 0, NotSerialized)
    {
        SDRV ()
        Local0 = (HBAS + 0x01)
        OperationRegion (HRGE, SystemIO, Local0, 0x01)
        Field (HRGE, ByteAcc, NoLock, Preserve)
        {
            EREG,   8
        }

        EREG = 0x00
        Local1 = (HBAS + 0x07)
        OperationRegion (HRGC, SystemIO, Local1, 0x01)
        Field (HRGC, ByteAcc, NoLock, Preserve)
        {
            CREG,   8
        }

        Local0 = 0x28
        While (Local0)
        {
            Local2 = (CREG & 0x01)
            If (Local2)
            {
                Return (0x00)
            }

            WFZF (Local1)
            Local2 = (CREG & 0x80)
            If (Local2 == 0x00)
            {
                Return (0x01)
            }

            Local0--
        }

        Return (0x00)
    }

    Method (WFZF, 1, NotSerialized)
    {
        OperationRegion (HRGC, SystemIO, Arg0, 0x01)
        Field (HRGC, ByteAcc, NoLock, Preserve)
        {
            CREG,   8
        }

        Local1 = 0xFFFF
        While (Local1)
        {
            Local2 = CREG /* \WFZF.CREG */
            Local2 &= 0x80
            If (Local2 == 0x00)
            {
                Return (0x01)
            }

            Stall (0x0F)
            Local1--
        }

        Return (0x00)
    }

    Scope (\_SB.PCI0)
    {
        Name (HFZF, 0x00)
        Method (HWAK, 1, NotSerialized)
        {
            If (Arg0 == 0x03)
            {
                HFZF = 0x00
            }
        }
    }

    Scope (\_SB.PCI0.SBRG.SIOR)
    {
        Method (HWV0, 0, NotSerialized)
        {
            Return ((VCOR * 0x08))
        }

        Method (HWV1, 0, NotSerialized)
        {
            Local0 = (V12V * 0x08)
            Return (Local0)
        }

        Method (HWV3, 0, NotSerialized)
        {
            Local0 = (V33V * 0x08)
            Return (Local0)
        }

        Method (HWV5, 0, NotSerialized)
        {
            Local0 = (V50V * 0x08)
            Return (Local0)
        }

        Method (HWT0, 0, NotSerialized)
        {
            Local1 = MBTE /* \_SB_.PCI0.SBRG.SIOR.MBTE */
            Local1 *= 0x0A
            Return (Local1)
        }

        Method (HWT1, 0, NotSerialized)
        {
            BSEL = 0x01
            Local1 = TSR1 /* \_SB_.PCI0.SBRG.SIOR.TSR1 */
            Local1 *= 0x0A
            Local2 = TSR2 /* \_SB_.PCI0.SBRG.SIOR.TSR2 */
            Local2 *= 0x05
            Local1 += Local2
            Return (Local1)
        }

        Method (HWT2, 0, NotSerialized)
        {
            BSEL = 0x02
            Local1 = TSR1 /* \_SB_.PCI0.SBRG.SIOR.TSR1 */
            Local1 *= 0x0A
            Local2 = TSR2 /* \_SB_.PCI0.SBRG.SIOR.TSR2 */
            Local2 *= 0x05
            Local1 += Local2
            Return (Local1)
        }

        Method (HWF0, 0, NotSerialized)
        {
            Local0 = FAN1 /* \_SB_.PCI0.SBRG.SIOR.FAN1 */
            BSEL = 0x00
            Local1 = (FD21 & 0x20)
            Local1 >>= 0x05
            Local1 *= 0x04
            Local1 += FD11 /* \_SB_.PCI0.SBRG.SIOR.FD11 */
            While (((Local0 > 0xE6) && (Local1 < 0x07)) || ((Local0 < 
                0x64) && (Local1 > 0x00)))
            {
                If ((Local0 > 0xE6) && (Local1 < 0x07))
                {
                    Local1 += 0x01
                    Divide (Local1, 0x04, Local2, Local3)
                    BSEL = 0x00
                    Local3 <<= 0x05
                    Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */
                    Local4 &= 0xDF
                    FD21 = (Local3 | Local4)
                    FD11 = Local2
                    Sleep (0x012C)
                    Local0 = FAN1 /* \_SB_.PCI0.SBRG.SIOR.FAN1 */
                }
                Else
                {
                    Local1 -= 0x01
                    Divide (Local1, 0x04, Local2, Local3)
                    BSEL = 0x00
                    Local3 <<= 0x05
                    Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */
                    Local4 &= 0xDF
                    FD21 = (Local3 | Local4)
                    FD11 = Local2
                    Sleep (0x012C)
                    Local0 = FAN1 /* \_SB_.PCI0.SBRG.SIOR.FAN1 */
                }
            }

            If ((Local0 == 0xFF) && (Local1 == 0x07))
            {
                Return (0x00)
            }

            If ((Local0 == 0x00) && (Local1 == 0x00))
            {
                Return (0xFFFF)
            }

            Local2 = 0x01
            While (Local1)
            {
                Local2 *= 0x02
                Local1--
            }

            Local0 *= Local2
            Divide (0x00149970, Local0, Local1, Local0)
            Return (Local0)
        }

        Method (HWF1, 0, NotSerialized)
        {
            Local0 = FAN2 /* \_SB_.PCI0.SBRG.SIOR.FAN2 */
            BSEL = 0x00
            Local1 = (FD21 & 0x40)
            Local1 >>= 0x06
            Local1 *= 0x04
            Local1 += FD12 /* \_SB_.PCI0.SBRG.SIOR.FD12 */
            While (((Local0 > 0xE6) && (Local1 < 0x07)) || ((Local0 < 
                0x64) && (Local1 > 0x00)))
            {
                If ((Local0 > 0xE6) && (Local1 < 0x07))
                {
                    Local1 += 0x01
                    Divide (Local1, 0x04, Local2, Local3)
                    BSEL = 0x00
                    Local3 <<= 0x06
                    Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */
                    Local4 &= 0xBF
                    FD21 = (Local3 | Local4)
                    FD12 = Local2
                    Sleep (0x012C)
                    Local0 = FAN2 /* \_SB_.PCI0.SBRG.SIOR.FAN2 */
                }
                Else
                {
                    Local1 -= 0x01
                    Divide (Local1, 0x04, Local2, Local3)
                    BSEL = 0x00
                    Local3 <<= 0x06
                    Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */
                    Local4 &= 0xBF
                    FD21 = (Local3 | Local4)
                    FD12 = Local2
                    Sleep (0x012C)
                    Local0 = FAN2 /* \_SB_.PCI0.SBRG.SIOR.FAN2 */
                }
            }

            If ((Local0 == 0xFF) && (Local1 == 0x07))
            {
                Return (0x00)
            }

            If ((Local0 == 0x00) && (Local1 == 0x00))
            {
                Return (0xFFFF)
            }

            Local2 = 0x01
            While (Local1)
            {
                Local2 *= 0x02
                Local1--
            }

            Local0 *= Local2
            Divide (0x00149970, Local0, Local1, Local0)
            Return (Local0)
        }

        Method (HWF2, 0, NotSerialized)
        {
            Local0 = FAN3 /* \_SB_.PCI0.SBRG.SIOR.FAN3 */
            BSEL = 0x00
            Local1 = (FD21 & 0x80)
            Local1 >>= 0x07
            Local1 *= 0x04
            Divide (FD13, 0x40, Local2, Local3)
            Local1 += Local3
            While (((Local0 > 0xE6) && (Local1 < 0x07)) || ((Local0 < 
                0x64) && (Local1 > 0x00)))
            {
                If ((Local0 > 0xE6) && (Local1 < 0x07))
                {
                    Local1 += 0x01
                    Divide (Local1, 0x04, Local2, Local3)
                    BSEL = 0x00
                    Local3 <<= 0x07
                    Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */
                    Local4 &= 0x7F
                    FD21 = (Local3 | Local4)
                    Local3 = FD13 /* \_SB_.PCI0.SBRG.SIOR.FD13 */
                    Local3 &= 0x3F
                    Local2 *= 0x40
                    Local2 += Local3
                    FD13 = Local2
                    Sleep (0x012C)
                    Local0 = FAN3 /* \_SB_.PCI0.SBRG.SIOR.FAN3 */
                }
                Else
                {
                    Local1 -= 0x01
                    Divide (Local1, 0x04, Local2, Local3)
                    BSEL = 0x00
                    Local3 <<= 0x07
                    Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */
                    Local4 &= 0x7F
                    FD21 = (Local3 | Local4)
                    Local3 = FD13 /* \_SB_.PCI0.SBRG.SIOR.FD13 */
                    Local3 &= 0x3F
                    Local2 *= 0x40
                    Local2 += Local3
                    FD13 = Local2
                    Sleep (0x012C)
                    Local0 = FAN3 /* \_SB_.PCI0.SBRG.SIOR.FAN3 */
                }
            }

            If ((Local0 == 0xFF) && (Local1 == 0x07))
            {
                Return (0x00)
            }

            If ((Local0 == 0x00) && (Local1 == 0x00))
            {
                Return (0xFFFF)
            }

            Local2 = 0x01
            While (Local1)
            {
                Local2 *= 0x02
                Local1--
            }

            Local0 *= Local2
            Divide (0x00149970, Local0, Local1, Local0)
            Return (Local0)
        }

        OperationRegion (HWRE, SystemIO, IOHW, 0x0A)
        Field (HWRE, ByteAcc, NoLock, Preserve)
        {
            Offset (0x05), 
            HIDX,   8, 
            HDAT,   8
        }

        IndexField (HIDX, HDAT, ByteAcc, NoLock, Preserve)
        {
            Offset (0x04), 
            CHNM,   1, 
            CFNM,   1, 
            CHNS,   2, 
            CFNS,   2, 
            Offset (0x05), 
            SYST,   8, 
            TRGT,   8, 
            Offset (0x08), 
            SSDN,   8, 
            CSDN,   8, 
            SSUP,   8, 
            CSUP,   8, 
            Offset (0x20), 
            VCOR,   8, 
            V12V,   8, 
            Offset (0x23), 
            V33V,   8, 
            Offset (0x25), 
            V50V,   8, 
            Offset (0x27), 
            MBTE,   8, 
            FAN1,   8, 
            FAN2,   8, 
            FAN3,   8, 
            Offset (0x40), 
            HWST,   1, 
            Offset (0x41), 
            Offset (0x47), 
                ,   4, 
            FD11,   2, 
            FD12,   2, 
            Offset (0x4B), 
            FD13,   8, 
            Offset (0x4E), 
            BSEL,   3, 
            Offset (0x4F), 
            Offset (0x50), 
            TSR1,   8, 
            TSR2,   1, 
            Offset (0x52), 
            Offset (0x5D), 
            FD21,   8
        }
    }

    Scope (\_SB.PCI0.SBRG.ASOC)
    {
        Name (CORV, Package (0x05)
        {
            0x06020000, 
            "Vcore Voltage", 
            0x0352, 
            0x0640, 
            0x01
        })
        Name (V3VV, Package (0x05)
        {
            0x06020001, 
            " +3.3 Voltage", 
            0x0B9A, 
            0x0E2E, 
            0x01
        })
        Name (V5VV, Package (0x05)
        {
            0x06020002, 
            " +5 Voltage", 
            0x1194, 
            0x157C, 
            0x01
        })
        Name (VV12, Package (0x05)
        {
            0x06020003, 
            " +12 Voltage", 
            0x27D8, 
            0x35E8, 
            0x01
        })
        Name (VPAR, Package (0x04)
        {
            Package (0x03)
            {
                0x00, 
                0x01, 
                0x00
            }, 

            Package (0x03)
            {
                0x22, 
                0x22, 
                0x00
            }, 

            Package (0x03)
            {
                0x16, 
                0x0A, 
                0x00
            }, 

            Package (0x03)
            {
                0x38, 
                0x0A, 
                0x00
            }
        })
        Name (VBUF, Package (0x05)
        {
            0x04, 
            CORV, 
            V3VV, 
            V5VV, 
            VV12
        })
        Method (VGET, 1, NotSerialized)
        {
            Local0 = 0x00
            If (Arg0 == 0x00)
            {
                Local0 = ^^SIOR.HWV0 ()
            }

            If (Arg0 == 0x01)
            {
                Local0 = ^^SIOR.HWV3 ()
            }

            If (Arg0 == 0x02)
            {
                Local0 = ^^SIOR.HWV5 ()
            }

            If (Arg0 == 0x03)
            {
                Local0 = ^^SIOR.HWV1 ()
            }

            Return (Local0)
        }

        Name (CPUT, Package (0x05)
        {
            0x06030000, 
            "CPU Temperature", 
            0x0258, 
            0x03B6, 
            0x00010001
        })
        Name (TBUF, Package (0x02)
        {
            0x01, 
            CPUT
        })
        Method (TGET, 1, NotSerialized)
        {
            Local0 = 0x00
            If (Arg0 == 0x00)
            {
                Local0 = ^^SIOR.HWT1 ()
            }

            Return (Local0)
        }

        Name (CPUF, Package (0x05)
        {
            0x06040000, 
            "CPU FAN Speed", 
            0x0258, 
            0x1C20, 
            0x00010001
        })
        Name (CHAF, Package (0x05)
        {
            0x06040001, 
            "CHASSIS FAN Speed", 
            0x0320, 
            0x1C20, 
            0x00010001
        })
        Name (FBUF, Package (0x03)
        {
            0x02, 
            CPUF, 
            CHAF
        })
        Method (FGET, 1, NotSerialized)
        {
            Local0 = 0x00
            If (Arg0 == 0x00)
            {
                Local0 = ^^SIOR.HWF1 ()
            }

            If (Arg0 == 0x01)
            {
                Local0 = ^^SIOR.HWF0 ()
            }

            Return (Local0)
        }

        Method (VSIF, 0, Serialized)
        {
            Return (VBUF) /* \_SB_.PCI0.SBRG.ASOC.VBUF */
        }

        Method (RVLT, 1, Serialized)
        {
            Acquire (AMTX, 0xFFFF)
            Local0 = (Arg0 & 0xFFFF)
            Local1 = VGET (Local0)
            Local2 = DerefOf (DerefOf (VPAR [Local0]) [0x00])
            Local3 = DerefOf (DerefOf (VPAR [Local0]) [0x01])
            Local4 = DerefOf (DerefOf (VPAR [Local0]) [0x02])
            Local5 = (Local1 * (Local2 + Local3))
            Local5 /= Local3
            Local5 += Local4
            Release (AMTX)
            Return (Local5)
        }

        Method (SVLT, 1, Serialized)
        {
            Acquire (AMTX, 0xFFFF)
            Local0 = (DerefOf (Arg0 [0x00]) & 0xFFFF)
            Local1 = DerefOf (VBUF [0x00])
            If (Local0 >= Local1)
            {
                Release (AMTX)
                Return (0x00)
            }

            Local0++
            DerefOf (VBUF [Local0]) [0x01] = DerefOf (Arg0 [
                0x01])
            DerefOf (VBUF [Local0]) [0x02] = DerefOf (Arg0 [
                0x02])
            DerefOf (VBUF [Local0]) [0x03] = DerefOf (Arg0 [
                0x03])
            DerefOf (VBUF [Local0]) [0x04] = DerefOf (Arg0 [
                0x04])
            Release (AMTX)
            Return (0x01)
        }

        Method (TSIF, 0, Serialized)
        {
            Return (TBUF) /* \_SB_.PCI0.SBRG.ASOC.TBUF */
        }

        Method (RTMP, 1, NotSerialized)
        {
            Acquire (AMTX, 0xFFFF)
            Local0 = (Arg0 & 0xFFFF)
            Local1 = TGET (Local0)
            Release (AMTX)
            Return (Local1)
        }

        Method (STMP, 1, Serialized)
        {
            Acquire (AMTX, 0xFFFF)
            Local0 = (DerefOf (Arg0 [0x00]) & 0xFFFF)
            Local1 = DerefOf (TBUF [0x00])
            If (Local0 >= Local1)
            {
                Release (AMTX)
                Return (0x00)
            }

            Local0++
            DerefOf (TBUF [Local0]) [0x01] = DerefOf (Arg0 [
                0x01])
            DerefOf (TBUF [Local0]) [0x02] = DerefOf (Arg0 [
                0x02])
            DerefOf (TBUF [Local0]) [0x03] = DerefOf (Arg0 [
                0x03])
            DerefOf (TBUF [Local0]) [0x04] = DerefOf (Arg0 [
                0x04])
            Release (AMTX)
            Return (0x01)
        }

        Method (FSIF, 0, Serialized)
        {
            Return (FBUF) /* \_SB_.PCI0.SBRG.ASOC.FBUF */
        }

        Method (RFAN, 1, Serialized)
        {
            Acquire (AMTX, 0xFFFF)
            Local0 = (Arg0 & 0xFFFF)
            Local1 = FGET (Local0)
            Release (AMTX)
            Return (Local1)
        }

        Method (SFAN, 1, Serialized)
        {
            Acquire (AMTX, 0xFFFF)
            Local0 = (DerefOf (Arg0 [0x00]) & 0xFFFF)
            Local1 = DerefOf (FBUF [0x00])
            If (Local0 >= Local1)
            {
                Release (AMTX)
                Return (0x00)
            }

            Local0++
            DerefOf (FBUF [Local0]) [0x01] = DerefOf (Arg0 [
                0x01])
            DerefOf (FBUF [Local0]) [0x02] = DerefOf (Arg0 [
                0x02])
            DerefOf (FBUF [Local0]) [0x03] = DerefOf (Arg0 [
                0x03])
            DerefOf (FBUF [Local0]) [0x04] = DerefOf (Arg0 [
                0x04])
            Release (AMTX)
            Return (0x01)
        }
    }

    Scope (\_SB)
    {
        Scope (PCI0)
        {
            Name (CRS, 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)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Granularity
                    0x0D00,             // Range Minimum
                    0xFFFF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0xF300,             // Length
                    ,, , TypeStatic)
                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
                    0x00000000,         // Range Minimum
                    0x00000000,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    ,, _Y18, AddressRangeMemory, TypeStatic)
            })
            CreateDWordField (CRS, \_SB.PCI0._Y18._MIN, MIN6)  // _MIN: Minimum Base Address
            CreateDWordField (CRS, \_SB.PCI0._Y18._MAX, MAX6)  // _MAX: Maximum Base Address
            CreateDWordField (CRS, \_SB.PCI0._Y18._LEN, LEN6)  // _LEN: Length
            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                MIN6 = MG2B /* \MG2B */
                MIN6 += 0x00010000
                LEN6 = MG2L /* \MG2L */
                LEN6 -= 0x00010000
                Local0 = LEN6 /* \_SB_.PCI0.LEN6 */
                MAX6 = (MIN6 + Local0--)
                Return (CRS) /* \_SB_.PCI0.CRS_ */
            }
        }
    }

    Name (WOTB, 0x00)
    Name (WSSB, 0x00)
    Name (WAXB, 0x00)
    Method (_PTS, 1, NotSerialized)  // _PTS: Prepare To Sleep
    {
        DBG8 = Arg0
        PTS (Arg0)
        WAKP [0x00] = 0x00
        WAKP [0x01] = 0x00
        If ((Arg0 == 0x04) && (OSFL () == 0x02))
        {
            Sleep (0x0BB8)
        }

        WSSB = ASSB /* \ASSB */
        WOTB = AOTB /* \AOTB */
        WAXB = AAXB /* \AAXB */
        ASSB = Arg0
        AOTB = OSFL ()
        AAXB = Zero
    }

    Method (_WAK, 1, NotSerialized)  // _WAK: Wake
    {
        DBG8 = (Arg0 << 0x04)
        WAK (Arg0)
        If (IOWK) {}
        Else
        {
            Notify (\_SB.PWRB, 0x02) // Device Wake
        }

        If (ASSB)
        {
            ASSB = WSSB /* \WSSB */
            AOTB = WOTB /* \WOTB */
            AAXB = WAXB /* \WAXB */
        }

        If (DerefOf (WAKP [0x00]))
        {
            WAKP [0x01] = 0x00
        }
        Else
        {
            WAKP [0x01] = Arg0
        }

        Return (WAKP) /* \WAKP */
    }

    OperationRegion (PMS0, SystemIO, PMBS, 0x04)
    Field (PMS0, ByteAcc, NoLock, Preserve)
    {
            ,   10, 
        RTCS,   1, 
            ,   4, 
        WAKS,   1, 
        Offset (0x03), 
        PWBT,   1, 
            ,   1, 
        RTCE,   1, 
        Offset (0x04)
    }

    OperationRegion (SMIE, SystemIO, PM30, 0x08)
    Field (SMIE, ByteAcc, NoLock, Preserve)
    {
            ,   4, 
        PS1E,   1, 
            ,   31, 
        PS1S,   1, 
        Offset (0x08)
    }

    OperationRegion (\_SB.PCI0.SKPD, PCI_Config, ACPH, 0x02)
    Field (\_SB.PCI0.SKPD, ByteAcc, NoLock, Preserve)
    {
        APWR,   8, 
        SPLV,   3, 
        OSFG,   2, 
        Offset (0x02)
    }

    OperationRegion (IORK, SystemIO, 0xB3, 0x01)
    Field (IORK, ByteAcc, NoLock, Preserve)
    {
        IOWK,   8
    }

    Scope (\_SB.PCI0.IDE0)
    {
        OperationRegion (PAR9, PCI_Config, 0x09, 0x01)
        Field (PAR9, ByteAcc, NoLock, Preserve)
        {
            PAMD,   8
        }
    }

    Scope (\_SB.PCI0.IDE1)
    {
        OperationRegion (SAR9, PCI_Config, 0x09, 0x01)
        Field (SAR9, ByteAcc, NoLock, Preserve)
        {
            SAMD,   8
        }
    }

    Name (\_S0, Package (0x04)  // _S0_: S0 System State
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    If (SS1)
    {
        Name (\_S1, Package (0x04)  // _S1_: S1 System State
        {
            0x01, 
            0x00, 
            0x00, 
            0x00
        })
    }

    If (SS3)
    {
        Name (\_S3, Package (0x04)  // _S3_: S3 System State
        {
            0x05, 
            0x00, 
            0x00, 
            0x00
        })
    }

    If (SS4)
    {
        Name (\_S4, Package (0x04)  // _S4_: S4 System State
        {
            0x06, 
            0x00, 
            0x00, 
            0x00
        })
    }

    Name (\_S5, Package (0x04)  // _S5_: S5 System State
    {
        0x07, 
        0x00, 
        0x00, 
        0x00
    })
    Scope (\_SB.PCI0)
    {
        Method (_INI, 0, NotSerialized)  // _INI: Initialize
        {
        }
    }

    Method (PTS, 1, NotSerialized)
    {
        If (Arg0)
        {
            \_SB.PCI0.SBRG.SIOS (Arg0)
            \_SB.PCI0.NPTS (Arg0)
            \_SB.PCI0.SBRG.SPTS (Arg0)
        }
    }

    Method (WAK, 1, NotSerialized)
    {
        \_SB.PCI0.SBRG.SIOW (Arg0)
        \_SB.PCI0.NWAK (Arg0)
        \_SB.PCI0.SBRG.SWAK (Arg0)
        \_SB.PCI0.HWAK (Arg0)
    }
}