F71442C2DD56

Intel ACPI Component Architecture
ACPI Binary Table Extraction Utility version 20141107-32 [Apr  6 2015]
Copyright (c) 2000 - 2014 Intel Corporation


Signature  Length      Revision   OemId    OemTableId   OemRevision CompilerId CompilerRevision

      
   0xBFE1C296     0x20    "p   m "  "  Z l   "   0xB7719938    "    "     0x080495AA
   RSDT   0x00000030     0x01    "A M I "  "OEMRSDT "   0x01000504    "MSFT"     0x00000097
   DSDT   0x000072A1     0x01    "0ABBD "  "0ABBD001"   0x00000001    "MSFT"     0x0100000E
   FACS   0x00000040
   FACP   0x00000081     0x02    "A M I "  "OEMFACP "   0x01000504    "MSFT"     0x00000097
   APIC   0x00000054     0x01    "A M I "  "OEMAPIC "   0x01000504    "MSFT"     0x00000097

Found 6 ACPI tables

APIC
----
[000h 0000   4]                    Signature : "APIC"    [Multiple APIC Description Table (MADT)]
[004h 0004   4]                 Table Length : 00000054
[008h 0008   1]                     Revision : 01
[009h 0009   1]                     Checksum : 70
[00Ah 0010   6]                       Oem ID : "A M I "
[010h 0016   8]                 Oem Table ID : "OEMAPIC "
[018h 0024   4]                 Oem Revision : 01000504
[01Ch 0028   4]              Asl Compiler ID : "MSFT"
[020h 0032   4]        Asl Compiler Revision : 00000097

[024h 0036   4]           Local Apic Address : FEE00000
[028h 0040   4]        Flags (decoded below) : 00000001
                         PC-AT Compatibility : 1

[02Ch 0044   1]                Subtable Type : 00 [Processor Local APIC]
[02Dh 0045   1]                       Length : 08
[02Eh 0046   1]                 Processor ID : 01
[02Fh 0047   1]                Local Apic ID : 00
[030h 0048   4]        Flags (decoded below) : 00000001
                           Processor Enabled : 1

[034h 0052   1]                Subtable Type : 01 [I/O APIC]
[035h 0053   1]                       Length : 0C
[036h 0054   1]                  I/O Apic ID : 01
[037h 0055   1]                     Reserved : 00
[038h 0056   4]                      Address : FEC00000
[03Ch 0060   4]                    Interrupt : 00000000

[040h 0064   1]                Subtable Type : 02 [Interrupt Source Override]
[041h 0065   1]                       Length : 0A
[042h 0066   1]                          Bus : 00
[043h 0067   1]                       Source : 00
[044h 0068   4]                    Interrupt : 00000002
[048h 0072   2]        Flags (decoded below) : 0000
                                    Polarity : 0
                                Trigger Mode : 0

[04Ah 0074   1]                Subtable Type : 02 [Interrupt Source Override]
[04Bh 0075   1]                       Length : 0A
[04Ch 0076   1]                          Bus : 00
[04Dh 0077   1]                       Source : 09
[04Eh 0078   4]                    Interrupt : 00000009
[052h 0082   2]        Flags (decoded below) : 000D
                                    Polarity : 1
                                Trigger Mode : 3

Raw Table Data: Length 84 (0x54)

  0000: 41 50 49 43 54 00 00 00 01 70 41 20 4D 20 49 20  APICT....pA M I 
  0010: 4F 45 4D 41 50 49 43 20 04 05 00 01 4D 53 46 54  OEMAPIC ....MSFT
  0020: 97 00 00 00 00 00 E0 FE 01 00 00 00 00 08 01 00  ................
  0030: 01 00 00 00 01 0C 01 00 00 00 C0 FE 00 00 00 00  ................
  0040: 02 0A 00 00 02 00 00 00 00 00 02 0A 00 09 09 00  ................
  0050: 00 00 0D 00                                      ....


DSDT
----
DefinitionBlock ("dsdt.aml", "DSDT", 1, "0ABBD", "0ABBD001", 0x00000001)
{
    OperationRegion (BIOS, SystemMemory, 0x7DF50064, 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
    }

    Name (IO1B, 0x0C00)
    Name (IO1L, 0x80)
    Name (IOEC, 0x0290)
    Name (IO4L, 0x10)
    Name (IOPM, 0x0230)
    Name (IO5L, 0x10)
    Name (SPIO, 0x2E)
    Name (PMBS, 0xE400)
    Name (PMLN, 0x80)
    Name (WFAT, 0x90)
    Name (WNVR, 0x91)
    Name (RNVR, 0x92)
    Name (SWFR, 0x93)
    Name (STDD, 0x94)
    Name (GTDD, 0x95)
    Name (ADBR, 0x96)
    Name (CGPS, 0x97)
    Name (CGWK, 0x98)
    Name (ISWP, 0x99)
    Name (SBIA, 0x9A)
    Name (GPBS, 0xEC00)
    Name (GPLN, 0x40)
    Name (SMBS, 0xE800)
    Name (SMBL, 0x10)
    Name (MBLF, 0x0A)
    Name (APCB, 0xFEC00000)
    Name (APCL, 0x00100000)
    Name (FNC0, 0x00)
    Name (FNC1, 0x16)
    Name (FNC2, 0x1E)
    Name (FNC3, 0x1E)
    Name (FNC4, 0x25)
    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 = 0x55
        }

        PICM = Arg0
    }

    Method (OSFL, 0, NotSerialized)
    {
        Local0 = 0x01
        If (MCTH (\_OS, "Microsoft Windows NT"))
        {
            Local0 = 0x00
        }

        Return (Local0)
    }

    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 (Index (BUF0, Local0)) != DerefOf (Index (BUF1, Local0
                ))))
            {
                Return (Zero)
            }
        }

        Return (One)
    }

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

        Return (PRWP) /* \GPRW.PRWP */
    }

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

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

    Scope (\_PR)
    {
        Processor (CPU1, 0x01, 0x0000E410, 0x06) {}
    }

    Scope (\_SB)
    {
        Name (PR01, Package (0x06)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                LNKC, 
                0x00
            }, 

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

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

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

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

            Package (0x04)
            {
                0x0004FFFF, 
                0x01, 
                LNKD, 
                0x00
            }
        })
        Name (AR01, Package (0x06)
        {
            Package (0x04)
            {
                0xFFFF, 
                0x00, 
                0x00, 
                0x12
            }, 

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

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

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

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

            Package (0x04)
            {
                0x0004FFFF, 
                0x01, 
                0x00, 
                0x13
            }
        })
        Name (PR00, Package (0x07)
        {
            Package (0x04)
            {
                0x0002FFFF, 
                0x00, 
                LNKA, 
                0x00
            }, 

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

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

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

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

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

            Package (0x04)
            {
                0x001DFFFF, 
                0x03, 
                LNKH, 
                0x00
            }
        })
        Name (AR00, Package (0x07)
        {
            Package (0x04)
            {
                0x0002FFFF, 
                0x00, 
                0x00, 
                0x10
            }, 

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

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

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

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

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

            Package (0x04)
            {
                0x001DFFFF, 
                0x03, 
                0x00, 
                0x17
            }
        })
        Name (PRSA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {3,4,5,6,7,11,12}
        })
        Name (PRSB, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, )
                {3,4,5,6,7,12}
        })
        Alias (PRSB, PRSC)
        Alias (PRSB, PRSD)
        Alias (PRSB, PRSE)
        Alias (PRSB, PRSF)
        Alias (PRSB, PRSG)
        Alias (PRSB, PRSH)
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03") /* PCI Bus */)  // _HID: Hardware ID
            Name (_ADR, 0x00)  // _ADR: Address
            Name (_BBN, 0x00)  // _BBN: BIOS Bus Number
            Name (_UID, 0x00)  // _UID: Unique ID
            Method (_PRT, 0, NotSerialized)  // _PRT: PCI Routing Table
            {
                If (PICM)
                {
                    Return (AR00) /* \_SB_.AR00 */
                }

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

            Device (P0P1)
            {
                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 (AR01) /* \_SB_.AR01 */
                    }

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

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

                Device (CBS0)
                {
                    Name (_ADR, 0x00050000)  // _ADR: Address
                    OperationRegion (CBSP, PCI_Config, 0x00, 0xF0)
                    Field (CBSP, DWordAcc, NoLock, Preserve)
                    {
                        Offset (0x04), 
                        CB04,   8, 
                        Offset (0x14), 
                        CB14,   8, 
                        Offset (0x3C), 
                        CB3C,   8, 
                        Offset (0x3E), 
                        CB3E,   8, 
                        Offset (0x44), 
                        CB44,   32, 
                        Offset (0xE0), 
                        PME0,   8, 
                        PME1,   8
                    }

                    Method (_INI, 0, NotSerialized)  // _INI: Initialize
                    {
                        CB44 = Zero
                    }

                    Method (CBSW, 1, NotSerialized)
                    {
                        If ((Arg0 == 0x03))
                        {
                            CB44 = Zero
                        }
                    }

                    Method (CBSR, 0, NotSerialized)
                    {
                        Local1 = (PME1 & 0x80)
                        If (Local1)
                        {
                            PME0 &= 0xFC
                            Local2 = PME1 /* \_SB_.PCI0.P0P1.CBS0.PME1 */
                            PME1 = Local2
                        }

                        Return (Local1)
                    }

                    Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                    {
                        Return (GPRW (0x0B, 0x03))
                    }
                }

                Device (CBS1)
                {
                    Name (_ADR, 0x00050001)  // _ADR: Address
                    OperationRegion (CBSP, PCI_Config, 0x00, 0xF0)
                    Field (CBSP, DWordAcc, NoLock, Preserve)
                    {
                        Offset (0x04), 
                        CB04,   8, 
                        Offset (0x14), 
                        CB14,   8, 
                        Offset (0x3C), 
                        CB3C,   8, 
                        Offset (0x3E), 
                        CB3E,   8, 
                        Offset (0x44), 
                        CB44,   32, 
                        Offset (0xE0), 
                        PME0,   8, 
                        PME1,   8
                    }

                    Method (_INI, 0, NotSerialized)  // _INI: Initialize
                    {
                        CB44 = Zero
                    }

                    Method (CBSW, 1, NotSerialized)
                    {
                        If ((Arg0 == 0x03))
                        {
                            CB44 = Zero
                        }
                    }

                    Method (CBSR, 0, NotSerialized)
                    {
                        Local1 = (PME1 & 0x80)
                        If (Local1)
                        {
                            PME0 &= 0xFC
                            Local2 = PME1 /* \_SB_.PCI0.P0P1.CBS1.PME1 */
                            PME1 = Local2
                        }

                        Return (Local1)
                    }

                    Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                    {
                        Return (GPRW (0x0B, 0x03))
                    }
                }

                Device (P394)
                {
                    Name (_ADR, 0x00050002)  // _ADR: Address
                    Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                    {
                        Return (GPRW (0x0B, 0x03))
                    }
                }

                Device (MPCI)
                {
                    Name (_ADR, 0x00040000)  // _ADR: Address
                    OperationRegion (MINP, PCI_Config, 0x00, 0x68)
                    Field (MINP, ByteAcc, NoLock, Preserve)
                    {
                        VNUM,   32, 
                        Offset (0x09), 
                        PINF,   8, 
                        SBCC,   8, 
                        BSCC,   8, 
                        Offset (0x2C), 
                        SNUM,   32, 
                        Offset (0x34)
                    }

                    Method (MPDP, 0, NotSerialized)
                    {
                        If ((SNUM == 0x04621668))
                        {
                            Return (0x01)
                        }

                        If ((SNUM == 0x25228086))
                        {
                            Return (0x02)
                        }

                        If ((SNUM == 0x25278086))
                        {
                            Return (0x02)
                        }

                        If ((SNUM == 0x25218086))
                        {
                            Return (0x02)
                        }

                        If ((SNUM == 0x25248086))
                        {
                            Return (0x02)
                        }

                        If ((SNUM == 0x25268086))
                        {
                            Return (0x02)
                        }

                        If ((SNUM == 0x27018086))
                        {
                            Return (0x02)
                        }

                        If ((SNUM == 0x27028086))
                        {
                            Return (0x02)
                        }

                        If ((SNUM == 0x10201043))
                        {
                            Return (0x04)
                        }

                        If ((SNUM == 0x120F1043))
                        {
                            Return (0x04)
                        }

                        If ((SNUM == 0x25108086))
                        {
                            Return (0x08)
                        }

                        If ((SNUM != 0xFFFFFFFF))
                        {
                            If ((BSCC == 0x02))
                            {
                                Return (One)
                            }
                        }

                        Return (0x00)
                    }

                    Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                    {
                        Return (GPRW (0x0B, 0x03))
                    }
                }
            }

            Device (SBRG)
            {
                Name (_ADR, 0x001F0000)  // _ADR: Address
                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 (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}
                    })
                }

                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 */
                        }
                    }
                }

                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 (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,
                            0x0063,             // Range Minimum
                            0x0063,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0065,             // Range Minimum
                            0x0065,             // Range Maximum
                            0x00,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0067,             // Range Minimum
                            0x0067,             // Range Maximum
                            0x00,               // Alignment
                            0x09,               // 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
                            _Y00)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x00,               // Alignment
                            0x00,               // Length
                            _Y01)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y00._MIN, GP00)  // _MIN: Minimum Base Address
                        CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y00._MAX, GP01)  // _MAX: Maximum Base Address
                        CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y00._LEN, GP0L)  // _LEN: Length
                        GP00 = PMBS /* \PMBS */
                        GP01 = PMBS /* \PMBS */
                        GP0L = PMLN /* \PMLN */
                        If (GPBS)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y01._MIN, GP20)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y01._MAX, GP21)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y01._LEN, GP2L)  // _LEN: Length
                            GP20 = GPBS /* \GPBS */
                            GP21 = GPBS /* \GPBS */
                            GP2L = GPLN /* \GPLN */
                        }

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

                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
                            _Y02)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y03)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        If (APCB)
                        {
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y02._LEN, ML01)  // _LEN: Length
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y02._BAS, MB01)  // _BAS: Base Address
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y03._LEN, ML02)  // _LEN: Length
                            CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y03._BAS, MB02)  // _BAS: Base Address
                            MB01 = APCB /* \APCB */
                            ML01 = APCL /* \APCL */
                            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
                            _Y04)
                        Memory32Fixed (ReadOnly,
                            0x000E0000,         // Address Base
                            0x00020000,         // Address Length
                            _Y05)
                        Memory32Fixed (ReadWrite,
                            0x00100000,         // Address Base
                            0x00000000,         // Address Length
                            _Y06)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y07)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateDWordField (CRS, \_SB.RMEM._Y04._BAS, BAS1)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.RMEM._Y04._LEN, LEN1)  // _LEN: Length
                        CreateDWordField (CRS, \_SB.RMEM._Y05._BAS, BAS2)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.RMEM._Y05._LEN, LEN2)  // _LEN: Length
                        CreateDWordField (CRS, \_SB.RMEM._Y06._LEN, LEN3)  // _LEN: Length
                        CreateDWordField (CRS, \_SB.RMEM._Y07._BAS, BAS4)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.RMEM._Y07._LEN, LEN4)  // _LEN: Length
                        If (OSFL ()) {}
                        Else
                        {
                            If (MG1B)
                            {
                                If ((MG1B > 0x000C0000))
                                {
                                    BAS1 = 0x000C0000
                                    LEN1 = (MG1B - BAS1) /* \_SB_.RMEM._CRS.BAS1 */
                                }
                            }
                            Else
                            {
                                BAS1 = 0x000C0000
                                LEN1 = 0x00020000
                            }

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

                        LEN3 = (MG2B - 0x00100000)
                        Return (CRS) /* \_SB_.RMEM.CRS_ */
                    }
                }

                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
                            _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)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        If (((SPIO != 0x03F0) && (SPIO > 0xF0)))
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y08._MIN, GP10)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y08._MAX, GP11)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y08._LEN, GPL1)  // _LEN: Length
                            GP10 = SPIO /* \SPIO */
                            GP11 = SPIO /* \SPIO */
                            GPL1 = 0x02
                        }

                        If (IO1B)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y09._MIN, GP20)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y09._MAX, GP21)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y09._LEN, GPL2)  // _LEN: Length
                            GP20 = IO1B /* \IO1B */
                            GP21 = IO1B /* \IO1B */
                            GPL2 = IO1L /* \IO1L */
                        }

                        If (IOEC)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y0A._MIN, GP40)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y0A._MAX, GP41)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y0A._LEN, GPL4)  // _LEN: Length
                            GP40 = IOEC /* \IOEC */
                            GP41 = IOEC /* \IOEC */
                            GPL4 = IO4L /* \IO4L */
                        }

                        If (IOPM)
                        {
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y0B._MIN, GP50)  // _MIN: Minimum Base Address
                            CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y0B._MAX, GP51)  // _MAX: Maximum Base Address
                            CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y0B._LEN, GPL5)  // _LEN: Length
                            GP50 = IOPM /* \IOPM */
                            GP51 = IOPM /* \IOPM */
                            GPL5 = IO5L /* \IO5L */
                        }

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

                Name (DCAT, Package (0x15)
                {
                    0x01, 
                    0x02, 
                    0x03, 
                    0x00, 
                    0xFF, 
                    0x08, 
                    0xFF, 
                    0xFF, 
                    0x06, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0xFF, 
                    0x07, 
                    0x05, 
                    0xFF, 
                    0xFF, 
                    0xFF
                })
                Name (IKEY, Package (0x02)
                {
                    Package (0x04)
                    {
                        0x87, 
                        0x01, 
                        0x55, 
                        0x55
                    }, 

                    Package (0x04)
                    {
                        0x87, 
                        0x01, 
                        0x55, 
                        0xAA
                    }
                })
                Method (ENFG, 1, NotSerialized)
                {
                    Local1 = 0x00
                    If ((SPIO == 0x2E))
                    {
                        Local1 = 0x00
                    }

                    If ((SPIO == 0x4E))
                    {
                        Local1 = 0x01
                    }

                    Local0 = 0x00
                    While ((Local0 != 0x04))
                    {
                        INDX = DerefOf (Index (DerefOf (Index (IKEY, Local1)), Local0))
                        Local0++
                    }

                    LDN = Arg0
                }

                Method (EXFG, 0, NotSerialized)
                {
                    INDX = 0x02
                    DATA = 0x02
                }

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

                Method (UHID, 1, NotSerialized)
                {
                    If ((Arg0 == 0x01))
                    {
                        ENFG (CGLD (Arg0))
                        Local0 = DMCH /* \_SB_.PCI0.SBRG.DMCH */
                        EXFG ()
                        If (((DMCH < 0x04) && ((Local1 = (DMCH & 0x03)) != 0x00)))
                        {
                            Return (0x0160633A)
                        }
                        Else
                        {
                            Return (0x1005D041)
                        }
                    }

                    Return (0x0105D041)
                }

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

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

                Method (SIOH, 0, NotSerialized)
                {
                    Debug = "SIOH"
                }

                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 (0x30), 
                    ACTR,   8, 
                    Offset (0x60), 
                    IOAH,   8, 
                    IOAL,   8, 
                    IOH2,   8, 
                    IOL2,   8, 
                    Offset (0x70), 
                    INTR,   8, 
                    Offset (0x74), 
                    DMCH,   8, 
                    Offset (0xF0), 
                    OPT0,   8, 
                    OPT1,   8, 
                    OPT2,   8
                }

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

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

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

                Method (DCNT, 2, NotSerialized)
                {
                    ENFG (CGLD (Arg0))
                    Local1 = (IOAH << 0x08)
                    Local1 |= IOAL
                    RRIO (Arg0, Arg1, Local1, 0x08)
                    If (((DMCH < 0x04) && ((Local1 = (DMCH & 0x03)) != 0x00)))
                    {
                        RDMA (Arg0, Arg1, Local1++)
                    }

                    ACTR = Arg1
                    EXFG ()
                }

                Name (CRS1, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y0E)
                    IRQNoFlags (_Y0C)
                        {}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y0D)
                        {}
                })
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y0C._INT, IRQM)  // _INT: Interrupts
                CreateByteField (CRS1, \_SB.PCI0.SBRG._Y0D._DMA, DMAM)  // _DMA: Direct Memory Access
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y0E._MIN, IO11)  // _MIN: Minimum Base Address
                CreateWordField (CRS1, \_SB.PCI0.SBRG._Y0E._MAX, IO12)  // _MAX: Maximum Base Address
                CreateByteField (CRS1, \_SB.PCI0.SBRG._Y0E._LEN, LEN1)  // _LEN: Length
                Name (CRS2, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y11)
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x00,               // Length
                        _Y12)
                    IRQNoFlags (_Y0F)
                        {6}
                    DMA (Compatibility, NotBusMaster, Transfer8, _Y10)
                        {2}
                })
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y0F._INT, IRQE)  // _INT: Interrupts
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y10._DMA, DMAE)  // _DMA: Direct Memory Access
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y11._MIN, IO21)  // _MIN: Minimum Base Address
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y11._MAX, IO22)  // _MAX: Maximum Base Address
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y11._LEN, LEN2)  // _LEN: Length
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y12._MIN, IO31)  // _MIN: Minimum Base Address
                CreateWordField (CRS2, \_SB.PCI0.SBRG._Y12._MAX, IO32)  // _MAX: Maximum Base Address
                CreateByteField (CRS2, \_SB.PCI0.SBRG._Y12._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, 0x09, IRQM)
                    CreateByteField (Arg0, 0x0C, DMAM)
                    CreateWordField (Arg0, 0x02, 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 = 0x04
                    }

                    EXFG ()
                    DCNT (Arg1, 0x01)
                }

                Scope (\)
                {
                    OperationRegion (\GPSC, SystemIO, 0xB2, 0x02)
                    Field (\GPSC, ByteAcc, NoLock, Preserve)
                    {
                        SMCM,   8, 
                        SMST,   8
                    }

                    Method (\ISMI, 1, Serialized)
                    {
                        SMCM = Arg0
                    }

                    Method (\DIAG, 1, NotSerialized)
                    {
                        DBG8 = Arg0
                    }

                    OperationRegion (\SIOG, SystemIO, IO1B, 0x10)
                    Field (\SIOG, ByteAcc, NoLock, Preserve)
                    {
                        PO00,   1, 
                        PO01,   1, 
                        PO02,   1, 
                        PO03,   1, 
                        PO04,   1, 
                        PO05,   1, 
                        PO06,   1, 
                        PO07,   1, 
                        PI00,   1, 
                        PI01,   1, 
                        PI02,   1, 
                        PI03,   1, 
                        PI04,   1, 
                        PI05,   1, 
                        PI06,   1, 
                        PI07,   1, 
                        Offset (0x04), 
                        PO10,   1, 
                        PO11,   1, 
                        PO12,   1, 
                        PO13,   1, 
                        PO14,   1, 
                        PO15,   1, 
                        PO16,   1, 
                        PO17,   1, 
                        PI10,   1, 
                        PI11,   1, 
                        PI12,   1, 
                        PI13,   1, 
                        PI14,   1, 
                        PI15,   1, 
                        PI16,   1, 
                        PI17,   1, 
                        Offset (0x08), 
                        PO20,   1, 
                        PO21,   1, 
                        PO22,   1, 
                        PO23,   1, 
                        PO24,   1, 
                        PO25,   1, 
                        PO26,   1, 
                        PO27,   1, 
                        PI20,   1, 
                        PI21,   1, 
                        PI22,   1, 
                        PI23,   1, 
                        PI24,   1, 
                        PI25,   1, 
                        PI26,   1, 
                        PI27,   1, 
                        PO30,   1, 
                        PO31,   1, 
                        PO32,   1, 
                        PO33,   1, 
                        PO34,   1, 
                        PO35,   1, 
                        PO36,   1, 
                        PO37,   1, 
                        PI30,   1, 
                        PI31,   1, 
                        PI32,   1, 
                        PI33,   1, 
                        PI34,   1, 
                        PI35,   1, 
                        PI36,   1, 
                        PI37,   1
                    }

                    OperationRegion (\PMIO, SystemIO, PMBS, 0x80)
                    Field (\PMIO, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x10), 
                            ,   1, 
                        TDTY,   3, 
                        TENA,   1, 
                        TTDT,   3, 
                        FRCT,   1, 
                            ,   8, 
                        THLS,   1, 
                        Offset (0x28), 
                            ,   11, 
                        SBPS,   1, 
                        Offset (0x2A), 
                        Offset (0x2B), 
                        G08S,   1, 
                            ,   2, 
                        G11S,   1, 
                        G12S,   1, 
                        FLPS,   1, 
                        Offset (0x2C), 
                            ,   2, 
                        TPOL,   1, 
                        Offset (0x2D), 
                        Offset (0x2E), 
                        Offset (0x2F), 
                        G08E,   1, 
                            ,   2, 
                        G11E,   1, 
                        G12E,   1, 
                        Offset (0x30), 
                            ,   4, 
                        SLPE,   1, 
                        Offset (0x31), 
                        Offset (0x34), 
                            ,   4, 
                        SLPS,   1, 
                        Offset (0x35), 
                        Offset (0x60), 
                        TRLD,   8, 
                        TTMR,   8, 
                        Offset (0x69), 
                            ,   3, 
                        THLT,   1
                    }

                    OperationRegion (\GPIO, SystemIO, GPBS, 0x40)
                    Field (\GPIO, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x0C), 
                            ,   25, 
                        CBSP,   1, 
                            ,   1, 
                        WLAN,   1, 
                        WLDC,   1, 
                        Offset (0x2C), 
                            ,   11, 
                        LIDL,   1, 
                            ,   1, 
                        FLPL,   1, 
                        Offset (0x38), 
                        BKLT,   1, 
                        PID0,   2, 
                        FS02,   3, 
                        FS56,   2, 
                        PID2,   2
                    }

                    OperationRegion (\ECMS, SystemIO, 0x72, 0x02)
                    Field (\ECMS, ByteAcc, Lock, Preserve)
                    {
                        EIND,   8, 
                        EDAT,   8
                    }

                    IndexField (EIND, EDAT, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x20), 
                        IKFG,   8, 
                        FRPN,   16, 
                        RAMB,   32, 
                        AVOL,   8, 
                        LBTN,   8, 
                        CKLN,   8, 
                        CK00,   8, 
                        CK01,   8, 
                        CK02,   8, 
                        CK03,   8, 
                        CK04,   8, 
                        CK05,   8, 
                        CK06,   8, 
                        CK07,   8, 
                        CK08,   8, 
                        CK09,   8, 
                        CK10,   8, 
                        CK11,   8, 
                        CK12,   8, 
                        CK13,   8, 
                        CK14,   8, 
                        CK15,   8, 
                        CK16,   8, 
                        CK17,   8, 
                        CK18,   8, 
                        CK19,   8, 
                        CK20,   8, 
                        CK21,   8, 
                        CK22,   8, 
                        CK23,   8, 
                        CK24,   8, 
                        CK25,   8, 
                        CK26,   8, 
                        CK27,   8, 
                        CK28,   8, 
                        CK29,   8, 
                        ERRF,   8, 
                        OCLK,   8, 
                        WIDE,   1, 
                        OVCK,   2, 
                        S42K,   3, 
                        S3RM,   1, 
                        Offset (0x4B), 
                        CPUR,   6, 
                        CPUF,   2, 
                        LBT2,   8, 
                        PCMS,   8
                    }

                    OperationRegion (\RAMW, SystemMemory, RAMB, 0xFF)
                    Field (\RAMW, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0xB0), 
                        TRTY,   8, 
                        FSFN,   8, 
                        FSTA,   16, 
                        FADR,   32, 
                        FSIZ,   16, 
                        ACTD,   8, 
                        AVLD,   8, 
                        SETD,   8, 
                        ACPF,   1, 
                        DCPF,   1, 
                        CHGF,   1, 
                        DCP2,   1, 
                        CHG2,   1, 
                        DCTP,   1, 
                        CTYP,   1, 
                        Offset (0xBE), 
                        PADL,   16, 
                        CADL,   16, 
                        CSTE,   16, 
                        NSTE,   16, 
                        SSTE,   16, 
                        SFUN,   8, 
                        TSAD,   8, 
                        TAC3,   8, 
                        TAC2,   8, 
                        TAC1,   8, 
                        TAC0,   8, 
                        TPSV,   8, 
                        TCRT,   8, 
                        F1L0,   8, 
                        F2L0,   8, 
                        F1L1,   8, 
                        F2L1,   8, 
                        F1L2,   8, 
                        F2L2,   8, 
                        F1L3,   8, 
                        F2L3,   8, 
                        F1L4,   8, 
                        F2L4,   8, 
                        SLPT,   8, 
                        DBRD,   32, 
                        AIBF,   1, 
                        Offset (0xE0), 
                        PPSV,   8, 
                        PAC0,   8, 
                        BIAV,   8, 
                        CPUS,   8, 
                        TMPO,   8, 
                        MNAM,   64
                    }

                    Name (OSFG, 0x00)
                    Name (OS9X, 0x01)
                    Name (OS98, 0x02)
                    Name (OSME, 0x04)
                    Name (OS2K, 0x08)
                    Name (OSXP, 0x10)
                    Method (OSVR, 0, NotSerialized)
                    {
                        If (CondRefOf (\_OSI, Local0))
                        {
                            OSFG = OSXP /* \OSXP */
                        }
                        Else
                        {
                            If (MCTH (\_OS, "Microsoft Windows"))
                            {
                                OSFG = OS98 /* \OS98 */
                            }
                            Else
                            {
                                If (MCTH (\_OS, "Microsoft WindowsME: Millennium Edition"))
                                {
                                    OSFG = OSME /* \OSME */
                                }
                                Else
                                {
                                    If (MCTH (\_OS, "Microsoft Windows NT"))
                                    {
                                        OSFG = OS2K /* \OS2K */
                                    }
                                    Else
                                    {
                                        OSFG = OSXP /* \OSXP */
                                    }
                                }
                            }
                        }

                        Return (OSFG) /* \OSFG */
                    }

                    OperationRegion (\SIOP, SystemIO, \SPIO, 0x02)
                    Field (\SIOP, ByteAcc, Lock, Preserve)
                    {
                        SIOI,   8, 
                        SIOD,   8
                    }

                    IndexField (SIOI, SIOD, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x07), 
                        LDNP,   8, 
                        Offset (0x30), 
                        LDCP,   8
                    }

                    Method (\DBGR, 1, NotSerialized)
                    {
                        Local0 = LDNP /* \LDNP */
                        LDNP = 0x01
                        Local1 = LDCP /* \LDCP */
                        LDCP = 0x01
                        DBRD = Arg0
                        \ISMI (\ADBR)
                        LDNP = 0x01
                        LDCP = Local1
                        LDNP = Local0
                    }

                    Name (ONAM, "ASUSTEK")
                }

                Scope (\_SB.PCI0)
                {
                    Method (_INI, 0, NotSerialized)  // _INI: Initialize
                    {
                        \OSVR ()
                        \WLAN = Zero
                    }
                }

                Scope (\_SB.PCI0.SBRG)
                {
                    OperationRegion (GPMC, PCI_Config, 0xA0, 0x60)
                    Field (GPMC, ByteAcc, NoLock, Preserve)
                    {
                            ,   7, 
                        C4EN,   1
                    }

                    Method (_INI, 0, NotSerialized)  // _INI: Initialize
                    {
                        C4C3 ()
                    }

                    Method (C4C3, 0, NotSerialized)
                    {
                        If (CPUS)
                        {
                            Local0 = (\ACPF ^ One)
                            C4EN = Local0
                        }
                        Else
                        {
                            C4EN = Zero
                        }
                    }
                }

                Scope (\_SB.PCI0.SBRG)
                {
                    Device (EC0)
                    {
                        Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */)  // _HID: Hardware ID
                        Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
                        {
                            IO (Decode16,
                                0x0062,             // Range Minimum
                                0x0062,             // Range Maximum
                                0x00,               // Alignment
                                0x01,               // Length
                                )
                            IO (Decode16,
                                0x0066,             // Range Minimum
                                0x0066,             // Range Maximum
                                0x00,               // Alignment
                                0x01,               // Length
                                )
                        })
                        Name (_GPE, 0x1C)  // _GPE: General Purpose Events
                        Mutex (MUEC, 0x00)
                        Name (ECFL, Zero)
                        Method (ECAV, 0, NotSerialized)
                        {
                            Return (ECFL) /* \_SB_.PCI0.SBRG.EC0_.ECFL */
                        }

                        OperationRegion (ECOR, EmbeddedControl, 0x00, 0x80)
                        Field (ECOR, ByteAcc, Lock, Preserve)
                        {
                            Offset (0x04), 
                            CMD1,   8, 
                            CDT1,   8, 
                            CDT2,   8, 
                            CDT3,   8, 
                            Offset (0x43), 
                            P50I,   1, 
                                ,   1, 
                                ,   1, 
                            P43I,   1, 
                            P54I,   1, 
                            P55I,   1, 
                                ,   1, 
                            Offset (0x44), 
                            P54D,   8, 
                            P55D,   8, 
                            Offset (0x48), 
                            P54S,   8, 
                            P55S,   8, 
                            P50S,   8, 
                            P43S,   8, 
                            P54T,   8, 
                            P55T,   8, 
                            P50T,   8, 
                            P43T,   8, 
                            P60S,   8, 
                            P61S,   8, 
                            P62S,   8, 
                            P63S,   8, 
                            P64S,   8, 
                            P65S,   8, 
                            P66S,   8, 
                            P67S,   8, 
                            P60T,   8, 
                            P61T,   8, 
                            P62T,   8, 
                            P63T,   8, 
                            P64T,   8, 
                            P65T,   8, 
                            P66T,   8, 
                            P67T,   8, 
                            Offset (0x78), 
                            P60I,   1, 
                            P61I,   1, 
                            P62I,   1, 
                            P63I,   1, 
                            P64I,   1, 
                            P65I,   1, 
                            P66I,   1, 
                            P67I,   1
                        }

                        Name (SMBF, 0x00)
                        OperationRegion (SMBX, EmbeddedControl, 0x18, 0x28)
                        Field (SMBX, ByteAcc, NoLock, Preserve)
                        {
                            PRTC,   8, 
                            SSTS,   5, 
                                ,   1, 
                            ALFG,   1, 
                            CDFG,   1, 
                            ADDR,   8, 
                            CMDB,   8, 
                            BDAT,   256, 
                            BCNT,   8, 
                                ,   1, 
                            ALAD,   7, 
                            ALD0,   8, 
                            ALD1,   8
                        }

                        Field (SMBX, ByteAcc, NoLock, Preserve)
                        {
                            Offset (0x04), 
                            DAT0,   8, 
                            DAT1,   8
                        }

                        Field (SMBX, ByteAcc, NoLock, Preserve)
                        {
                            Offset (0x04), 
                            DT2B,   16
                        }

                        OperationRegion (NSBS, EmbeddedControl, 0x40, 0x04)
                        Field (NSBS, ByteAcc, NoLock, Preserve)
                        {
                            A2AD,   8, 
                            A2D0,   8, 
                            A2D1,   8, 
                            A3AD,   8
                        }

                        Method (_INI, 0, NotSerialized)  // _INI: Initialize
                        {
                            If ((\OSFG <= \OSME))
                            {
                                ECFL = One
                            }
                        }

                        Method (_REG, 2, NotSerialized)  // _REG: Region Availability
                        {
                            If ((Arg0 == 0x03))
                            {
                                ECFL = Arg1
                            }
                        }

                        Method (_Q01, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x52) // Reserved
                            }
                        }

                        Method (_Q02, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x53) // Reserved
                            }
                        }

                        Method (_Q03, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x54) // Reserved
                            }
                        }

                        Method (_Q04, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x55) // Reserved
                            }
                        }

                        Method (_Q05, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x56) // Reserved
                            }
                        }

                        Method (_Q09, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            DWDG ()
                            Notify (\_SB.PCI0.BAT0, 0x80) // Status Change
                        }

                        Method (_Q0A, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            Notify (\_SB.SLPB, 0x80) // Status Change
                        }

                        Method (_Q0B, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            \WLAN = Zero
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x5D) // Reserved
                            }
                        }

                        Method (_Q0E, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If ((LBTN > 0x00))
                            {
                                LBTN--
                            }

                            If ((LBTN > 0x0F))
                            {
                                LBTN = 0x0F
                            }

                            STBR ()
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, (LBTN + 0x20))
                            }
                        }

                        Method (_Q0F, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If ((LBTN < 0x0F))
                            {
                                LBTN++
                            }
                            Else
                            {
                                LBTN = 0x0F
                            }

                            STBR ()
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, (LBTN + 0x10))
                            }
                        }

                        Method (_Q10, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            Local0 = \BKLT
                            Local0 ^= 0x01
                            \BKLT = Local0
                            If (\_SB.ATKP)
                            {
                                Local0 = (0x34 - \BKLT)
                                Notify (\_SB.ATKD, Local0)
                            }
                        }

                        Method (_Q11, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            FHKW ()
                            Local0 = \ADVG ()
                            If (\NATK ())
                            {
                                Local1 = (Local0 + 0x60)
                                If (\_SB.ATKP)
                                {
                                    Notify (\_SB.ATKD, Local1)
                                }
                                Else
                                {
                                    \SWHG (Local0)
                                }
                            }
                            Else
                            {
                                \SWHG (Local0)
                            }

                            FHKS ()
                        }

                        Name (FHKM, One)
                        Method (FHKW, 0, Serialized)
                        {
                            While (!FHKM)
                            {
                                Sleep (0x0A)
                            }

                            FHKM = Zero
                        }

                        Method (FHKS, 0, Serialized)
                        {
                            FHKM = One
                        }

                        Method (_Q13, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x32) // Reserved
                            }
                        }

                        Method (_Q14, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If ((\AVOL < 0x0F))
                            {
                                \AVOL++
                            }

                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x31) // Reserved
                            }
                        }

                        Method (_Q15, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If ((\AVOL > 0x00))
                            {
                                \AVOL--
                            }

                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x30) // Reserved
                            }
                        }

                        Method (_Q20, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (CDFG)
                            {
                                SMBF = One
                                CDFG = Zero
                            }

                            If (ALFG)
                            {
                                \_SB.PCI0.SBRG.EC0.ALMH (ALAD)
                                ALFG = Zero
                            }
                        }

                        Method (_Q30, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x50) // Reserved
                            }
                        }

                        Method (_Q31, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x51) // Reserved
                            }
                        }

                        Method (_Q32, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x5C) // Reserved
                            }
                        }

                        Method (_Q33, 0, NotSerialized)  // _Qxx: EC Query
                        {
                            If (\_SB.ATKP)
                            {
                                Notify (\_SB.ATKD, 0x6B) // Reserved
                            }
                        }

                        Name (LEDS, Ones)
                        Method (EC0S, 1, NotSerialized)
                        {
                            If ((Arg0 == 0x01))
                            {
                                STC5 (0x53)
                            }

                            If ((Arg0 == 0x03))
                            {
                                STC5 (0x2C)
                                STC5 (0x53)
                            }

                            If (Arg0)
                            {
                                If ((Arg0 < 0x04))
                                {
                                    Local0 = RDC3 (0x02)
                                    LEDS = (Local0 & 0xE0)
                                    Local1 = (LEDS & 0x80)
                                    If (!Local1)
                                    {
                                        STC5 (0x2F)
                                    }

                                    Local1 = (LEDS & 0x40)
                                    If (!Local1)
                                    {
                                        STC5 (0x2E)
                                    }

                                    Local1 = (LEDS & 0x20)
                                    If (!Local1)
                                    {
                                        STC5 (0x2D)
                                    }
                                }
                            }
                        }

                        Method (EC0W, 1, NotSerialized)
                        {
                            If ((Arg0 == 0x01))
                            {
                                STC5 (0x33)
                            }

                            If ((Arg0 == 0x03))
                            {
                                STC5 (0x2C)
                                STC5 (0x33)
                            }

                            If ((Arg0 <= 0x04))
                            {
                                \ACPF = ACPS ()
                                \DCPF = DCPS (0x00)
                            }

                            If (Arg0)
                            {
                                If ((Arg0 < 0x04))
                                {
                                    Local1 = (LEDS & 0x80)
                                    If (!Local1)
                                    {
                                        STC5 (0x4F)
                                    }

                                    Local1 = (LEDS & 0x40)
                                    If (!Local1)
                                    {
                                        STC5 (0x4E)
                                    }

                                    Local1 = (LEDS & 0x20)
                                    If (!Local1)
                                    {
                                        STC5 (0x4D)
                                    }
                                }
                            }
                        }
                    }
                }

                Scope (\_SB.PCI0.SBRG.EC0)
                {
                    Method (WCMD, 1, Serialized)
                    {
                        If (ECAV ())
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                CMD1 = Arg0
                                Release (MUEC)
                            }
                        }
                        Else
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                ECWC (Arg0)
                                Release (MUEC)
                            }
                        }
                    }

                    Method (DLY0, 1, Serialized)
                    {
                        If (!ECAV ())
                        {
                            Return (Ones)
                        }

                        Local0 = Ones
                        If ((Acquire (MUEC, 0xFFFF) == 0x00))
                        {
                            CDT1 = Arg0
                            CDT2 = 0x6B
                            CDT3 = 0x00
                            CMD1 = 0xBB
                            Local1 = 0x7F
                            While ((Local1 && CMD1))
                            {
                                Sleep (0x01)
                                Local1--
                            }

                            If ((CMD1 == Zero))
                            {
                                Local0 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                            }

                            Release (MUEC)
                        }

                        Return (Local0)
                    }

                    Name (PWAC, Buffer (0x10)
                    {
                        /* 0000 */  0x17, 0x2E, 0x3D, 0x49, 0x58, 0x60, 0x64, 0x68,  /* ..=IX`dh */
                        /* 0008 */  0x6C, 0x70, 0x73, 0x77, 0x7B, 0x7F, 0x83, 0x87   /* lpsw{... */
                    })
                    Name (PWDC, Buffer (0x10)
                    {
                        /* 0000 */  0x0F, 0x26, 0x36, 0x41, 0x51, 0x58, 0x5C, 0x60,  /* .&6AQX\` */
                        /* 0008 */  0x64, 0x68, 0x6C, 0x70, 0x73, 0x77, 0x7B, 0x7F   /* dhlpsw{. */
                    })
                    Method (STBR, 0, Serialized)
                    {
                        If (ACAP ())
                        {
                            Local0 = DerefOf (Index (PWAC, LBTN))
                        }
                        Else
                        {
                            Local0 = DerefOf (Index (PWDC, LBTN))
                        }

                        STC4 (Local0)
                    }

                    Method (STC4, 1, Serialized)
                    {
                        If (ECAV ())
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                CDT1 = Arg0
                                CDT2 = 0x85
                                CMD1 = 0xC4
                                Local0 = 0x7F
                                While ((Local0 && CMD1))
                                {
                                    Sleep (0x01)
                                    Local0--
                                }

                                If ((CMD1 == Zero))
                                {
                                    Local0 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                                }
                                Else
                                {
                                    Local0 = Ones
                                }

                                Release (MUEC)
                                Return (Local0)
                            }
                        }

                        Return (Ones)
                    }

                    Method (STDA, 1, Serialized)
                    {
                        If (ECAV ())
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                CDT1 = Arg0
                                CDT2 = 0xD0
                                CMD1 = 0xDA
                                Local0 = 0x7F
                                While ((Local0 && CMD1))
                                {
                                    Sleep (0x01)
                                    Local0--
                                }

                                If ((CMD1 == Zero))
                                {
                                    Local0 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                                }
                                Else
                                {
                                    Local0 = Ones
                                }

                                Release (MUEC)
                                Return (Local0)
                            }
                        }

                        Return (Ones)
                    }

                    Method (STDC, 1, Serialized)
                    {
                        If (ECAV ())
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                CDT1 = Arg0
                                CDT2 = 0xD0
                                CMD1 = 0xDC
                                Local0 = 0x7F
                                While ((Local0 && CMD1))
                                {
                                    Sleep (0x01)
                                    Local0--
                                }

                                If ((CMD1 == Zero))
                                {
                                    Local0 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                                }
                                Else
                                {
                                    Local0 = Ones
                                }

                                Release (MUEC)
                                Return (Local0)
                            }
                        }

                        Return (Ones)
                    }

                    Method (ACAP, 0, Serialized)
                    {
                        Return (\ACPF)
                    }

                    Method (ACPS, 0, Serialized)
                    {
                        If (ECAV ())
                        {
                            Local0 = RDC3 (0x06)
                            While ((Local0 == Ones))
                            {
                                Local0 = RDC3 (0x06)
                            }

                            Local0 &= 0x10
                            Local0 >>= 0x04
                            If ((\CPUS == Zero))
                            {
                                Local1 = RDC3 (0x05)
                                While ((Local1 == Ones))
                                {
                                    Local1 = RDC3 (0x05)
                                }

                                Local1 &= 0x10
                                If ((Local0 == 0x00))
                                {
                                    If ((Local1 == 0x00))
                                    {
                                        \FRCT = One
                                        \TTDT = 0x02
                                    }
                                }
                                Else
                                {
                                    If ((Local1 == 0x00))
                                    {
                                        \FRCT = Zero
                                        \TTDT = Zero
                                    }
                                }
                            }
                            Else
                            {
                                Local1 = RDC3 (0x05)
                                While ((Local1 == Ones))
                                {
                                    Local1 = RDC3 (0x05)
                                }

                                Local1 &= 0x10
                                If (Local1)
                                {
                                    \DCTP = One
                                }
                                Else
                                {
                                    \DCTP = Zero
                                }
                            }

                            Return (Local0)
                        }
                        Else
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                Local0 = ECRP (0x06)
                                Local0 >>= 0x04
                                Local0 &= 0x01
                                Release (MUEC)
                                Return (Local0)
                            }
                        }
                    }

                    Method (BATP, 1, Serialized)
                    {
                        If (Arg0)
                        {
                            Return (\DCP2)
                        }
                        Else
                        {
                            Return (\DCPF)
                        }
                    }

                    Method (DCPS, 1, Serialized)
                    {
                        If (ECAV ())
                        {
                            If (Arg0)
                            {
                                Local0 = RDC3 (0x04)
                                While ((Local0 == Ones))
                                {
                                    Local0 = RDC3 (0x04)
                                }

                                Local0 &= 0x08
                            }
                            Else
                            {
                                Local0 = RDC3 (0x05)
                                While ((Local0 == Ones))
                                {
                                    Local0 = RDC3 (0x05)
                                }

                                Local0 &= 0x20
                            }

                            If (Local0)
                            {
                                Return (Zero)
                            }
                            Else
                            {
                                Return (One)
                            }
                        }
                        Else
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                If (Arg0)
                                {
                                    Local0 = ECRP (0x04)
                                    Local0 >>= 0x03
                                }
                                Else
                                {
                                    Local0 = ECRP (0x05)
                                    Local0 >>= 0x05
                                }

                                Local0 &= 0x01
                                Release (MUEC)
                                If (Local0)
                                {
                                    Return (Zero)
                                }
                                Else
                                {
                                    Return (One)
                                }
                            }
                        }
                    }

                    Method (CHGS, 1, Serialized)
                    {
                        BATS (Arg0)
                        Local0 = SMBR (RDWD, BADR, 0x16)
                        BATR ()
                        Local1 = DerefOf (Index (Local0, 0x00))
                        If (Local1)
                        {
                            Return (\ACPF)
                        }
                        Else
                        {
                            Local2 = DerefOf (Index (Local0, 0x02))
                            Local2 >>= 0x06
                            Local2 &= 0x01
                            Local2 ^= 0x01
                            Return (Local2)
                        }
                    }

                    Method (STC5, 1, Serialized)
                    {
                        If (ECAV ())
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                CDT1 = Arg0
                                CMD1 = 0xC5
                                Local0 = 0x7F
                                While ((Local0 && CMD1))
                                {
                                    Sleep (0x01)
                                    Local0--
                                }

                                If ((CMD1 == Zero))
                                {
                                    Local0 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                                }
                                Else
                                {
                                    Local0 = Ones
                                }

                                Release (MUEC)
                                Return (Local0)
                            }
                        }
                        Else
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                ECSP (Arg0)
                                Release (MUEC)
                                Return (One)
                            }
                        }

                        Return (Ones)
                    }

                    Method (RDC3, 1, Serialized)
                    {
                        If (ECAV ())
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                CDT1 = Arg0
                                CMD1 = 0xC3
                                Local0 = 0x7F
                                While ((Local0 && CMD1))
                                {
                                    Sleep (0x01)
                                    Local0--
                                }

                                If ((CMD1 == Zero))
                                {
                                    Local0 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                                }
                                Else
                                {
                                    Local0 = Ones
                                }

                                Release (MUEC)
                                Return (Local0)
                            }
                        }
                        Else
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                Local0 = ECRP (Arg0)
                                Release (MUEC)
                                Return (Local0)
                            }
                        }

                        Return (Ones)
                    }

                    Method (RBAT, 2, Serialized)
                    {
                        If (!ECAV ())
                        {
                            Return (Ones)
                        }

                        If ((Acquire (MUEC, 0xFFFF) == 0x00))
                        {
                            Local0 = 0x03
                            While (Local0)
                            {
                                CDT2 = Arg0
                                Local1 = Arg1
                                Local1 <<= 0x01
                                Local1 += 0xDA
                                CMD1 = Local1
                                Local1 = 0x7F
                                While ((CMD1 && Local1))
                                {
                                    Local1--
                                    Sleep (0x01)
                                }

                                If ((CMD1 == 0x00))
                                {
                                    Local1 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                                    Local0 = Zero
                                }
                                Else
                                {
                                    Local1 = Ones
                                    Local0--
                                }
                            }

                            Release (MUEC)
                            Return (Local1)
                        }

                        Return (Ones)
                    }

                    Method (FNCT, 2, Serialized)
                    {
                        If (ECAV ())
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                CDT2 = Arg0
                                CDT1 = Arg1
                                CMD1 = 0xC4
                                Local0 = 0x7F
                                While ((Local0 && CMD1))
                                {
                                    Sleep (0x01)
                                    Local0--
                                }

                                Release (MUEC)
                            }
                        }
                    }

                    Name (WRQK, 0x02)
                    Name (RDQK, 0x03)
                    Name (SDBT, 0x04)
                    Name (RCBT, 0x05)
                    Name (WRBT, 0x06)
                    Name (RDBT, 0x07)
                    Name (WRWD, 0x08)
                    Name (RDWD, 0x09)
                    Name (WRBL, 0x0A)
                    Name (RDBL, 0x0B)
                    Name (PCLL, 0x0C)
                    Name (GOOD, 0x00)
                    Name (UKER, 0x07)
                    Name (DAER, 0x10)
                    Name (CMDN, 0x12)
                    Name (UKE2, 0x13)
                    Name (DADN, 0x17)
                    Name (SBTO, 0x18)
                    Name (USPT, 0x19)
                    Name (SBBY, 0x1A)
                    Mutex (MUSB, 0x00)
                    Method (SWTC, 1, Serialized)
                    {
                        Local0 = UKER /* \_SB_.PCI0.SBRG.EC0_.UKER */
                        Local1 = 0x03
                        While ((Local0 && Local1))
                        {
                            Local2 = 0x23
                            While (Local2)
                            {
                                If (PRTC)
                                {
                                    Sleep (0x01)
                                    Local2--
                                }
                                Else
                                {
                                    Local2 = Zero
                                    Local0 = SSTS /* \_SB_.PCI0.SBRG.EC0_.SSTS */
                                }
                            }

                            If (Local0)
                            {
                                PRTC = Zero
                                Local1--
                                If (Local1)
                                {
                                    Sleep (0x01)
                                    PRTC = Arg0
                                }
                            }
                        }

                        Return (Local0)
                    }

                    Method (SMBR, 3, NotSerialized)
                    {
                        Local0 = Package (0x03)
                            {
                                0x07, 
                                0x00, 
                                0x00
                            }
                        If (!ECAV ())
                        {
                            Return (Local0)
                        }

                        If ((Arg0 != RDBL))
                        {
                            If ((Arg0 != RDWD))
                            {
                                If ((Arg0 != RDBT))
                                {
                                    If ((Arg0 != RCBT))
                                    {
                                        If ((Arg0 != RDQK))
                                        {
                                            Return (Local0)
                                        }
                                    }
                                }
                            }
                        }

                        If ((Acquire (MUSB, 0xFFFF) == 0x00))
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */
                                Local2 = Zero
                                While ((Local1 != 0x00))
                                {
                                    Stall (0x0A)
                                    Local2++
                                    If ((Local2 > 0x03E8))
                                    {
                                        Index (Local0, 0x00) = SBBY /* \_SB_.PCI0.SBRG.EC0_.SBBY */
                                        Local1 = Zero
                                    }
                                    Else
                                    {
                                        Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */
                                    }
                                }

                                Release (MUEC)
                            }

                            If ((Local2 <= 0x03E8))
                            {
                                Local3 = (Arg1 << 0x01)
                                Local3 |= 0x01
                                If ((Acquire (MUEC, 0xFFFF) == 0x00))
                                {
                                    ADDR = Local3
                                    If ((Arg0 != RDQK))
                                    {
                                        If ((Arg0 != RCBT))
                                        {
                                            CMDB = Arg2
                                        }
                                    }

                                    PRTC = Arg0
                                    Release (MUEC)
                                }

                                Index (Local0, 0x00) = SWTC (Arg0)
                                If ((DerefOf (Index (Local0, 0x00)) == 0x00))
                                {
                                    If ((Acquire (MUEC, 0xFFFF) == 0x00))
                                    {
                                        If ((Arg0 == RDBL))
                                        {
                                            Index (Local0, 0x01) = BCNT /* \_SB_.PCI0.SBRG.EC0_.BCNT */
                                            Index (Local0, 0x02) = BDAT /* \_SB_.PCI0.SBRG.EC0_.BDAT */
                                        }

                                        If ((Arg0 == RDWD))
                                        {
                                            Index (Local0, 0x01) = 0x02
                                            Index (Local0, 0x02) = DT2B /* \_SB_.PCI0.SBRG.EC0_.DT2B */
                                        }

                                        If ((Arg0 == RDBT))
                                        {
                                            Index (Local0, 0x01) = 0x01
                                            Index (Local0, 0x02) = DAT0 /* \_SB_.PCI0.SBRG.EC0_.DAT0 */
                                        }

                                        If ((Arg0 == RCBT))
                                        {
                                            Index (Local0, 0x01) = 0x01
                                            Index (Local0, 0x02) = DAT0 /* \_SB_.PCI0.SBRG.EC0_.DAT0 */
                                        }

                                        Release (MUEC)
                                    }
                                }
                            }

                            Release (MUSB)
                        }

                        Return (Local0)
                    }

                    Method (SMBW, 5, NotSerialized)
                    {
                        Local0 = Package (0x01)
                            {
                                0x07
                            }
                        If (!ECAV ())
                        {
                            Return (Local0)
                        }

                        If ((Arg0 != WRBL))
                        {
                            If ((Arg0 != WRWD))
                            {
                                If ((Arg0 != WRBT))
                                {
                                    If ((Arg0 != SDBT))
                                    {
                                        If ((Arg0 != WRQK))
                                        {
                                            Return (Local0)
                                        }
                                    }
                                }
                            }
                        }

                        If ((Acquire (MUSB, 0xFFFF) == 0x00))
                        {
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */
                                Local2 = Zero
                                While ((Local1 != 0x00))
                                {
                                    Stall (0x0A)
                                    Local2++
                                    If ((Local2 > 0x03E8))
                                    {
                                        Index (Local0, 0x00) = SBBY /* \_SB_.PCI0.SBRG.EC0_.SBBY */
                                        Local1 = Zero
                                    }
                                    Else
                                    {
                                        Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */
                                    }
                                }

                                Release (MUEC)
                            }

                            If ((Local2 <= 0x03E8))
                            {
                                Local3 = (Arg1 << 0x01)
                                If ((Acquire (MUEC, 0xFFFF) == 0x00))
                                {
                                    ADDR = Local3
                                    If ((Arg0 != WRQK))
                                    {
                                        If ((Arg0 != SDBT))
                                        {
                                            CMDB = Arg2
                                        }
                                    }

                                    If ((Arg0 == WRBL))
                                    {
                                        BCNT = Arg3
                                        BDAT = Arg4
                                    }

                                    If ((Arg0 == WRWD))
                                    {
                                        DT2B = Arg4
                                    }

                                    If ((Arg0 == WRBT))
                                    {
                                        DAT0 = Arg4
                                    }

                                    If ((Arg0 == SDBT))
                                    {
                                        DAT0 = Arg4
                                    }

                                    PRTC = Arg0
                                    Release (MUEC)
                                }

                                Index (Local0, 0x00) = SWTC (Arg0)
                            }

                            Release (MUSB)
                        }

                        Return (Local0)
                    }

                    OperationRegion (K62P, SystemIO, 0x62, 0x01)
                    Field (K62P, ByteAcc, NoLock, Preserve)
                    {
                        EC62,   8
                    }

                    OperationRegion (K66P, SystemIO, 0x66, 0x01)
                    Field (K66P, ByteAcc, NoLock, Preserve)
                    {
                        EC66,   8
                    }

                    Alias (\G12E, KSCE)
                    Alias (\G12S, KSCS)
                    Method (WEIE, 0, NotSerialized)
                    {
                        Local0 = 0x4000
                        Local1 = (EC66 & 0x02)
                        While (((Local0 != Zero) && (Local1 == 0x02)))
                        {
                            Local1 = (EC66 & 0x02)
                            Local0--
                        }
                    }

                    Method (WEOF, 0, NotSerialized)
                    {
                        Local0 = 0x4000
                        Local1 = (EC66 & 0x01)
                        While (((Local0 != Zero) && (Local1 == 0x00)))
                        {
                            Local1 = (EC66 & 0x01)
                            Local0--
                        }
                    }

                    Method (ECRD, 1, NotSerialized)
                    {
                        Local1 = KSCE /* \_SB_.PCI0.SBRG.EC0_.KSCE */
                        KSCE = Zero
                        WEIE ()
                        EC66 = 0x80
                        WEIE ()
                        EC62 = Arg0
                        WEOF ()
                        Local0 = EC62 /* \_SB_.PCI0.SBRG.EC0_.EC62 */
                        While (KSCS)
                        {
                            KSCS = One
                        }

                        KSCE = Local1
                        Return (Local0)
                    }

                    Method (ECWR, 2, NotSerialized)
                    {
                        Local1 = KSCE /* \_SB_.PCI0.SBRG.EC0_.KSCE */
                        KSCE = Zero
                        WEIE ()
                        EC66 = 0x81
                        WEIE ()
                        EC62 = Arg0
                        WEIE ()
                        EC62 = Arg1
                        WEIE ()
                        While (KSCS)
                        {
                            KSCS = One
                        }

                        KSCE = Local1
                    }

                    Method (ECWC, 1, NotSerialized)
                    {
                        Local1 = KSCE /* \_SB_.PCI0.SBRG.EC0_.KSCE */
                        KSCE = Zero
                        WEIE ()
                        EC66 = 0x81
                        WEIE ()
                        EC62 = 0x04
                        WEIE ()
                        EC62 = Arg0
                        While (KSCS)
                        {
                            KSCS = One
                        }

                        KSCE = Local1
                    }

                    Method (ECQR, 0, NotSerialized)
                    {
                        Local1 = KSCE /* \_SB_.PCI0.SBRG.EC0_.KSCE */
                        KSCE = Zero
                        WEIE ()
                        EC66 = 0x84
                        WEIE ()
                        WEOF ()
                        Local0 = EC62 /* \_SB_.PCI0.SBRG.EC0_.EC62 */
                        While (KSCS)
                        {
                            KSCS = One
                        }

                        KSCE = Local1
                        Return (Local0)
                    }

                    Method (ECRP, 1, NotSerialized)
                    {
                        ECWR (0x05, Arg0)
                        ECWR (0x04, 0xC3)
                        While (ECRD (0x04)) {}
                        Return (ECRD (0x05))
                    }

                    Method (ECSP, 1, NotSerialized)
                    {
                        ECWR (0x05, Arg0)
                        ECWR (0x04, 0xC5)
                        While (ECRD (0x04)) {}
                    }

                    Method (RAMR, 2, NotSerialized)
                    {
                        If (!ECAV ())
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If ((Acquire (MUEC, 0x0FFF) == 0x00))
                            {
                                CDT3 = Arg0
                                CDT2 = Arg1
                                CMD1 = 0xBA
                                Local1 = 0x0001FFFF
                                While ((CMD1 && Local1))
                                {
                                    Local1--
                                    Stall (0x01)
                                }

                                If ((CMD1 == 0x00))
                                {
                                    Local1 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */
                                }
                                Else
                                {
                                    Local1 = Ones
                                }

                                Release (MUEC)
                                Return (Local1)
                            }

                            Local0--
                        }

                        Return (Ones)
                    }

                    Method (RAMW, 3, NotSerialized)
                    {
                        If (!ECAV ())
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If ((Acquire (MUEC, 0x0FFF) == 0x00))
                            {
                                CDT3 = Arg0
                                CDT2 = Arg1
                                CDT1 = Arg2
                                CMD1 = 0xBB
                                Local1 = 0x0001FFFF
                                While ((CMD1 && Local1))
                                {
                                    Local1--
                                    Stall (0x01)
                                }

                                If ((CMD1 == 0x00))
                                {
                                    Local1 = Zero
                                }
                                Else
                                {
                                    Local1 = Ones
                                }

                                Release (MUEC)
                                Return (Local1)
                            }

                            Local0--
                        }

                        Return (Ones)
                    }

                    Method (AWDG, 0, NotSerialized)
                    {
                        RAMW (0x00, 0x6E, 0x80)
                        RAMW (0x01, 0xDE, 0xC8)
                        RAMW (0x01, 0xDF, 0x01)
                        EWDG ()
                    }

                    Method (EWDG, 0, NotSerialized)
                    {
                        RAMW (0x00, 0x6B, 0x03)
                    }

                    Method (DWDG, 0, NotSerialized)
                    {
                        RAMW (0x00, 0x6B, 0x00)
                    }
                }

                Scope (\_SB.PCI0.SBRG.EC0)
                {
                    Method (_Q69, 0, NotSerialized)  // _Qxx: EC Query
                    {
                        If (\_SB.ATKP)
                        {
                            Notify (\_SB.ATKD, 0x40) // Reserved
                        }
                    }

                    Method (_Q6A, 0, NotSerialized)  // _Qxx: EC Query
                    {
                        If (\_SB.ATKP)
                        {
                            Notify (\_SB.ATKD, 0x41) // Reserved
                        }
                    }

                    Method (_Q6B, 0, NotSerialized)  // _Qxx: EC Query
                    {
                        If (\_SB.ATKP)
                        {
                            Notify (\_SB.ATKD, 0x43) // Reserved
                        }
                    }

                    Method (_Q6C, 0, NotSerialized)  // _Qxx: EC Query
                    {
                        If (\_SB.ATKP)
                        {
                            Notify (\_SB.ATKD, 0x45) // Reserved
                        }
                    }

                    Method (_Q51, 0, NotSerialized)  // _Qxx: EC Query
                    {
                    }
                }

                Scope (\_SB.PCI0)
                {
                    Name (ACFL, 0x01)
                    Device (AC0)
                    {
                        Name (_HID, "ACPI0003" /* Power Source Device */)  // _HID: Hardware ID
                        Method (_PSR, 0, NotSerialized)  // _PSR: Power Source
                        {
                            If (ACFL)
                            {
                                \_SB.PCI0.SBRG.EC0.ACPS ()
                                ACFL = Zero
                            }

                            Return (\_SB.PCI0.SBRG.EC0.ACAP ())
                        }

                        Name (_PCL, Package (0x01)  // _PCL: Power Consumer List
                        {
                            \_SB.PCI0
                        })
                    }
                }

                Scope (\_SB.PCI0.SBRG.EC0)
                {
                    Method (_Q34, 0, NotSerialized)  // _Qxx: EC Query
                    {
                        If (ACPS ())
                        {
                            AWDG ()
                            \ACPF = One
                            Local0 = 0x58
                        }
                        Else
                        {
                            \ACPF = Zero
                            Local0 = 0x57
                        }

                        If ((Acquire (MUEC, 0xFFFF) == 0x00))
                        {
                            P64S ^= 0x10
                            Release (MUEC)
                        }

                        STBR ()
                        Notify (\_SB.PCI0.AC0, 0x80) // Status Change
                        NBAT (0x80)
                        \_SB.PCI0.SBRG.C4C3 ()
                        If (\_SB.ATKP)
                        {
                            Notify (\_SB.ATKD, Local0)
                        }

                        Sleep (0x64)
                        Notify (\_PR.CPU1, 0x80) // Performance Capability Change
                        Notify (\_PR.CPU1, 0x81) // C-State Change
                        Sleep (0x0A)
                    }
                }

                Scope (\_SB.PCI0)
                {
                    Device (BAT0)
                    {
                        Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */)  // _HID: Hardware ID
                        Name (_UID, 0x00)  // _UID: Unique ID
                        Name (_PCL, Package (0x01)  // _PCL: Power Consumer List
                        {
                            \_SB.PCI0
                        })
                        Method (_STA, 0, NotSerialized)  // _STA: Status
                        {
                            If (\_SB.PCI0.SBRG.EC0.BATP (0x00))
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x0F)
                            }
                        }

                        Name (LOW2, 0x012C)
                        Name (DVOT, 0x0E)
                        Name (PUNT, One)
                        Name (LFCC, 0x1770)
                        Name (NBIF, Package (0x0D)
                        {
                            0x00, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0x01, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            "", 
                            "", 
                            "", 
                            ""
                        })
                        Name (PBIF, Package (0x0D)
                        {
                            0x01, 
                            0x1770, 
                            0x1770, 
                            0x01, 
                            0x39D0, 
                            0x0258, 
                            0x012C, 
                            0x3C, 
                            0x3C, 
                            "M3N", 
                            " ", 
                            "LIon", 
                            "ASUSTek"
                        })
                        Name (PBST, Package (0x04)
                        {
                            0x00, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF, 
                            0xFFFFFFFF
                        })
                        Method (FBIF, 5, NotSerialized)
                        {
                            PUNT = Arg0
                            Local1 = Arg1
                            Local2 = Arg2
                            If ((PUNT == 0x00))
                            {
                                Local1 *= 0x0A
                                Local2 *= 0x0A
                            }

                            Index (PBIF, 0x00) = Arg0
                            Index (PBIF, 0x01) = Local1
                            Index (PBIF, 0x02) = Local2
                            LFCC = Local2
                            Index (PBIF, 0x03) = Arg3
                            Index (PBIF, 0x04) = Arg4
                            Divide (Local1, 0x0A, Local3, Local5)
                            Index (PBIF, 0x05) = Local5
                            Local6 = (Local5 >> 0x01)
                            Index (PBIF, 0x06) = Local6
                            LOW2 = Local6
                            Divide (Local1, 0x64, Local3, Local7)
                            Index (PBIF, 0x07) = Local7
                            Index (PBIF, 0x08) = Local7
                        }

                        Method (CBIF, 0, NotSerialized)
                        {
                            If (PUNT)
                            {
                                Local0 = DerefOf (Index (PBIF, 0x04))
                                Local0 += 0x01F4
                                Divide (Local0, 0x03E8, Local1, DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                                Index (PBIF, 0x00) = Zero
                                Index (PBIF, 0x01) = (DerefOf (Index (PBIF, 0x01)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                                Index (PBIF, 0x02) = (DerefOf (Index (PBIF, 0x02)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                                Index (PBIF, 0x05) = (DerefOf (Index (PBIF, 0x05)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                                Index (PBIF, 0x06) = (DerefOf (Index (PBIF, 0x06)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                                Index (PBIF, 0x07) = (DerefOf (Index (PBIF, 0x07)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                                Index (PBIF, 0x08) = (DerefOf (Index (PBIF, 0x08)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                            }
                        }

                        Method (_BIF, 0, NotSerialized)  // _BIF: Battery Information
                        {
                            If (!\_SB.PCI0.SBRG.EC0.BATP (0x00))
                            {
                                Return (NBIF) /* \_SB_.PCI0.BAT0.NBIF */
                            }

                            \_SB.PCI0.SBRG.EC0.BATS (0x00)
                            Index (PBIF, 0x09) = \MNAM
                            Index (PBIF, 0x0C) = \ONAM
                            Local0 = \_SB.PCI0.SBRG.EC0.BIF0 ()
                            Local1 = \_SB.PCI0.SBRG.EC0.BIF1 ()
                            Local2 = \_SB.PCI0.SBRG.EC0.BIF2 ()
                            Local3 = \_SB.PCI0.SBRG.EC0.BIF3 ()
                            Local4 = \_SB.PCI0.SBRG.EC0.BIF4 ()
                            \_SB.PCI0.SBRG.EC0.BATR ()
                            If ((Local0 != Ones))
                            {
                                If ((Local1 != Ones))
                                {
                                    If ((Local2 != Ones))
                                    {
                                        If ((Local3 != Ones))
                                        {
                                            If ((Local4 != Ones))
                                            {
                                                FBIF (Local0, Local1, Local2, Local3, Local4)
                                                CBIF ()
                                            }
                                        }
                                    }
                                }
                            }

                            If ((PUNT == 0x00))
                            {
                                Local2 *= 0x0A
                            }

                            LFCC = Local2
                            Return (PBIF) /* \_SB_.PCI0.BAT0.PBIF */
                        }

                        Method (FBST, 4, NotSerialized)
                        {
                            Local1 = (Arg1 & 0xFFFF)
                            If (\_SB.PCI0.SBRG.EC0.ACAP ())
                            {
                                If (((Local1 > 0xA0) && (Local1 < 0x8000)))
                                {
                                    Local0 = 0x02
                                }
                                Else
                                {
                                    If ((Local1 == 0x00))
                                    {
                                        Local2 = \_SB.PCI0.SBRG.EC0.RDC3 (0x02)
                                        If ((Local2 & 0x08))
                                        {
                                            Local0 = Zero
                                        }
                                        Else
                                        {
                                            Local0 = 0x02
                                        }
                                    }
                                    Else
                                    {
                                        Local0 = 0x01
                                    }
                                }
                            }
                            Else
                            {
                                Local0 = 0x01
                            }

                            Local2 = (Arg0 & 0x0300)
                            If (Local2)
                            {
                                Local2 = (One << 0x02)
                                Local0 |= Local2
                            }

                            If ((Local1 >= 0x8000))
                            {
                                Local1 -= 0xFFFF
                            }

                            Local2 = Arg2
                            If ((PUNT == 0x00))
                            {
                                Local1 *= DVOT /* \_SB_.PCI0.BAT0.DVOT */
                                Local2 *= 0x0A
                            }

                            Local3 = (Local0 & 0x02)
                            If (!Local3)
                            {
                                Local3 = (LFCC - Local2)
                                Divide (LFCC, 0xC8, Local4, Local5)
                                If ((Local3 < Local5))
                                {
                                    Local2 = LFCC /* \_SB_.PCI0.BAT0.LFCC */
                                }
                            }

                            If (!\_SB.PCI0.SBRG.EC0.ACAP ())
                            {
                                Divide (Local2, \MBLF, Local3, Local4)
                                If ((Local1 < Local4))
                                {
                                    Local1 = Local4
                                }
                            }

                            Index (PBST, 0x00) = Local0
                            Index (PBST, 0x01) = Local1
                            Index (PBST, 0x02) = Local2
                            Index (PBST, 0x03) = Arg3
                        }

                        Method (CBST, 0, NotSerialized)
                        {
                            If (PUNT)
                            {
                                Index (PBST, 0x01) = (DerefOf (Index (PBST, 0x01)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                                Index (PBST, 0x02) = (DerefOf (Index (PBST, 0x02)) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */
                            }

                            Local0 = (DerefOf (Index (PBIF, 0x02)) * 0x03E7)
                            Divide (Local0, 0x03E8, Local1, Local0)
                            If ((DerefOf (Index (PBST, 0x02)) >= Local0))
                            {
                                If (\_SB.PCI0.SBRG.EC0.ACAP ())
                                {
                                    Local2 = \_SB.PCI0.SBRG.EC0.RDC3 (0x02)
                                    If ((Local2 & 0x08))
                                    {
                                        Index (PBST, 0x02) = DerefOf (Index (PBIF, 0x02))
                                    }
                                    Else
                                    {
                                        Index (PBST, 0x02) = Local0
                                    }
                                }
                                Else
                                {
                                    Local2 = \_SB.PCI0.SBRG.EC0.BSTS ()
                                    If ((Local2 & 0x20))
                                    {
                                        Index (PBST, 0x02) = DerefOf (Index (PBIF, 0x02))
                                    }
                                    Else
                                    {
                                        Index (PBST, 0x02) = Local0
                                    }
                                }
                            }
                        }

                        Method (_BST, 0, NotSerialized)  // _BST: Battery Status
                        {
                            If (!\_SB.PCI0.SBRG.EC0.BATP (0x00))
                            {
                                Index (PBST, 0x00) = Zero
                                Index (PBST, 0x01) = Ones
                                Index (PBST, 0x02) = Ones
                                Index (PBST, 0x03) = Ones
                                Return (PBST) /* \_SB_.PCI0.BAT0.PBST */
                            }

                            If (\MES4)
                            {
                                \MES4--
                                Return (PBST) /* \_SB_.PCI0.BAT0.PBST */
                            }

                            \_SB.PCI0.SBRG.EC0.BATS (0x00)
                            Local0 = \_SB.PCI0.SBRG.EC0.BSTS ()
                            Local1 = \_SB.PCI0.SBRG.EC0.BCRT ()
                            Local2 = \_SB.PCI0.SBRG.EC0.BRCP ()
                            Local3 = \_SB.PCI0.SBRG.EC0.BVOT ()
                            \_SB.PCI0.SBRG.EC0.BATR ()
                            If ((Local0 != Ones))
                            {
                                If ((Local1 != Ones))
                                {
                                    If ((Local2 != Ones))
                                    {
                                        If ((Local3 != Ones))
                                        {
                                            FBST (Local0, Local1, Local2, Local3)
                                            CBST ()
                                        }
                                    }
                                }
                            }

                            Return (PBST) /* \_SB_.PCI0.BAT0.PBST */
                        }
                    }
                }

                Scope (\_SB.PCI0.SBRG.EC0)
                {
                    Method (_Q2F, 0, NotSerialized)  // _Qxx: EC Query
                    {
                        If (!DCPS (0x00))
                        {
                            \DCPF = Zero
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                P55S &= 0xEF
                                Release (MUEC)
                            }
                        }
                        Else
                        {
                            \DCPF = One
                            If ((Acquire (MUEC, 0xFFFF) == 0x00))
                            {
                                P55S |= 0x10
                                Release (MUEC)
                            }
                        }

                        Notify (\_SB.PCI0.BAT0, 0x01) // Device Check
                        Notify (\_SB.PCI0.BAT0, 0x81) // Information Change
                        Notify (\_SB.PCI0.AC0, 0x80) // Status Change
                    }

                    Method (_Q50, 0, NotSerialized)  // _Qxx: EC Query
                    {
                        If (\_SB.ATKP)
                        {
                            Notify (\_SB.ATKD, 0x6E) // Reserved
                        }
                        Else
                        {
                            If (BATP (0x00))
                            {
                                Notify (\_SB.PCI0.BAT0, 0x80) // Status Change
                            }
                        }
                    }

                    Method (NBAT, 1, NotSerialized)
                    {
                        If (BATP (0x00))
                        {
                            Notify (\_SB.PCI0.BAT0, Arg0)
                        }
                    }

                    Mutex (MMPX, 0x00)
                    Method (BATS, 1, Serialized)
                    {
                    }

                    Method (BATR, 0, Serialized)
                    {
                    }

                    Name (BADR, 0x0B)
                    Name (CADR, 0x09)
                    Name (SADR, 0x0A)
                    Method (ALMH, 1, NotSerialized)
                    {
                        If ((Arg0 == BADR))
                        {
                            NBAT (0x80)
                        }
                    }

                    Method (BIFW, 1, NotSerialized)
                    {
                        Local0 = SMBR (RDWD, BADR, Arg0)
                        Local1 = DerefOf (Index (Local0, 0x00))
                        If (Local1)
                        {
                            Return (Ones)
                        }
                        Else
                        {
                            Return (DerefOf (Index (Local0, 0x02)))
                        }
                    }

                    Method (BIF0, 0, NotSerialized)
                    {
                        Local1 = One
                        Local2 = One
                        While (((Local1 != 0x00) & (Local2 <= 0x03)))
                        {
                            Local0 = SMBR (RDWD, BADR, 0x03)
                            Local1 = DerefOf (Index (Local0, 0x00))
                            Local2++
                        }

                        If (Local1)
                        {
                            Return (Ones)
                        }
                        Else
                        {
                            Local2 = DerefOf (Index (Local0, 0x02))
                            Local2 >>= 0x0F
                            Local2 &= 0x01
                            Local2 ^= 0x01
                            Return (Local2)
                        }
                    }

                    Method (BIF1, 0, NotSerialized)
                    {
                        Local1 = Ones
                        Local0 = One
                        While (((Local1 == Ones) & (Local0 <= 0x03)))
                        {
                            Local1 = BIFW (0x18)
                            Local0++
                        }

                        Return (Local1)
                    }

                    Method (BIF2, 0, NotSerialized)
                    {
                        Local1 = Ones
                        Local0 = One
                        While (((Local1 == Ones) & (Local0 <= 0x03)))
                        {
                            Local1 = BIFW (0x10)
                            Local0++
                        }

                        Return (Local1)
                    }

                    Method (BIF3, 0, NotSerialized)
                    {
                        Local1 = Ones
                        Local0 = One
                        While (((Local1 == Ones) & (Local0 <= 0x03)))
                        {
                            Local1 = BIFW (0x03)
                            Local0++
                        }

                        If ((Local1 != Ones))
                        {
                            Local1 >>= 0x09
                            Local1 &= 0x01
                            Local1 ^= 0x01
                        }

                        Return (Local1)
                    }

                    Method (BIF4, 0, NotSerialized)
                    {
                        Local1 = Ones
                        Local0 = One
                        While (((Local1 == Ones) & (Local0 <= 0x03)))
                        {
                            Local1 = BIFW (0x19)
                            Local0++
                        }

                        Return (Local1)
                    }

                    Method (BIF9, 0, NotSerialized)
                    {
                        Name (BSTR, Buffer (0x20) {})
                        Local0 = SMBR (RDBL, BADR, 0x21)
                        If ((DerefOf (Index (Local0, 0x00)) != 0x00))
                        {
                            BSTR = \MNAM
                            Index (BSTR, 0x04) = 0x00
                        }
                        Else
                        {
                            BSTR = DerefOf (Index (Local0, 0x02))
                            Index (BSTR, DerefOf (Index (Local0, 0x01))) = 0x00
                        }

                        Return (BSTR) /* \_SB_.PCI0.SBRG.EC0_.BIF9.BSTR */
                    }

                    Method (BSTS, 0, NotSerialized)
                    {
                        Return (BIFW (0x16))
                    }

                    Method (BCRT, 0, NotSerialized)
                    {
                        Return (BIFW (0x0A))
                    }

                    Method (BRCP, 0, NotSerialized)
                    {
                        Return (BIFW (0x0F))
                    }

                    Method (BVOT, 0, NotSerialized)
                    {
                        Return (BIFW (0x09))
                    }
                }

                Scope (\_SB)
                {
                    Device (SLPB)
                    {
                        Name (_HID, EisaId ("PNP0C0E") /* Sleep Button Device */)  // _HID: Hardware ID
                        Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                        {
                            Return (Package (0x02)
                            {
                                0x0A, 
                                0x04
                            })
                        }
                    }
                }

                Scope (\_GPE)
                {
                    Method (_L0A, 0, NotSerialized)  // _Lxx: Level-Triggered GPE
                    {
                        Notify (\_SB.SLPB, 0x02) // Device Wake
                    }
                }

                Scope (\_SB)
                {
                    Device (LID)
                    {
                        Name (_HID, EisaId ("PNP0C0D") /* Lid Device */)  // _HID: Hardware ID
                        Method (_LID, 0, NotSerialized)  // _LID: Lid Status
                        {
                            Return (\LIDL)
                        }
                    }
                }

                Scope (\_GPE)
                {
                    Method (_L1B, 0, Serialized)  // _Lxx: Level-Triggered GPE
                    {
                        \LIDL ^= 0x01
                        Notify (\_SB.LID, 0x80) // Status Change
                    }
                }

                Scope (\)
                {
                    OperationRegion (SMB0, SystemIO, SMBS, 0x10)
                    Field (SMB0, ByteAcc, NoLock, Preserve)
                    {
                        HSTS,   8, 
                        SSTS,   8, 
                        HSTC,   8, 
                        HCMD,   8, 
                        HADR,   8, 
                        HDT0,   8, 
                        HDT1,   8, 
                        BLKD,   8, 
                        SLCT,   8, 
                        SHCM,   8, 
                        SLEV,   16, 
                        SLDT,   16, 
                        SCFG,   8, 
                        SADR,   8
                    }

                    Name (RBUF, Package (0x20) {})
                    Method (HBSY, 0, NotSerialized)
                    {
                        Local0 = 0x00FFFFFF
                        While (Local0)
                        {
                            Local1 = (HSTS & 0x01)
                            If (!Local1)
                            {
                                Return (Zero)
                            }

                            Local0--
                        }

                        Return (One)
                    }

                    Method (WTSB, 0, NotSerialized)
                    {
                        Local0 = 0x00FFFFFF
                        While (Local0)
                        {
                            Local0--
                            Local1 = (HSTS & 0x1E)
                            If ((Local1 == 0x02))
                            {
                                Return (One)
                            }

                            If (Local1)
                            {
                                Return (Zero)
                            }
                        }

                        Return (Zero)
                    }

                    Mutex (\P4SM, 0x00)
                    Method (SBYT, 2, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = Arg0
                                HCMD = Arg1
                                HSTS = 0xFF
                                HSTC = 0x44
                                If (WTSB ())
                                {
                                    Release (\P4SM)
                                    Return (One)
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }

                    Method (WBYT, 3, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = Arg0
                                HCMD = Arg1
                                HDT0 = Arg2
                                HSTS = 0xFF
                                HSTC = 0x48
                                If (WTSB ())
                                {
                                    Release (\P4SM)
                                    Return (One)
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }

                    Method (WWRD, 4, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = Arg0
                                HCMD = Arg1
                                Local1 = (Arg2 & 0xFF)
                                Local2 = (Arg2 >> 0x08)
                                Local2 &= 0xFF
                                HDT0 = Local2
                                HDT1 = Local1
                                HSTS = 0xFF
                                HSTC = 0x4C
                                If (WTSB ())
                                {
                                    Release (\P4SM)
                                    Return (One)
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }

                    Method (WBLK, 4, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = Arg0
                                HCMD = Arg1
                                Local1 = HSTC /* \HSTC */
                                Local2 = Arg2
                                Local1 = 0x00
                                While (Local2)
                                {
                                    BLKD = DerefOf (Index (Arg3, Local1))
                                    Local2--
                                    Local1++
                                }

                                HDT0 = Arg2
                                Local1 = HSTC /* \HSTC */
                                HSTS = 0xFF
                                HSTC = 0x54
                                If (WTSB ())
                                {
                                    Release (\P4SM)
                                    Return (One)
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }

                    Method (RSBT, 2, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = (Arg0 | 0x01)
                                HCMD = Arg1
                                HSTS = 0xFF
                                HSTC = 0x44
                                If (WTSB ())
                                {
                                    Release (\P4SM)
                                    Return (HDT0) /* \HDT0 */
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }

                    Method (RBYT, 2, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = (Arg0 | 0x01)
                                HCMD = Arg1
                                HSTS = 0xFF
                                HSTC = 0x48
                                If (WTSB ())
                                {
                                    Release (\P4SM)
                                    Return (HDT0) /* \HDT0 */
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }

                    Method (RWRD, 2, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = (Arg0 | 0x01)
                                HCMD = Arg1
                                HSTS = 0xFF
                                HSTC = 0x4C
                                If (WTSB ())
                                {
                                    Local1 = HDT0 /* \HDT0 */
                                    Local1 <<= 0x08
                                    Local2 = HDT1 /* \HDT1 */
                                    Local1 += Local2
                                    Release (\P4SM)
                                    Return (Local1)
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }

                    Method (RBLK, 3, Serialized)
                    {
                        If ((Acquire (\P4SM, 0xFFFF) != 0x00))
                        {
                            Return (Ones)
                        }

                        Local0 = 0x05
                        While (Local0)
                        {
                            If (HBSY ())
                            {
                                Local0--
                            }
                            Else
                            {
                                HADR = (Arg0 | 0x01)
                                HCMD = Arg1
                                HSTS = 0xFF
                                HSTC = 0x54
                                If (WTSB ())
                                {
                                    Local1 = HSTC /* \HSTC */
                                    Local2 = HDT0 /* \HDT0 */
                                    Local3 = Local2
                                    RBUF = 0x00
                                    Local1 = 0x00
                                    While (Local2)
                                    {
                                        Index (RBUF, Local1) = BLKD /* \BLKD */
                                        Local2--
                                        Local1++
                                    }

                                    Release (\P4SM)
                                    Return (Local3)
                                }
                                Else
                                {
                                    Local0--
                                }
                            }
                        }

                        Release (\P4SM)
                        Return (Ones)
                    }
                }

                Scope (\)
                {
                    Name (FAN1, 0x00)
                    Name (FAN2, 0x00)
                    Device (FN00)
                    {
                        Name (_HID, EisaId ("PNP0C0B") /* Fan (Thermal Solution) */)  // _HID: Hardware ID
                        Name (_PR0, Package (0x01)  // _PR0: Power Resources for D0
                        {
                            GFAN
                        })
                    }

                    PowerResource (GFAN, 0x00, 0x0000)
                    {
                        Method (_STA, 0, NotSerialized)  // _STA: Status
                        {
                            Return (FAN1) /* \FAN1 */
                        }

                        Method (_ON, 0, NotSerialized)  // _ON_: Power On
                        {
                            FAN1 = 0x01
                        }

                        Method (_OFF, 0, NotSerialized)  // _OFF: Power Off
                        {
                            FAN1 = 0x00
                        }
                    }

                    Name (\_SB.PCI0.SBRG._PR0, Package (0x01)  // _PR0: Power Resources for D0
                    {
                        GFAN
                    })
                    Method (FANW, 1, NotSerialized)
                    {
                        Noop
                    }

                    Method (FANS, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            \GFAN._OFF ()
                        }
                    }
                }

                Scope (\)
                {
                    Name (TSP, 0x0A)
                    Name (TC1, 0x02)
                    Name (TC2, 0x0A)
                }

                Scope (\_TZ)
                {
                    Method (KELV, 1, NotSerialized)
                    {
                        Local0 = (Arg0 & 0xFF)
                        If ((Local0 >= 0x80))
                        {
                            Local0 -= 0x0100
                            Local0 *= 0x0A
                            Local0 -= 0x0AAC
                            Return (Local0)
                        }

                        Local0 *= 0x0A
                        Local0 += 0x0AAC
                        Return (Local0)
                    }

                    Method (CELC, 1, NotSerialized)
                    {
                        Local0 = (Arg0 - 0x0AAC)
                        Divide (Local0, 0x0A, Local1, Local0)
                        Return (Local0)
                    }

                    Name (PLCY, 0x00)
                    ThermalZone (THRM)
                    {
                        Method (_CRT, 0, NotSerialized)  // _CRT: Critical Temperature
                        {
                            Return (KELV (TCRT))
                        }

                        Method (_TMP, 0, NotSerialized)  // _TMP: Temperature
                        {
                            Local1 = 0x05
                            While (Local1)
                            {
                                Local0 = RTMP ()
                                If ((Local0 > TCRT))
                                {
                                    Local1--
                                }
                                Else
                                {
                                    Local1 = 0x00
                                }
                            }

                            Return (KELV (Local0))
                        }

                        Name (_PSL, Package (0x01)  // _PSL: Passive List
                        {
                            \_PR.CPU1
                        })
                        Method (_TSP, 0, NotSerialized)  // _TSP: Thermal Sampling Period
                        {
                            Local0 = (TSP * 0x0A)
                            Return (Local0)
                        }

                        Method (_TC1, 0, NotSerialized)  // _TC1: Thermal Constant 1
                        {
                            Return (TC1) /* \TC1_ */
                        }

                        Method (_TC2, 0, NotSerialized)  // _TC2: Thermal Constant 2
                        {
                            Return (TC2) /* \TC2_ */
                        }

                        Method (_PSV, 0, NotSerialized)  // _PSV: Passive Temperature
                        {
                            If (PLCY)
                            {
                                Return (KELV (PPSV))
                            }
                            Else
                            {
                                Return (KELV (TPSV))
                            }
                        }

                        Name (_AL0, Package (0x01)  // _ALx: Active List
                        {
                            FN00
                        })
                        Method (_AC0, 0, NotSerialized)  // _ACx: Active Cooling
                        {
                            If (PLCY)
                            {
                                Return (KELV (PAC0))
                            }
                            Else
                            {
                                Return (KELV (TAC3))
                            }
                        }

                        Method (_SCP, 1, NotSerialized)  // _SCP: Set Cooling Policy
                        {
                            TCHG ()
                            Notify (THRM, 0x81) // Thermal Trip Point Change
                        }
                    }

                    Method (TRMS, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            \_TZ.TMSS (Arg0)
                        }
                    }

                    Method (TRMW, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            If ((Arg0 < 0x04))
                            {
                                \_TZ.TMSW (Arg0)
                                \_TZ.TCHG ()
                            }
                        }
                    }
                }

                Scope (\_GPE)
                {
                    Method (_L00, 0, Serialized)  // _Lxx: Level-Triggered GPE
                    {
                        \_TZ.TCHG ()
                        Notify (\_TZ.THRM, 0x80) // Thermal Status Change
                    }
                }

                Scope (\_TZ)
                {
                    Name (FON1, 0x76)
                    Name (FON2, 0xA0)
                    Name (LTMP, 0x3C)
                    Name (HLMT, 0x46)
                    Name (LLMT, 0x32)
                    Name (ELMT, 0x02)
                    Method (TMSW, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            If ((Arg0 < 0x04))
                            {
                                WBYT (TSAD, 0x0A, 0x00)
                                WBYT (TSAD, 0x0B, 0x7F)
                                WBYT (TSAD, 0x0C, 0xC9)
                                WBYT (TSAD, 0x19, 0x7F)
                                WBYT (TSAD, 0x20, 0x7F)
                                RBYT (TSAD, 0x02)
                                RBYT (TSAD, 0x02)
                            }
                        }
                    }

                    Method (TMSS, 1, NotSerialized)
                    {
                        If ((Arg0 <= 0x03))
                        {
                            WBYT (TSAD, 0x0D, 0x7F)
                            WBYT (TSAD, 0x0E, 0xC9)
                            RBYT (TSAD, 0x02)
                            RBYT (TSAD, 0x02)
                        }

                        If ((Arg0 == 0x01))
                        {
                            \_SB.PCI0.SBRG.EC0.FNCT (0x84, 0x00)
                        }
                    }

                    Method (TCHG, 0, NotSerialized)
                    {
                        WBYT (TSAD, 0x09, 0xA0)
                        RTMP ()
                        If ((LTMP >= 0x80))
                        {
                            LTMP = 0x00
                        }

                        If (PLCY)
                        {
                            Local0 = \_TZ.THRM._PSV ()
                            Local0 = CELC (Local0)
                            Local1 = \_TZ.THRM._AC0 ()
                            Local1 = CELC (Local1)
                            If ((LTMP > TCRT))
                            {
                                HLMT = 0x7F
                                LLMT = TCRT /* \TCRT */
                                FON1 = F1L4 /* \F1L4 */
                                FON2 = F2L4 /* \F2L4 */
                            }
                            Else
                            {
                                If ((LTMP > Local1))
                                {
                                    HLMT = TCRT /* \TCRT */
                                    LLMT = Local1
                                    FON1 = F1L4 /* \F1L4 */
                                    FON2 = F2L4 /* \F2L4 */
                                }
                                Else
                                {
                                    If ((LTMP > Local0))
                                    {
                                        HLMT = Local1
                                        LLMT = Local0
                                        FON1 = F1L0 /* \F1L0 */
                                        FON2 = F2L0 /* \F2L0 */
                                    }
                                    Else
                                    {
                                        HLMT = Local0
                                        LLMT = 0xC9
                                        FON1 = F1L0 /* \F1L0 */
                                        FON2 = F2L0 /* \F2L0 */
                                    }
                                }
                            }
                        }
                        Else
                        {
                            If ((LTMP > TCRT))
                            {
                                HLMT = 0x7F
                                LLMT = TCRT /* \TCRT */
                                FON1 = F1L4 /* \F1L4 */
                                FON2 = F2L4 /* \F2L4 */
                            }
                            Else
                            {
                                If ((LTMP > TPSV))
                                {
                                    HLMT = TCRT /* \TCRT */
                                    LLMT = TPSV /* \TPSV */
                                    FON1 = F1L4 /* \F1L4 */
                                    FON2 = F2L4 /* \F2L4 */
                                }
                                Else
                                {
                                    If ((LTMP > TAC0))
                                    {
                                        HLMT = TPSV /* \TPSV */
                                        LLMT = TAC0 /* \TAC0 */
                                        FON1 = F1L4 /* \F1L4 */
                                        FON2 = F2L4 /* \F2L4 */
                                    }
                                    Else
                                    {
                                        If ((LTMP > TAC1))
                                        {
                                            HLMT = TAC0 /* \TAC0 */
                                            LLMT = TAC1 /* \TAC1 */
                                            FON1 = F1L3 /* \F1L3 */
                                            FON2 = F2L3 /* \F2L3 */
                                        }
                                        Else
                                        {
                                            If ((LTMP > TAC2))
                                            {
                                                HLMT = TAC1 /* \TAC1 */
                                                LLMT = TAC2 /* \TAC2 */
                                                FON1 = F1L2 /* \F1L2 */
                                                FON2 = F2L2 /* \F2L2 */
                                            }
                                            Else
                                            {
                                                If ((LTMP > TAC3))
                                                {
                                                    HLMT = TAC2 /* \TAC2 */
                                                    LLMT = TAC3 /* \TAC3 */
                                                    FON1 = F1L1 /* \F1L1 */
                                                    FON2 = F2L1 /* \F2L1 */
                                                }
                                                Else
                                                {
                                                    HLMT = TAC3 /* \TAC3 */
                                                    LLMT = 0xC9
                                                    FON1 = F1L0 /* \F1L0 */
                                                    FON2 = F2L0 /* \F2L0 */
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Local1 = (HLMT + 0x01)
                        If ((Local1 > 0x7F))
                        {
                            Local1 = 0x7F
                        }

                        Local2 = LLMT /* \_TZ_.LLMT */
                        If ((LLMT < 0x80))
                        {
                            Local2 = (LLMT - 0x04)
                            If ((LTMP < TAC2))
                            {
                                If ((LTMP > TAC3))
                                {
                                    Local2 = (LLMT - 0x0A)
                                }
                            }
                        }

                        WBYT (TSAD, 0x0D, Local1)
                        WBYT (TSAD, 0x0E, Local2)
                        RBYT (TSAD, 0x02)
                        RBYT (TSAD, 0x02)
                        \_SB.PCI0.SBRG.EC0.FNCT (0x84, FON1)
                        WBYT (TSAD, 0x09, 0x20)
                    }

                    Method (RTMP, 0, NotSerialized)
                    {
                        Local0 = RBYT (TSAD, 0x01)
                        If (~Local0)
                        {
                            LTMP = Local0
                        }

                        Return (LTMP) /* \_TZ_.LTMP */
                    }

                    Method (RFAN, 0, NotSerialized)
                    {
                        If ((FON1 == F1L0))
                        {
                            Local0 = FNC0 /* \FNC0 */
                        }
                        Else
                        {
                            If ((FON1 == F1L1))
                            {
                                Local0 = FNC1 /* \FNC1 */
                            }
                            Else
                            {
                                If ((FON1 == F1L2))
                                {
                                    Local0 = FNC2 /* \FNC2 */
                                }
                                Else
                                {
                                    If ((FON1 == F1L3))
                                    {
                                        Local0 = FNC3 /* \FNC3 */
                                    }
                                    Else
                                    {
                                        If ((FON1 == F1L4))
                                        {
                                            Local0 = FNC4 /* \FNC4 */
                                        }
                                    }
                                }
                            }
                        }

                        Return (Local0)
                    }

                    Method (THDL, 0, NotSerialized)
                    {
                        TCHG ()
                    }
                }

                Scope (\_SB.PCI0)
                {
                    Device (VGA)
                    {
                        Name (_ADR, 0x00020000)  // _ADR: Address
                        Name (LCDM, 0x0808)
                        Name (CRTM, 0x0101)
                        Name (TVOM, 0x0202)
                        Name (DONE, Zero)
                        Name (DOSF, One)
                        Name (UPDN, One)
                        Name (NXTD, 0x01)
                        Method (MD2A, 1, NotSerialized)
                        {
                            Local0 = Zero
                            If ((Arg0 & LCDM))
                            {
                                Local0 |= 0x01
                            }

                            If ((Arg0 & CRTM))
                            {
                                Local0 |= 0x02
                            }

                            If ((Arg0 & TVOM))
                            {
                                Local0 |= 0x04
                            }

                            If (!Local0)
                            {
                                Return (NXTD) /* \_SB_.PCI0.VGA_.NXTD */
                            }

                            Return (Local0)
                        }

                        Method (MA2D, 1, NotSerialized)
                        {
                            Local0 = Zero
                            If ((Arg0 & 0x01))
                            {
                                Local0 |= LCDM /* \_SB_.PCI0.VGA_.LCDM */
                            }

                            If ((Arg0 & 0x02))
                            {
                                Local0 |= CRTM /* \_SB_.PCI0.VGA_.CRTM */
                            }

                            If ((Arg0 & 0x04))
                            {
                                Local0 |= TVOM /* \_SB_.PCI0.VGA_.TVOM */
                            }

                            If (!Local0)
                            {
                                Return (LCDM) /* \_SB_.PCI0.VGA_.LCDM */
                            }

                            Return (Local0)
                        }

                        Method (_INI, 0, NotSerialized)  // _INI: Initialize
                        {
                            GCAD ()
                            \PADL = \CADL
                            GCDD ()
                            GNDD ()
                        }

                        Method (_DOS, 1, NotSerialized)  // _DOS: Disable Output Switching
                        {
                            DOSF = Arg0
                        }

                        Method (_DOD, 0, NotSerialized)  // _DOD: Display Output Devices
                        {
                            Return (Package (0x02)
                            {
                                0x00010100, 
                                0x00010400
                            })
                        }

                        Device (CRTD)
                        {
                            Name (_ADR, 0x0100)  // _ADR: Address
                            Method (_DCS, 0, NotSerialized)  // _DCS: Display Current Status
                            {
                                If ((\CSTE & CRTM))
                                {
                                    Return (0x1F)
                                }

                                Return (0x1D)
                            }

                            Method (_DGS, 0, NotSerialized)  // _DGS: Display Graphics State
                            {
                                If ((\NSTE & CRTM))
                                {
                                    Return (0x01)
                                }

                                Return (0x00)
                            }

                            Method (_DSS, 1, NotSerialized)  // _DSS: Device Set State
                            {
                                If ((Arg0 & 0x40000000))
                                {
                                    If ((Arg0 & 0x80000000))
                                    {
                                        \CSTE = \NSTE
                                        DONE = One
                                    }
                                }
                            }
                        }

                        Device (LCDD)
                        {
                            Name (_ADR, 0x0400)  // _ADR: Address
                            Method (_DCS, 0, NotSerialized)  // _DCS: Display Current Status
                            {
                                If ((\CSTE & LCDM))
                                {
                                    Return (0x1F)
                                }

                                Return (0x1D)
                            }

                            Method (_DGS, 0, NotSerialized)  // _DGS: Display Graphics State
                            {
                                If ((\NSTE & LCDM))
                                {
                                    Return (0x01)
                                }

                                Return (0x00)
                            }

                            Method (_DSS, 1, NotSerialized)  // _DSS: Device Set State
                            {
                                If ((Arg0 & 0x40000000))
                                {
                                    If ((Arg0 & 0x80000000))
                                    {
                                        \CSTE = \NSTE
                                        DONE = One
                                    }
                                }
                            }
                        }

                        Method (SWHD, 1, Serialized)
                        {
                            UPDN = One
                            If (DOSF)
                            {
                                If (\NATK ())
                                {
                                    \SFUN = 0x00
                                }
                                Else
                                {
                                    \SFUN = 0x04
                                }

                                \SSTE = Arg0
                                If (\NATK ())
                                {
                                    \NSTE = MA2D (Arg0)
                                    \SSTE = \NSTE
                                }

                                ISMI (\STDD)
                                Notify (\_SB.PCI0.VGA, 0x81) // Information Change
                            }
                            Else
                            {
                                If ((\CADL != \PADL))
                                {
                                    \PADL = \CADL
                                    If ((OSFG == OSXP))
                                    {
                                        Notify (\_SB.PCI0, 0x00) // Bus Check
                                    }
                                    Else
                                    {
                                        Notify (\_SB.PCI0.VGA, 0x00) // Bus Check
                                    }

                                    Sleep (0x03E8)
                                }

                                Notify (\_SB.PCI0.VGA, 0x80) // Status Change
                            }
                        }

                        Method (GCDD, 0, NotSerialized)
                        {
                            \SFUN = 0x01
                            ISMI (\GTDD)
                            Return (\CSTE)
                        }

                        Method (GNDD, 0, NotSerialized)
                        {
                            \SFUN = 0x05
                            ISMI (\GTDD)
                            Return (\NSTE)
                        }

                        Method (GCAD, 0, NotSerialized)
                        {
                            \SFUN = 0x02
                            ISMI (\GTDD)
                            Return (\CADL)
                        }

                        Method (ADVD, 0, NotSerialized)
                        {
                            GCDD ()
                            GCAD ()
                            If (NATK ())
                            {
                                If (UPDN)
                                {
                                    NXTD = MD2A (\CSTE)
                                    UPDN = Zero
                                }

                                Local0 = Zero
                                Local1 = MD2A (\CADL)
                                While ((NXTD != Local0))
                                {
                                    NXTD++
                                    If ((NXTD > 0x03))
                                    {
                                        NXTD = One
                                    }

                                    Local0 = (NXTD & Local1)
                                }

                                \NSTE = MA2D (NXTD)
                                Return (NXTD) /* \_SB_.PCI0.VGA_.NXTD */
                            }

                            Return (GNDD ())
                        }
                    }
                }

                Scope (\)
                {
                    Method (ADVG, 0, NotSerialized)
                    {
                        Return (\_SB.PCI0.VGA.ADVD ())
                    }

                    Method (SWHG, 1, Serialized)
                    {
                        \_SB.PCI0.VGA.DONE = Zero
                        \_SB.PCI0.VGA.SWHD (Arg0)
                        If (!\_SB.PCI0.VGA.DOSF)
                        {
                            Local0 = 0x01F4
                            While (Local0)
                            {
                                If (\_SB.PCI0.VGA.DONE)
                                {
                                    Local0 = Zero
                                }
                                Else
                                {
                                    Sleep (0x0A)
                                    Local0--
                                }
                            }
                        }
                    }

                    Method (NATK, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Scope (\_SB)
                {
                    Name (ATKP, Zero)
                    Device (ATKD)
                    {
                        Name (_HID, "ATK0100")  // _HID: Hardware ID
                        Name (_UID, 0x01010100)  // _UID: Unique ID
                        Method (INIT, 1, NotSerialized)
                        {
                            ATKP = One
                            Return (\MNAM)
                        }

                        Method (BSTS, 0, NotSerialized)
                        {
                            Local0 = \IKFG
                            If (\_SB.PCI0.SBRG.EC0.ACAP ())
                            {
                                Local0 &= 0x7F
                            }

                            Return (Local0)
                        }

                        Method (MLED, 1, NotSerialized)
                        {
                            If (Arg0)
                            {
                                Local0 = 0x31
                            }
                            Else
                            {
                                Local0 = 0x51
                            }

                            \_SB.PCI0.SBRG.EC0.STC5 (Local0)
                        }

                        Method (TMPR, 0, NotSerialized)
                        {
                            Local0 = \_TZ.RTMP ()
                            Local1 = \_TZ.RFAN ()
                            Local1 <<= 0x10
                            Local0 = (\_TZ.KELV (Local0) + Local1)
                            Local2 = Zero
                            If (\TENA)
                            {
                                Local2 = \TDTY
                            }
                            Else
                            {
                                If (\THLS)
                                {
                                    Local2 = \TTDT
                                }
                            }

                            Local2 <<= 0x18
                            Local0 += Local2
                            Return (Local0)
                        }

                        Method (SFUN, 0, NotSerialized)
                        {
                            Local0 = 0x37
                            Local0 |= 0x0240
                            If ((\_SB.PCI0.P0P1.MPCI.MPDP () == 0x01))
                            {
                                Local0 |= 0x0100
                            }

                            If ((\_SB.PCI0.P0P1.MPCI.MPDP () > 0x01))
                            {
                                Local0 |= 0x0800
                            }

                            Return (Local0)
                        }

                        Name (FMST, Package (0x04)
                        {
                            Package (0x04)
                            {
                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x55, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0x64, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0x69, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0x6E, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0x73, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x71, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0x85, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0x8C, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0x93, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0x99, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x8D, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0xA6, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0xAF, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xB7, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0xBF, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0xAA, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0xC8, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0xD2, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xDC, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0xE6, 
                                        0x07
                                    }
                                }
                            }, 

                            Package (0x04)
                            {
                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x5A, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0x64, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0x6E, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0x78, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0x82, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x78, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0x85, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0x93, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xA0, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0xAD, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x96, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0xA6, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0xB7, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xC7, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0xD9, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0xB4, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0xC8, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0xDC, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xF0, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0x0104, 
                                        0x07
                                    }
                                }
                            }, 

                            Package (0x04)
                            {
                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x5A, 
                                        0x00
                                    }, 

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

                                    Package (0x02)
                                    {
                                        0x69, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0x6E, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0x73, 
                                        0x04
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x78, 
                                        0x00
                                    }, 

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

                                    Package (0x02)
                                    {
                                        0x8C, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0x93, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0x99, 
                                        0x04
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x96, 
                                        0x00
                                    }, 

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

                                    Package (0x02)
                                    {
                                        0xAF, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0xB7, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0xBF, 
                                        0x04
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0xB4, 
                                        0x00
                                    }, 

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

                                    Package (0x02)
                                    {
                                        0xD2, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0xDC, 
                                        0x03
                                    }, 

                                    Package (0x02)
                                    {
                                        0xE6, 
                                        0x04
                                    }
                                }
                            }, 

                            Package (0x04)
                            {
                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x5A, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0x64, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0x78, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0x7D, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0x82, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x78, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0x85, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0xA0, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xA7, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0xAD, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0x96, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0xA6, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0xC8, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xD0, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0xD9, 
                                        0x07
                                    }
                                }, 

                                Package (0x05)
                                {
                                    Package (0x02)
                                    {
                                        0xB4, 
                                        0x02
                                    }, 

                                    Package (0x02)
                                    {
                                        0xC8, 
                                        0x04
                                    }, 

                                    Package (0x02)
                                    {
                                        0xF0, 
                                        0x05
                                    }, 

                                    Package (0x02)
                                    {
                                        0xFA, 
                                        0x06
                                    }, 

                                    Package (0x02)
                                    {
                                        0x0104, 
                                        0x07
                                    }
                                }
                            }
                        })
                        Method (GFRQ, 1, NotSerialized)
                        {
                            If ((\OVCK == 0x00))
                            {
                                If ((Arg0 != 0x01))
                                {
                                    Return (0x00)
                                }
                            }

                            Local0 = DerefOf (Index (FMST, \FS56))
                            Local1 = DerefOf (Index (Local0, \CPUF))
                            Local5 = Arg0
                            If ((Local5 == 0x02))
                            {
                                If (\OVCK)
                                {
                                    Local6 = (\OVCK - 0x01)
                                    Local5 += Local6
                                }
                            }

                            Local2 = DerefOf (Index (Local1, Local5))
                            Local3 = DerefOf (Index (Local2, 0x00))
                            Local4 = (Local3 * \CPUR)
                            Return (Local4)
                        }

                        Method (SFRQ, 1, NotSerialized)
                        {
                            Local0 = DerefOf (Index (FMST, \FS56))
                            Local1 = DerefOf (Index (Local0, \CPUF))
                            Local5 = Arg0
                            If ((Local5 == 0x02))
                            {
                                If (\OVCK)
                                {
                                    Local6 = (\OVCK - 0x01)
                                    Local5 += Local6
                                }
                            }

                            Local2 = DerefOf (Index (Local1, Local5))
                            Local3 = DerefOf (Index (Local2, 0x01))
                            \FS02 = Local3
                            Return (One)
                        }

                        Method (WDEV, 0, NotSerialized)
                        {
                            Return (\_SB.PCI0.P0P1.MPCI.MPDP ())
                        }

                        Method (OSVR, 1, NotSerialized)
                        {
                            \OSFG = Arg0
                        }

                        Method (GPLV, 0, NotSerialized)
                        {
                            Return (\LBTN)
                        }

                        Method (SPLV, 1, NotSerialized)
                        {
                            \LBTN = Arg0
                            \_SB.PCI0.SBRG.EC0.STBR ()
                        }

                        Method (WLED, 1, NotSerialized)
                        {
                            If ((Arg0 == One))
                            {
                                \WLDC = Zero
                            }
                            Else
                            {
                                \WLDC = One
                            }
                        }

                        Method (SDSP, 1, NotSerialized)
                        {
                            If (\NATK ())
                            {
                                \SWHG (Arg0)
                            }
                        }

                        Method (GPID, 0, NotSerialized)
                        {
                            Local0 = \PID0
                            Local0 &= 0x03
                            Local1 = \PID2
                            Local1 &= 0x03
                            Local1 <<= 0x02
                            Local1 |= Local0
                            If ((Local1 == 0x0B))
                            {
                                Local0 = 0x05
                            }
                            Else
                            {
                                Local0 = 0x03
                            }

                            Return (Local0)
                        }
                    }
                }

                Scope (\)
                {
                    Name (PMEW, Zero)
                    Name (MES4, Zero)
                    Method (OEMS, 1, NotSerialized)
                    {
                        If ((Arg0 == 0x03))
                        {
                            \S3RM = One
                            If ((\OSFG <= \OSME))
                            {
                                \WIDE = One
                            }
                            Else
                            {
                                \WIDE = Zero
                            }
                        }

                        \_SB.PCI0.USB1.USBS (Arg0)
                        \_SB.PCI0.USB2.USBS (Arg0)
                        \_SB.PCI0.USB3.USBS (Arg0)
                        \_SB.PCI0.SBRG.EC0.EC0S (Arg0)
                        \SLPT = Arg0
                        \SLPS = One
                        \SLPE = One
                        If ((Arg0 == 0x04))
                        {
                            If ((OSFG == OSXP))
                            {
                                \TTMR = 0x20
                                \TRLD = 0x20
                                \THLT = 0x00
                            }

                            If ((OSFG == OS2K))
                            {
                                S42K = Arg0
                            }
                        }

                        If ((Arg0 == 0x03))
                        {
                            \CBSP = Zero
                        }

                        \WLDC = 0x01
                        \WLAN = 0x01
                        DBG8 = (Arg0 + 0xD0)
                        If (Arg0)
                        {
                            \SLPT = Arg0
                            \SLPS = One
                            \SLPE = One
                        }
                    }

                    Method (OEMW, 1, NotSerialized)
                    {
                        \_SB.PCI0.SBRG.EC0.EC0W (Arg0)
                        \_SB.PCI0.SBRG.C4C3 ()
                        If ((Arg0 == 0x03))
                        {
                            \CBSP = One
                        }

                        If ((Arg0 == 0x04))
                        {
                            If ((\OSFG <= \OSME))
                            {
                                MES4 = 0x02
                            }
                            Else
                            {
                                MES4 = Zero
                            }
                        }

                        \SLPE = Zero
                        \SLPS = One
                        \SLPT = Zero
                        \_SB.PCI0.P0P1.CBS0.CBSW (Arg0)
                        \PMEW = \SBPS
                        \_SB.PCI0.USB1.USBW (Arg0)
                        \_SB.PCI0.USB2.USBW (Arg0)
                        \_SB.PCI0.USB3.USBW (Arg0)
                        If ((Arg0 == 0x04))
                        {
                            Notify (\_SB.SLPB, 0x02) // Device Wake
                        }

                        \WLAN = Zero
                        DBG8 = (Arg0 + 0xF0)
                    }
                }

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

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

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

                    Method (_L0D, 0, Serialized)  // _Lxx: Level-Triggered GPE
                    {
                        Notify (\_SB.PCI0.EHCI, 0x02) // Device Wake
                        Notify (\_SB.SLPB, 0x02) // Device Wake
                    }

                    Method (_L05, 0, Serialized)  // _Lxx: Level-Triggered GPE
                    {
                        Notify (\_SB.PCI0.MODM, 0x02) // Device Wake
                        Notify (\_SB.SLPB, 0x02) // Device Wake
                    }

                    Method (_L0B, 0, Serialized)  // _Lxx: Level-Triggered GPE
                    {
                        If (\PMEW)
                        {
                            Notify (\_SB.PCI0.P0P1, 0x02) // Device Wake
                            Notify (\_SB.SLPB, 0x02) // Device Wake
                            \PMEW = Zero
                        }
                        Else
                        {
                            If (\_SB.PCI0.P0P1.CBS0.CBSR ())
                            {
                                Notify (\_SB.PCI0.P0P1.CBS0, 0x02) // Device Wake
                            }
                        }
                    }
                }

                Scope (\_SB.ATKD)
                {
                    Method (FSMI, 1, NotSerialized)
                    {
                        \FSFN = Arg0
                        Local0 = (Arg0 | 0xA0)
                        \DBG8 = Local0
                        ISMI (\WFAT)
                        Return (\FSTA)
                    }

                    Method (FLSH, 1, NotSerialized)
                    {
                        \FSTA = Arg0
                        FSMI (0x00)
                    }

                    Method (FINI, 1, NotSerialized)
                    {
                        \FADR = Arg0
                        Return (FSMI (0x01))
                    }

                    Method (FERS, 1, NotSerialized)
                    {
                        \FSTA = Arg0
                        Return (FSMI (0x02))
                    }

                    Method (FWRI, 1, NotSerialized)
                    {
                        \FADR = Arg0
                        \FSIZ = 0x1000
                        Return ((0x1000 - FSMI (0x03)))
                    }

                    Method (FWRP, 0, NotSerialized)
                    {
                        \FSIZ = 0x00
                        Return ((0x1000 - FSMI (0x03)))
                    }

                    Method (FEBW, 1, NotSerialized)
                    {
                        \FADR = Arg0
                        Return (FSMI (0x04))
                    }

                    Method (FEBR, 1, NotSerialized)
                    {
                        \FADR = Arg0
                        Return (FSMI (0x05))
                    }

                    Method (FEDW, 0, NotSerialized)
                    {
                        Return (FSMI (0x06))
                    }
                }

                Device (UAR2)
                {
                    Name (_UID, 0x02)  // _UID: Unique ID
                    Method (_HID, 0, NotSerialized)  // _HID: Hardware ID
                    {
                        Return (UHID (0x01))
                    }

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

                    Method (_DIS, 0, NotSerialized)  // _DIS: Disable Device
                    {
                        If ((\OSFG > \OSME))
                        {
                            DCNT (0x01, 0x00)
                        }
                    }

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

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

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

                    Name (CMPR, ResourceTemplate ()
                    {
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                        }
                        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 ()
                    {
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {3,4,5,6,7,10,11,12}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03BC,             // Range Minimum
                                0x03BC,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {}
                        }
                        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}
                        }
                        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 ()
                                {}
                            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 ()
                                {}
                            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 ()
                                {}
                            DMA (Compatibility, NotBusMaster, Transfer8, )
                                {0,1,2,3}
                        }
                        EndDependentFn ()
                    })
                }

                Device (FWH)
                {
                    Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */)  // _HID: Hardware ID
                    Name (_UID, 0x02)  // _UID: Unique ID
                    Name (CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y13)
                        Memory32Fixed (ReadOnly,
                            0x00000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y14)
                    })
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y13._BAS, BS00)  // _BAS: Base Address
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y13._LEN, BL00)  // _LEN: Length
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y14._BAS, BS10)  // _BAS: Base Address
                    CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y14._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
                            _Y15)
                    })
                    Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
                    {
                        CreateDWordField (CRS, \_SB.PCI0.SBRG.FWHE._Y15._BAS, BS00)  // _BAS: Base Address
                        CreateDWordField (CRS, \_SB.PCI0.SBRG.FWHE._Y15._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, 0xE3, 0x01)
                Field (FHR0, ByteAcc, NoLock, Preserve)
                {
                    FHD0,   8
                }
            }

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

                OperationRegion (BAR0, PCI_Config, 0x00, 0x0100)
                Field (BAR0, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x40), 
                    TIMP,   16, 
                    TIMS,   16, 
                    STMP,   4, 
                    STMS,   4, 
                    Offset (0x48), 
                    UDMP,   2, 
                    UDMS,   2, 
                    Offset (0x4A), 
                    UDTP,   6, 
                    Offset (0x4B), 
                    UDTS,   6, 
                    Offset (0x54), 
                    PCB0,   2, 
                    SCB0,   2, 
                    PCA0,   2, 
                    SCA0,   2, 
                        ,   4, 
                    FPB0,   2, 
                    FSB0,   2, 
                    PSIG,   2, 
                    SSIG,   2
                }

                Name (TIM0, Package (0x09)
                {
                    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, 
                        0x0F
                    }, 

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

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

                    Package (0x06)
                    {
                        0x00, 
                        0x00, 
                        0x00, 
                        0x00, 
                        0x00, 
                        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)
                Name (GTIM, 0x00)
                Name (GSTM, 0x00)
                Name (GUDM, 0x00)
                Name (GUDT, 0x00)
                Name (GCB0, 0x00)
                Name (GFB0, 0x00)
                Device (CHN0)
                {
                    Name (_ADR, 0x00)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Return (GTM (TIMP, STMP, UDMP, UDTP, PCB0, FPB0))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        Debug = Arg0
                        TMD0 = Arg0
                        GTIM = TIMP /* \_SB_.PCI0.IDE0.TIMP */
                        GUDT = UDTP /* \_SB_.PCI0.IDE0.UDTP */
                        If (STM ())
                        {
                            TIMP = GTIM /* \_SB_.PCI0.IDE0.GTIM */
                            STMP = GSTM /* \_SB_.PCI0.IDE0.GSTM */
                            UDMP = GUDM /* \_SB_.PCI0.IDE0.GUDM */
                            UDTP = GUDT /* \_SB_.PCI0.IDE0.GUDT */
                            PCB0 = GCB0 /* \_SB_.PCI0.IDE0.GCB0 */
                            FPB0 = GFB0 /* \_SB_.PCI0.IDE0.GFB0 */
                        }

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

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

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

                Device (CHN1)
                {
                    Name (_ADR, 0x01)  // _ADR: Address
                    Method (_GTM, 0, NotSerialized)  // _GTM: Get Timing Mode
                    {
                        Return (GTM (TIMS, STMS, UDMS, UDTS, SCB0, FSB0))
                    }

                    Method (_STM, 3, NotSerialized)  // _STM: Set Timing Mode
                    {
                        Debug = Arg0
                        TMD0 = Arg0
                        GTIM = TIMS /* \_SB_.PCI0.IDE0.TIMS */
                        GUDT = UDTS /* \_SB_.PCI0.IDE0.UDTS */
                        If (STM ())
                        {
                            TIMS = GTIM /* \_SB_.PCI0.IDE0.GTIM */
                            STMS = GSTM /* \_SB_.PCI0.IDE0.GSTM */
                            UDMS = GUDM /* \_SB_.PCI0.IDE0.GUDM */
                            UDTS = GUDT /* \_SB_.PCI0.IDE0.GUDT */
                            SCB0 = GCB0 /* \_SB_.PCI0.IDE0.GCB0 */
                            FSB0 = GFB0 /* \_SB_.PCI0.IDE0.GFB0 */
                        }

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

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

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

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

                    If ((Arg0 & 0x02))
                    {
                        CHNF |= 0x02
                    }

                    Local5 = ((Arg0 & 0x3300) >> 0x08)
                    Local6 = Match (DerefOf (Index (TIM0, 0x01)), MLE, Local5, MTR, 0x00, 
                        0x00)
                    Local7 = DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local6))
                    DMA0 = Local7
                    If ((Arg0 & 0x08))
                    {
                        PIO0 = 0x0384
                    }
                    Else
                    {
                        PIO0 = Local7
                    }

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

                    If ((Arg0 & 0x4000))
                    {
                        CHNF |= 0x10
                        Local5 = Match (DerefOf (Index (TIM0, 0x02)), MLE, Arg1, MTR, 0x00, 
                            0x00)
                        Local6 = DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local5))
                        DMA1 = Local6
                        If ((Arg0 & 0x80))
                        {
                            PIO1 = 0x0384
                        }
                        Else
                        {
                            PIO1 = Local6
                        }
                    }

                    If ((Arg2 & 0x01))
                    {
                        Local5 = (Arg3 & 0x03)
                        If (((Arg5 & 0x01) && (Local5 == 0x01)))
                        {
                            Local5 += 0x04
                        }
                        Else
                        {
                            If ((Arg4 & 0x01))
                            {
                                Local5 += 0x02
                            }
                        }

                        DMA0 = DerefOf (Index (DerefOf (Index (TIM0, 0x03)), Local5))
                        CHNF |= 0x01
                    }

                    If ((Arg2 & 0x02))
                    {
                        Local5 = ((Arg3 >> 0x04) & 0x03)
                        If (((Arg5 & 0x02) && (Local5 == 0x01)))
                        {
                            Local5 += 0x04
                        }
                        Else
                        {
                            If ((Arg4 & 0x02))
                            {
                                Local5 += 0x02
                            }
                        }

                        DMA1 = DerefOf (Index (DerefOf (Index (TIM0, 0x03)), Local5))
                        CHNF |= 0x04
                    }

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

                Method (STM, 0, Serialized)
                {
                    If (REGF) {}
                    Else
                    {
                        Return (0x00)
                    }

                    GTIM &= 0x8044
                    GSTM = 0x00
                    GUDM = 0x00
                    GCB0 = 0x00
                    GUDT &= 0xCC
                    GFB0 = 0x00
                    If ((CHNF & 0x01))
                    {
                        Local0 = Match (DerefOf (Index (TIM0, 0x03)), MLE, DMA0, MTR, 0x00, 
                            0x00)
                        If ((Local0 > 0x05))
                        {
                            Local0 = 0x05
                        }

                        GUDT |= DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local0))
                        GCB0 |= DerefOf (Index (DerefOf (Index (TIM0, 0x05)), Local0))
                        GFB0 |= DerefOf (Index (DerefOf (Index (TIM0, 0x06)), Local0))
                        GUDM |= 0x01
                    }
                    Else
                    {
                        If (((PIO0 == Ones) | (PIO0 == 0x00)))
                        {
                            If (((DMA0 < Ones) & (DMA0 > 0x00)))
                            {
                                PIO0 = DMA0 /* \_SB_.PCI0.IDE0.DMA0 */
                                GTIM |= 0x08
                            }
                        }
                    }

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

                        GUDT |= (DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local0)) << 
                            0x04)
                        GCB0 |= (DerefOf (Index (DerefOf (Index (TIM0, 0x05)), Local0)) << 
                            0x01)
                        GFB0 |= (DerefOf (Index (DerefOf (Index (TIM0, 0x06)), Local0)) << 
                            0x01)
                        GUDM |= 0x02
                    }
                    Else
                    {
                        If (((PIO1 == Ones) | (PIO1 == 0x00)))
                        {
                            If (((DMA1 < Ones) & (DMA1 > 0x00)))
                            {
                                PIO1 = DMA1 /* \_SB_.PCI0.IDE0.DMA1 */
                                GTIM |= 0x80
                            }
                        }
                    }

                    If ((CHNF & 0x02))
                    {
                        GTIM |= 0x03
                    }

                    If ((CHNF & 0x08))
                    {
                        GTIM |= 0x30
                    }

                    Local0 = (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIO0, MTR, 0x00, 
                        0x00) & 0x03)
                    Local1 = DerefOf (Index (DerefOf (Index (TIM0, 0x01)), Local0))
                    Local2 = (Local1 << 0x08)
                    GTIM |= Local2
                    If ((CHNF & 0x10))
                    {
                        GTIM |= 0x4000
                        Local0 = (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIO1, MTR, 0x00, 
                            0x00) & 0x03)
                        GSTM = DerefOf (Index (DerefOf (Index (TIM0, 0x02)), Local0))
                    }

                    Return (0x01)
                }

                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 (Index (TIM0, 0x03)), MLE, DMAT, MTR, 0x00, 
                            0x00)
                        If ((Local1 > 0x05))
                        {
                            Local1 = 0x05
                        }

                        GTFB (AT01, (0x40 | Local1), Local7)
                    }
                    Else
                    {
                        If (((ID63 & 0xFF00) && PIOT))
                        {
                            Local0 = (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIOT, MTR, 0x00, 
                                0x00) & 0x03)
                            Local1 = (0x20 | DerefOf (Index (DerefOf (Index (TIM0, 0x08)), Local0)))
                            GTFB (AT01, Local1, Local7)
                        }
                    }

                    If (IRDY)
                    {
                        Local0 = (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIOT, MTR, 0x00, 
                            0x00) & 0x03)
                        Local1 = (0x08 | DerefOf (Index (DerefOf (Index (TIM0, 0x07)), Local0)))
                        GTFB (AT01, Local1, Local7)
                    }
                    Else
                    {
                        If ((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 (SMBC)
            {
                Name (_ADR, 0x001F0003)  // _ADR: Address
            }

            Device (MODM)
            {
                Name (_ADR, 0x001F0006)  // _ADR: Address
                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x05, 0x03))
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)  // _ADR: Address
                OperationRegion (BAR0, PCI_Config, 0xC0, 0x05)
                Field (BAR0, ByteAcc, NoLock, Preserve)
                {
                    UBL1,   16, 
                    Offset (0x04), 
                    P0WE,   1, 
                    P1WE,   1, 
                    Offset (0x05)
                }

                Method (_PSW, 1, NotSerialized)  // _PSW: Power State Wake
                {
                    If (Arg0)
                    {
                        P0WE = 0x01
                        P1WE = 0x01
                    }
                    Else
                    {
                        P0WE = 0x00
                        P1WE = 0x00
                    }
                }

                Method (UPAC, 1, NotSerialized)
                {
                    Local0 = Zero
                    If ((OSFG == OS9X))
                    {
                        Local0 = One
                    }
                    Else
                    {
                        If ((OSFG == OS98))
                        {
                            Local0 = One
                        }
                    }

                    If (Local0)
                    {
                        If ((Arg0 == 0x03))
                        {
                            Return (One)
                        }
                    }

                    Return (Zero)
                }

                OperationRegion (UPCI, PCI_Config, 0x20, 0x04)
                Field (UPCI, ByteAcc, NoLock, Preserve)
                {
                    UBAS,   32
                }

                Name (BASA, 0xB400)
                Name (P0ST, Zero)
                Name (P1ST, Zero)
                Method (SSTA, 0, NotSerialized)
                {
                    BASA = UBAS /* \_SB_.PCI0.USB1.UBAS */
                    BASA &= 0xFFFFFFFE
                    OperationRegion (UHCI, SystemIO, BASA, 0x20)
                    Field (UHCI, ByteAcc, NoLock, Preserve)
                    {
                        RSTP,   1, 
                        HRST,   1, 
                        GRST,   1, 
                        Offset (0x10), 
                        CCS0,   1, 
                        CSC0,   1, 
                        PED0,   1, 
                        Offset (0x12), 
                        CCS1,   1, 
                        CSC1,   1, 
                        PED1,   1
                    }

                    P0ST = CCS0 /* \_SB_.PCI0.USB1.SSTA.CCS0 */
                    P1ST = CCS1 /* \_SB_.PCI0.USB1.SSTA.CCS1 */
                }

                Method (RSTA, 0, NotSerialized)
                {
                    UBAS = BASA /* \_SB_.PCI0.USB1.BASA */
                    OperationRegion (UHCI, SystemIO, BASA, 0x20)
                    Field (UHCI, ByteAcc, NoLock, Preserve)
                    {
                        RSTP,   1, 
                        HRST,   1, 
                        GRST,   1, 
                        Offset (0x10), 
                        CCS0,   1, 
                        CSC0,   1, 
                        PED0,   1, 
                        Offset (0x12), 
                        CCS1,   1, 
                        CSC1,   1, 
                        PED1,   1
                    }
                }

                Method (USBS, 1, NotSerialized)
                {
                    If (UPAC (Arg0))
                    {
                        SSTA ()
                    }
                }

                Method (USBW, 1, NotSerialized)
                {
                    If (UPAC (Arg0))
                    {
                        RSTA ()
                    }
                }

                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x03, 0x03))
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)  // _ADR: Address
                OperationRegion (BAR0, PCI_Config, 0xC0, 0x05)
                Field (BAR0, ByteAcc, NoLock, Preserve)
                {
                    UBL1,   16, 
                    Offset (0x04), 
                    P0WE,   1, 
                    P1WE,   1, 
                    Offset (0x05)
                }

                Method (_PSW, 1, NotSerialized)  // _PSW: Power State Wake
                {
                    If (Arg0)
                    {
                        P0WE = 0x01
                        P1WE = 0x01
                    }
                    Else
                    {
                        P0WE = 0x00
                        P1WE = 0x00
                    }
                }

                Method (UPAC, 1, NotSerialized)
                {
                    Local0 = Zero
                    If ((OSFG == OS9X))
                    {
                        Local0 = One
                    }
                    Else
                    {
                        If ((OSFG == OS98))
                        {
                            Local0 = One
                        }
                    }

                    If (Local0)
                    {
                        If ((Arg0 == 0x03))
                        {
                            Return (One)
                        }
                    }

                    Return (Zero)
                }

                OperationRegion (UPCI, PCI_Config, 0x20, 0x04)
                Field (UPCI, ByteAcc, NoLock, Preserve)
                {
                    UBAS,   32
                }

                Name (BASA, 0xB400)
                Name (P0ST, Zero)
                Name (P1ST, Zero)
                Method (SSTA, 0, NotSerialized)
                {
                    BASA = UBAS /* \_SB_.PCI0.USB2.UBAS */
                    BASA &= 0xFFFFFFFE
                    OperationRegion (UHCI, SystemIO, BASA, 0x20)
                    Field (UHCI, ByteAcc, NoLock, Preserve)
                    {
                        RSTP,   1, 
                        HRST,   1, 
                        GRST,   1, 
                        Offset (0x10), 
                        CCS0,   1, 
                        CSC0,   1, 
                        PED0,   1, 
                        Offset (0x12), 
                        CCS1,   1, 
                        CSC1,   1, 
                        PED1,   1
                    }

                    P0ST = CCS0 /* \_SB_.PCI0.USB2.SSTA.CCS0 */
                    P1ST = CCS1 /* \_SB_.PCI0.USB2.SSTA.CCS1 */
                }

                Method (RSTA, 0, NotSerialized)
                {
                    UBAS = BASA /* \_SB_.PCI0.USB2.BASA */
                    OperationRegion (UHCI, SystemIO, BASA, 0x20)
                    Field (UHCI, ByteAcc, NoLock, Preserve)
                    {
                        RSTP,   1, 
                        HRST,   1, 
                        GRST,   1, 
                        Offset (0x10), 
                        CCS0,   1, 
                        CSC0,   1, 
                        PED0,   1, 
                        Offset (0x12), 
                        CCS1,   1, 
                        CSC1,   1, 
                        PED1,   1
                    }
                }

                Method (USBS, 1, NotSerialized)
                {
                    If (UPAC (Arg0))
                    {
                        SSTA ()
                    }
                }

                Method (USBW, 1, NotSerialized)
                {
                    If (UPAC (Arg0))
                    {
                        RSTA ()
                    }
                }

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

            Device (USB3)
            {
                Name (_ADR, 0x001D0002)  // _ADR: Address
                OperationRegion (BAR0, PCI_Config, 0xC0, 0x05)
                Field (BAR0, ByteAcc, NoLock, Preserve)
                {
                    UBL1,   16, 
                    Offset (0x04), 
                    P0WE,   1, 
                    P1WE,   1, 
                    Offset (0x05)
                }

                Method (_PSW, 1, NotSerialized)  // _PSW: Power State Wake
                {
                    If (Arg0)
                    {
                        P0WE = 0x01
                        P1WE = 0x01
                    }
                    Else
                    {
                        P0WE = 0x00
                        P1WE = 0x00
                    }
                }

                Method (UPAC, 1, NotSerialized)
                {
                    Local0 = Zero
                    If ((OSFG == OS9X))
                    {
                        Local0 = One
                    }
                    Else
                    {
                        If ((OSFG == OS98))
                        {
                            Local0 = One
                        }
                    }

                    If (Local0)
                    {
                        If ((Arg0 == 0x03))
                        {
                            Return (One)
                        }
                    }

                    Return (Zero)
                }

                OperationRegion (UPCI, PCI_Config, 0x20, 0x04)
                Field (UPCI, ByteAcc, NoLock, Preserve)
                {
                    UBAS,   32
                }

                Name (BASA, 0xB400)
                Name (P0ST, Zero)
                Name (P1ST, Zero)
                Method (SSTA, 0, NotSerialized)
                {
                    BASA = UBAS /* \_SB_.PCI0.USB3.UBAS */
                    BASA &= 0xFFFFFFFE
                    OperationRegion (UHCI, SystemIO, BASA, 0x20)
                    Field (UHCI, ByteAcc, NoLock, Preserve)
                    {
                        RSTP,   1, 
                        HRST,   1, 
                        GRST,   1, 
                        Offset (0x10), 
                        CCS0,   1, 
                        CSC0,   1, 
                        PED0,   1, 
                        Offset (0x12), 
                        CCS1,   1, 
                        CSC1,   1, 
                        PED1,   1
                    }

                    P0ST = CCS0 /* \_SB_.PCI0.USB3.SSTA.CCS0 */
                    P1ST = CCS1 /* \_SB_.PCI0.USB3.SSTA.CCS1 */
                }

                Method (RSTA, 0, NotSerialized)
                {
                    UBAS = BASA /* \_SB_.PCI0.USB3.BASA */
                    OperationRegion (UHCI, SystemIO, BASA, 0x20)
                    Field (UHCI, ByteAcc, NoLock, Preserve)
                    {
                        RSTP,   1, 
                        HRST,   1, 
                        GRST,   1, 
                        Offset (0x10), 
                        CCS0,   1, 
                        CSC0,   1, 
                        PED0,   1, 
                        Offset (0x12), 
                        CCS1,   1, 
                        CSC1,   1, 
                        PED1,   1
                    }
                }

                Method (USBS, 1, NotSerialized)
                {
                    If (UPAC (Arg0))
                    {
                        SSTA ()
                    }
                }

                Method (USBW, 1, NotSerialized)
                {
                    If (UPAC (Arg0))
                    {
                        RSTA ()
                    }
                }

                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x0C, 0x03))
                }
            }

            Device (EHCI)
            {
                Name (_ADR, 0x001D0007)  // _ADR: Address
                OperationRegion (U20P, PCI_Config, 0x00, 0x0100)
                Field (U20P, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x04), 
                        ,   1, 
                    MSPE,   1, 
                    Offset (0x06), 
                    Offset (0x10), 
                    MBAS,   32, 
                    Offset (0x54), 
                    PSTA,   2, 
                    Offset (0x55), 
                    PMEE,   1, 
                        ,   6, 
                    PMES,   1
                }

                Method (_PSW, 1, NotSerialized)  // _PSW: Power State Wake
                {
                    Local0 = MBAS /* \_SB_.PCI0.EHCI.MBAS */
                    Local0 &= 0xFFFFFFF0
                    OperationRegion (MMIO, SystemMemory, Local0, 0x0100)
                    Field (MMIO, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x64), 
                        P0SC,   32, 
                        P1SC,   32, 
                        P2SC,   32, 
                        P3SC,   32, 
                        P4SC,   32, 
                        P5SC,   32
                    }

                    If (!Local0)
                    {
                        Local2 = PSTA /* \_SB_.PCI0.EHCI.PSTA */
                        PSTA = Zero
                        Local3 = MSPE /* \_SB_.PCI0.EHCI.MSPE */
                        MSPE = One
                        If (Arg0)
                        {
                            Local4 = P0SC /* \_SB_.PCI0.EHCI._PSW.P0SC */
                            Local4 |= 0x00300000
                            P0SC = Local4
                            Local4 = P1SC /* \_SB_.PCI0.EHCI._PSW.P1SC */
                            Local4 |= 0x00300000
                            P1SC = Local4
                            Local4 = P2SC /* \_SB_.PCI0.EHCI._PSW.P2SC */
                            Local4 |= 0x00300000
                            P2SC = Local4
                            Local4 = P3SC /* \_SB_.PCI0.EHCI._PSW.P3SC */
                            Local4 |= 0x00300000
                            P3SC = Local4
                            Local4 = P4SC /* \_SB_.PCI0.EHCI._PSW.P4SC */
                            Local4 |= 0x00300000
                            P4SC = Local4
                            Local4 = P5SC /* \_SB_.PCI0.EHCI._PSW.P5SC */
                            Local4 |= 0x00300000
                            P5SC = Local4
                            PMES = One
                            PMEE = One
                        }
                        Else
                        {
                            Local4 = P0SC /* \_SB_.PCI0.EHCI._PSW.P0SC */
                            Local4 &= 0xFFCFFFFF
                            P0SC = Local4
                            Local4 = P1SC /* \_SB_.PCI0.EHCI._PSW.P1SC */
                            Local4 &= 0xFFCFFFFF
                            P1SC = Local4
                            Local4 = P2SC /* \_SB_.PCI0.EHCI._PSW.P2SC */
                            Local4 &= 0xFFCFFFFF
                            P2SC = Local4
                            Local4 = P3SC /* \_SB_.PCI0.EHCI._PSW.P3SC */
                            Local4 &= 0xFFCFFFFF
                            P3SC = Local4
                            Local4 = P4SC /* \_SB_.PCI0.EHCI._PSW.P4SC */
                            Local4 &= 0xFFCFFFFF
                            P4SC = Local4
                            Local4 = P5SC /* \_SB_.PCI0.EHCI._PSW.P5SC */
                            Local4 &= 0xFFCFFFFF
                            P5SC = Local4
                            PMES = One
                            PMEE = Zero
                        }

                        MSPE = Local3
                        PSTA = Local2
                    }
                }

                Method (_PRW, 0, NotSerialized)  // _PRW: Power Resources for Wake
                {
                    Return (GPRW (0x0D, 0x03))
                }
            }
        }
    }

    Scope (\_PR.CPU1)
    {
        Name (TYPE, 0x00)
        Name (PDCR, 0x01)
        Name (PDCM, 0x01)
        Method (APDC, 1, NotSerialized)
        {
            CreateDWordField (Arg0, 0x00, REV)
            CreateDWordField (Arg0, 0x04, SIZE)
            CreateDWordField (Arg0, 0x08, DAT0)
            If ((REV != PDCR))
            {
                Return (0x00)
            }

            If ((SIZE < 0x01))
            {
                Return (0x00)
            }

            If ((DAT0 & PDCM))
            {
                TYPE = 0x01
            }

            Return (0x01)
        }

        Name (MPCT, Package (0x02)
        {
            ResourceTemplate ()
            {
                Register (FFixedHW, 
                    0x40,               // Bit Width
                    0x00,               // Bit Offset
                    0x0000000000000199, // Address
                    ,)
            }, 

            ResourceTemplate ()
            {
                Register (FFixedHW, 
                    0x10,               // Bit Width
                    0x00,               // Bit Offset
                    0x0000000000000198, // Address
                    ,)
            }
        })
        Name (PPCT, Package (0x02)
        {
            ResourceTemplate ()
            {
                Register (SystemIO, 
                    0x10,               // Bit Width
                    0x00,               // Bit Offset
                    0x00000000000000B2, // Address
                    ,)
            }, 

            ResourceTemplate ()
            {
                Register (SystemIO, 
                    0x08,               // Bit Width
                    0x00,               // Bit Offset
                    0x00000000000000B3, // Address
                    ,)
            }
        })
        Method (APCT, 0, NotSerialized)
        {
            If (TYPE)
            {
                Return (MPCT) /* \_PR_.CPU1.MPCT */
            }
            Else
            {
                Return (PPCT) /* \_PR_.CPU1.PPCT */
            }
        }

        Name (MPSS, Package (0x0A)
        {
            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x0A, 
                0x112C, 
                0x112C
            }, 

            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x0A, 
                0x112C, 
                0x112C
            }, 

            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x0A, 
                0x112C, 
                0x112C
            }, 

            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x0A, 
                0x112C, 
                0x112C
            }, 

            Package (0x06)
            {
                0x0640, 
                0x7D00, 
                0x0A, 
                0x0A, 
                0x1029, 
                0x1029
            }, 

            Package (0x06)
            {
                0x0578, 
                0x6D60, 
                0x0A, 
                0x0A, 
                0x0E23, 
                0x0E23
            }, 

            Package (0x06)
            {
                0x04B0, 
                0x5DC0, 
                0x0A, 
                0x0A, 
                0x0C1D, 
                0x0C1D
            }, 

            Package (0x06)
            {
                0x03E8, 
                0x4E20, 
                0x0A, 
                0x0A, 
                0x0A17, 
                0x0A17
            }, 

            Package (0x06)
            {
                0x0320, 
                0x3E80, 
                0x0A, 
                0x0A, 
                0x0811, 
                0x0811
            }, 

            Package (0x06)
            {
                0x0258, 
                0x2EE0, 
                0x0A, 
                0x0A, 
                0x060B, 
                0x060B
            }
        })
        Name (PPSS, Package (0x0A)
        {
            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x64, 
                0x86, 
                0x00
            }, 

            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x64, 
                0x86, 
                0x00
            }, 

            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x64, 
                0x86, 
                0x00
            }, 

            Package (0x06)
            {
                0x06A4, 
                0x84D0, 
                0x0A, 
                0x64, 
                0x86, 
                0x00
            }, 

            Package (0x06)
            {
                0x0640, 
                0x7D00, 
                0x0A, 
                0x64, 
                0x0186, 
                0x01
            }, 

            Package (0x06)
            {
                0x0578, 
                0x6D60, 
                0x0A, 
                0x64, 
                0x0286, 
                0x02
            }, 

            Package (0x06)
            {
                0x04B0, 
                0x5DC0, 
                0x0A, 
                0x64, 
                0x0386, 
                0x03
            }, 

            Package (0x06)
            {
                0x03E8, 
                0x4E20, 
                0x0A, 
                0x64, 
                0x0486, 
                0x04
            }, 

            Package (0x06)
            {
                0x0320, 
                0x3E80, 
                0x0A, 
                0x64, 
                0x0586, 
                0x05
            }, 

            Package (0x06)
            {
                0x0258, 
                0x2EE0, 
                0x0A, 
                0x64, 
                0x0686, 
                0x06
            }
        })
        Name (NPSS, 0x00)
        Method (APSS, 0, NotSerialized)
        {
            If (TYPE)
            {
                Return (MPSS) /* \_PR_.CPU1.MPSS */
            }
            Else
            {
                Return (PPSS) /* \_PR_.CPU1.PPSS */
            }
        }

        Method (APPC, 0, NotSerialized)
        {
            If ((\ACPF == 0x00))
            {
                If ((SizeOf (PPSS) <= NPSS))
                {
                    Local1 = Zero
                }
                Else
                {
                    Local1 = (SizeOf (PPSS) - NPSS) /* \_PR_.CPU1.NPSS */
                }

                If ((\DCTP == 0x00))
                {
                    Local2 = 0xFFFF
                    If (\CTYP)
                    {
                        Local3 = (0x0610 >> 0x08)
                    }
                    Else
                    {
                        Local3 = (0x0610 >> 0x08)
                    }

                    While ((Local2 > Local3))
                    {
                        Local2 = DerefOf (Index (DerefOf (Index (MPSS, Local1)), 0x04))
                        Local2 >>= 0x08
                        If ((Local2 <= 0x06))
                        {
                            Return (Local1)
                        }
                        Else
                        {
                            If ((Local2 <= Local3))
                            {
                                Return (Local1)
                            }
                        }

                        Local1++
                    }
                }
            }

            If ((SizeOf (PPSS) <= NPSS))
            {
                Return (0x00)
            }
            Else
            {
                Return ((SizeOf (PPSS) - NPSS))
            }
        }
    }

    Scope (\_SB)
    {
        OperationRegion (\_SB.PCI0.SBRG.IROR, PCI_Config, 0x00, 0xFF)
        Field (\_SB.PCI0.SBRG.IROR, ByteAcc, NoLock, Preserve)
        {
            Offset (0x60), 
            PIRA,   8, 
            PIRB,   8, 
            PIRC,   8, 
            PIRD,   8, 
            Offset (0x68), 
            PIRE,   8, 
            PIRF,   8, 
            PIRG,   8, 
            PIRH,   8
        }

        Name (BUFA, ResourceTemplate ()
        {
            IRQ (Level, ActiveLow, Shared, _Y16)
                {15}
        })
        CreateWordField (BUFA, \_SB._Y16._INT, ICRS)  // _INT: Interrupts
        Method (LSTA, 1, NotSerialized)
        {
            Local0 = (Arg0 & 0x80)
            If (Local0)
            {
                Return (0x09)
            }
            Else
            {
                Return (0x0B)
            }
        }

        Method (LCRS, 1, NotSerialized)
        {
            Local0 = (Arg0 & 0x0F)
            ICRS = (0x01 << Local0)
            Return (BUFA) /* \_SB_.BUFA */
        }

        Method (LSRS, 1, NotSerialized)
        {
            CreateWordField (Arg0, 0x01, ISRS)
            FindSetRightBit (ISRS, Local0)
            Return (Local0--)
        }

        Method (LDIS, 1, NotSerialized)
        {
            Return ((Arg0 | 0x80))
        }

        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
            {
                Return (LSTA (PIRA))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRA))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRA = LSRS (Arg0)
            }
        }

        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
            {
                Return (LSTA (PIRB))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRB))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRB = LSRS (Arg0)
            }
        }

        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
            {
                Return (LSTA (PIRC))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRC))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRC = LSRS (Arg0)
            }
        }

        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
            {
                Return (LSTA (PIRD))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRD))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRD = LSRS (Arg0)
            }
        }

        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
            {
                Return (LSTA (PIRE))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRE))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRE = LSRS (Arg0)
            }
        }

        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
            {
                Return (LSTA (PIRF))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRF))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRF = LSRS (Arg0)
            }
        }

        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
            {
                Return (LSTA (PIRG))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRG))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRG = LSRS (Arg0)
            }
        }

        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
            {
                Return (LSTA (PIRH))
            }

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

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

            Method (_CRS, 0, NotSerialized)  // _CRS: Current Resource Settings
            {
                Return (LCRS (PIRH))
            }

            Method (_SRS, 1, NotSerialized)  // _SRS: Set Resource Settings
            {
                PIRH = LSRS (Arg0)
            }
        }
    }

    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
                    ,, _Y17, 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._Y17._MIN, MIN5)  // _MIN: Minimum Base Address
            CreateDWordField (CRS, \_SB.PCI0._Y17._MAX, MAX5)  // _MAX: Maximum Base Address
            CreateDWordField (CRS, \_SB.PCI0._Y17._LEN, LEN5)  // _LEN: Length
            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
            {
                MIN5 = MG1B /* \MG1B */
                LEN5 = MG1L /* \MG1L */
                Local0 = MG1L /* \MG1L */
                If (Local0)
                {
                    MAX5 = (MIN5 + Local0--)
                }

                MIN6 = MG2B /* \MG2B */
                LEN6 = MG2L /* \MG2L */
                Local0 = MG2L /* \MG2L */
                MAX6 = (MIN6 + Local0--)
                Return (CRS) /* \_SB_.PCI0.CRS_ */
            }
        }
    }

    If (SS1)
    {
        Name (\_SB.PCI0._S1D, 0x02)  // _S1D: S1 Device State
        Name (\_SB.PCI0.P0P1._S1D, 0x02)  // _S1D: S1 Device State
        Name (\_SB.PCI0.USB1._S1D, 0x02)  // _S1D: S1 Device State
        Name (\_SB.PCI0.USB2._S1D, 0x02)  // _S1D: S1 Device State
        Name (\_SB.PCI0.USB3._S1D, 0x02)  // _S1D: S1 Device State
    }

    If (SS3)
    {
        Name (\_SB.PCI0._S3D, 0x02)  // _S3D: S3 Device State
        Name (\_SB.PCI0.P0P1._S3D, 0x02)  // _S3D: S3 Device State
        Name (\_SB.PCI0.USB1._S3D, 0x02)  // _S3D: S3 Device State
        Name (\_SB.PCI0.USB2._S3D, 0x02)  // _S3D: S3 Device State
        Name (\_SB.PCI0.USB3._S3D, 0x02)  // _S3D: S3 Device State
    }

    If (SS4)
    {
        Name (\_SB.PCI0._S4D, 0x02)  // _S4D: S4 Device State
        Name (\_SB.PCI0.P0P1._S4D, 0x02)  // _S4D: S4 Device State
    }

    Method (_PTS, 1, NotSerialized)  // _PTS: Prepare To Sleep
    {
        DBG8 = Arg0
        PTS (Arg0)
        Index (WAKP, 0x00) = 0x00
        Index (WAKP, 0x01) = 0x00
    }

    Name (SLID, 0x01)
    Method (_WAK, 1, NotSerialized)  // _WAK: Wake
    {
        DBG8 = (Arg0 << 0x04)
        SLID = 0x01
        WAK (Arg0)
        If (DerefOf (Index (WAKP, 0x00)))
        {
            Index (WAKP, 0x01) = 0x00
        }
        Else
        {
            Index (WAKP, 0x01) = Arg0
        }

        Return (WAKP) /* \WAKP */
    }

    Name (_S0, Package (0x04)  // _S0_: S0 System State
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    If (SS1)
    {
        Name (_S1, Package (0x04)  // _S1_: S1 System State
        {
            0x02, 
            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
    })
    Method (PTS, 1, NotSerialized)
    {
        If (Arg0)
        {
            FANS (Arg0)
            \_TZ.TRMS (Arg0)
        }

        OEMS (Arg0)
    }

    Method (WAK, 1, NotSerialized)
    {
        FANW (Arg0)
        \_TZ.TRMW (Arg0)
        OEMW (Arg0)
    }
}



FACP
----
[000h 0000   4]                    Signature : "FACP"    [Fixed ACPI Description Table (FADT)]
[004h 0004   4]                 Table Length : 00000081
[008h 0008   1]                     Revision : 02
[009h 0009   1]                     Checksum : 4E
[00Ah 0010   6]                       Oem ID : "A M I "
[010h 0016   8]                 Oem Table ID : "OEMFACP "
[018h 0024   4]                 Oem Revision : 01000504
[01Ch 0028   4]              Asl Compiler ID : "MSFT"
[020h 0032   4]        Asl Compiler Revision : 00000097

[024h 0036   4]                 FACS Address : 7DF50000
[028h 0040   4]                 DSDT Address : 7DF40360
[02Ch 0044   1]                        Model : 01
[02Dh 0045   1]                   PM Profile : 00 [Unspecified]
[02Eh 0046   2]                SCI Interrupt : 0009
[030h 0048   4]             SMI Command Port : 000000B2
[034h 0052   1]            ACPI Enable Value : E1
[035h 0053   1]           ACPI Disable Value : 1E
[036h 0054   1]               S4BIOS Command : 00
[037h 0055   1]              P-State Control : E2
[038h 0056   4]     PM1A Event Block Address : 0000E400
[03Ch 0060   4]     PM1B Event Block Address : 00000000
[040h 0064   4]   PM1A Control Block Address : 0000E404
[044h 0068   4]   PM1B Control Block Address : 00000000
[048h 0072   4]    PM2 Control Block Address : 0000E420
[04Ch 0076   4]       PM Timer Block Address : 0000E408
[050h 0080   4]           GPE0 Block Address : 0000E428
[054h 0084   4]           GPE1 Block Address : 00000000
[058h 0088   1]       PM1 Event Block Length : 04
[059h 0089   1]     PM1 Control Block Length : 02
[05Ah 0090   1]     PM2 Control Block Length : 01
[05Bh 0091   1]        PM Timer Block Length : 04
[05Ch 0092   1]            GPE0 Block Length : 08
[05Dh 0093   1]            GPE1 Block Length : 00
[05Eh 0094   1]             GPE1 Base Offset : 00
[05Fh 0095   1]                 _CST Support : E3
[060h 0096   2]                   C2 Latency : 0001
[062h 0098   2]                   C3 Latency : 0065
[064h 0100   2]               CPU Cache Size : 0400
[066h 0102   2]           Cache Flush Stride : 0010
[068h 0104   1]            Duty Cycle Offset : 01
[069h 0105   1]             Duty Cycle Width : 03
[06Ah 0106   1]          RTC Day Alarm Index : 0D
[06Bh 0107   1]        RTC Month Alarm Index : 00
[06Ch 0108   1]            RTC Century Index : 00
[06Dh 0109   2]   Boot Flags (decoded below) : 0003
               Legacy Devices Supported (V2) : 1
            8042 Present on ports 60/64 (V2) : 1
                        VGA Not Present (V4) : 0
                      MSI Not Supported (V4) : 0
                PCIe ASPM Not Supported (V4) : 0
                   CMOS RTC Not Present (V5) : 0
[06Fh 0111   1]                     Reserved : 00
[070h 0112   4]        Flags (decoded below) : 000000A5
      WBINVD instruction is operational (V1) : 1
              WBINVD flushes all caches (V1) : 0
                    All CPUs support C1 (V1) : 1
                  C2 works on MP system (V1) : 0
            Control Method Power Button (V1) : 0
            Control Method Sleep Button (V1) : 1
        RTC wake not in fixed reg space (V1) : 0
            RTC can wake system from S4 (V1) : 1
                        32-bit PM Timer (V1) : 0
                      Docking Supported (V1) : 0
               Reset Register Supported (V2) : 0
                            Sealed Case (V3) : 0
                    Headless - No Video (V3) : 0
        Use native instr after SLP_TYPx (V3) : 0
              PCIEXP_WAK Bits Supported (V4) : 0
                     Use Platform Timer (V4) : 0
               RTC_STS valid on S4 wake (V4) : 0
                Remote Power-on capable (V4) : 0
                 Use APIC Cluster Model (V4) : 0
     Use APIC Physical Destination Mode (V4) : 0
                       Hardware Reduced (V5) : 0
                      Low Power S0 Idle (V5) : 0

[074h 0116  12]               Reset Register : [Generic Address Structure]
[074h 0116   1]                     Space ID : 01 [SystemIO]
[075h 0117   1]                    Bit Width : 08
[076h 0118   1]                   Bit Offset : 00
[077h 0119   1]         Encoded Access Width : 00 [Undefined/Legacy]
[078h 0120   8]                      Address : 0000000000000CF9

[080h 0128   1]         Value to cause reset : 06
**** ACPI table terminates in the middle of a data structure!

// ACPI Warning: FADT revision 2 does not match length: found 81 expected 84

Raw Table Data: Length 129 (0x81)

  0000: 46 41 43 50 81 00 00 00 02 4E 41 20 4D 20 49 20  FACP.....NA M I 
  0010: 4F 45 4D 46 41 43 50 20 04 05 00 01 4D 53 46 54  OEMFACP ....MSFT
  0020: 97 00 00 00 00 00 F5 7D 60 03 F4 7D 01 00 09 00  .......}`..}....
  0030: B2 00 00 00 E1 1E 00 E2 00 E4 00 00 00 00 00 00  ................
  0040: 04 E4 00 00 00 00 00 00 20 E4 00 00 08 E4 00 00  ........ .......
  0050: 28 E4 00 00 00 00 00 00 04 02 01 04 08 00 00 E3  (...............
  0060: 01 00 65 00 00 04 10 00 01 03 0D 00 00 03 00 00  ..e.............
  0070: A5 00 00 00 01 08 00 00 F9 0C 00 00 00 00 00 00  ................
  0080: 06                                               .


FACS
----
[000h 0000   4]                    Signature : "FACS"
[004h 0004   4]                       Length : 00000040
[008h 0008   4]           Hardware Signature : 00000000
[00Ch 0012   4]    32 Firmware Waking Vector : 00000000
[010h 0016   4]                  Global Lock : 00000000
[014h 0020   4]        Flags (decoded below) : 00000000
                      S4BIOS Support Present : 0
                  64-bit Wake Supported (V2) : 0
[018h 0024   8]    64 Firmware Waking Vector : 0000000000000000
[020h 0032   1]                      Version : 01
[021h 0033   3]                     Reserved : 000000
[024h 0036   4]    OspmFlags (decoded below) : 00000000
               64-bit Wake Env Required (V2) : 0

Raw Table Data: Length 64 (0x40)

  0000: 46 41 43 53 40 00 00 00 00 00 00 00 00 00 00 00  FACS@...........
  0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
  0020: 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
  0030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................


OEMB
----
[000h 0000   4]                    Signature : "OEMB"    
[004h 0004   4]                 Table Length : 0000004D
[008h 0008   1]                     Revision : 01
[009h 0009   1]                     Checksum : 2B     /* Incorrect checksum, should be 25 */
[00Ah 0010   6]                       Oem ID : "A M I "
[010h 0016   8]                 Oem Table ID : "OEMBIOS "
[018h 0024   4]                 Oem Revision : 01000504
[01Ch 0028   4]              Asl Compiler ID : "MSFT"
[020h 0032   4]        Asl Compiler Revision : 00000097


**** OEM-defined ACPI table [OEMB], unknown contents


Raw Table Data: Length 77 (0x4D)

  0000: 4F 45 4D 42 4D 00 00 00 01 2B 41 20 4D 20 49 20  OEMBM....+A M I 
  0010: 4F 45 4D 42 49 4F 53 20 04 05 00 01 4D 53 46 54  OEMBIOS ....MSFT
  0020: 97 00 00 00 0D 06 04 00 00 00 7E 00 00 F8 FF 00  ..........~.....
  0030: 00 0D 00 00 00 01 00 00 00 00 7E 00 00 C0 80 2E  ..........~.....
  0040: 00 00 E4 80 00 E8 10 00 0C 10 00 EC 40           ............@


RSDT
----
[000h 0000   4]                    Signature : "RSDT"    [Root System Description Table]
[004h 0004   4]                 Table Length : 00000030
[008h 0008   1]                     Revision : 01
[009h 0009   1]                     Checksum : A9
[00Ah 0010   6]                       Oem ID : "A M I "
[010h 0016   8]                 Oem Table ID : "OEMRSDT "
[018h 0024   4]                 Oem Revision : 01000504
[01Ch 0028   4]              Asl Compiler ID : "MSFT"
[020h 0032   4]        Asl Compiler Revision : 00000097

[024h 0036   4]       ACPI Table Address   0 : 7DF40200
[028h 0040   4]       ACPI Table Address   1 : 7DF40300
[02Ch 0044   4]       ACPI Table Address   2 : 7DF50040

Raw Table Data: Length 48 (0x30)

  0000: 52 53 44 54 30 00 00 00 01 A9 41 20 4D 20 49 20  RSDT0.....A M I 
  0010: 4F 45 4D 52 53 44 54 20 04 05 00 01 4D 53 46 54  OEMRSDT ....MSFT
  0020: 97 00 00 00 00 02 F4 7D 00 03 F4 7D 40 00 F5 7D  .......}...}@..}