/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20090123
 *
 * Disassembly of dsdt, Fri Jul 30 22:44:57 2010
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00006E6A (28266)
 *     Revision         0x01 **** ACPI 1.0, no 64-bit math support
 *     Checksum         0xD5
 *     OEM ID           "FUJ   "
 *     OEM Table ID     "FJNB1B5 "
 *     OEM Revision     0x01350000 (20250624)
 *     Compiler ID      "MSFT"
 *     Compiler Version 0x0100000E (16777230)
 */
DefinitionBlock ("dsdt.aml", "DSDT", 1, "FUJ   ", "FJNB1B5 ", 0x01350000)
{
    External (DC1S)
    External (\_SB_.REPL)
    External (\_PR_.CPU0._PPC, IntObj)
    External (\_SB_.PCI0.GFX0.LCD_.BLNF, MethodObj)    // 0 Arguments

    Name (BIDT, Buffer (0x10)
    {
        /* 0000 */    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
        /* 0008 */    0x08, 0x00, 0x00, 0x00, 0x09, 0x0A, 0x00, 0x0B
    })
    Name (BMNT, Package (0x0C)
    {
        "CP279074", 
        "CP293530", 
        "CP293546", 
        "CP293562", 
        "CP293578", 
        "CP293594", 
        "CP293610", 
        "CP293626", 
        "CP293642", 
        "CP245360", 
        "CP186215 / CP186216", 
        "CP144820 / CP144821"
    })
    Name (BMST, Package (0x0C)
    {
        "CP279074", 
        "CP293530", 
        "CP293546", 
        "CP293562", 
        "CP293578", 
        "CP293594", 
        "CP293610", 
        "CP293626", 
        "CP293642", 
        "CP245360", 
        "CP245376", 
        "CP245408"
    })
    Scope (\_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
        Processor (CPU1, 0x01, 0x00001010, 0x06) {}
    }

    Scope (\_SB)
    {
        Name (OSTB, Ones)
        OperationRegion (OSTY, SystemMemory, 0x3F6E9EF6, 0x00000001)
        Field (OSTY, AnyAcc, NoLock, Preserve)
        {
            TPOS,   8
        }

        Method (OSTP, 0, NotSerialized)
        {
            If (LEqual (^OSTB, Ones))
            {
                If (CondRefOf (\_OSI, Local0))
                {
                    If (\_OSI ("Windows 2006"))
                    {
                        Store (0x40, ^OSTB)
                        Store (0x40, ^TPOS)
                    }
                    Else
                    {
                        If (\_OSI ("Windows 2001.1"))
                        {
                            Store (0x20, ^OSTB)
                            Store (0x20, ^TPOS)
                        }
                        Else
                        {
                            If (\_OSI ("Windows 2001 SP1"))
                            {
                                Store (0x10, ^OSTB)
                                Store (0x10, ^TPOS)
                            }
                            Else
                            {
                                If (\_OSI ("Windows 2001"))
                                {
                                    Store (0x08, ^OSTB)
                                    Store (0x08, ^TPOS)
                                }
                                Else
                                {
                                    Store (0x00, ^OSTB)
                                    Store (0x00, ^TPOS)
                                }
                            }
                        }
                    }
                }
                Else
                {
                    If (CondRefOf (\_OS, Local0))
                    {
                        If (^SEQL (\_OS, "Microsoft Windows"))
                        {
                            Store (0x01, ^OSTB)
                            Store (0x01, ^TPOS)
                        }
                        Else
                        {
                            If (^SEQL (\_OS, "Microsoft WindowsME: Millennium Edition"))
                            {
                                Store (0x02, ^OSTB)
                                Store (0x02, ^TPOS)
                            }
                            Else
                            {
                                If (^SEQL (\_OS, "Microsoft Windows NT"))
                                {
                                    Store (0x04, ^OSTB)
                                    Store (0x04, ^TPOS)
                                }
                                Else
                                {
                                    Store (0x00, ^OSTB)
                                    Store (0x00, ^TPOS)
                                }
                            }
                        }
                    }
                    Else
                    {
                        Store (0x00, ^OSTB)
                        Store (0x00, ^TPOS)
                    }
                }
            }

            Return (^OSTB)
        }

        Method (SEQL, 2, Serialized)
        {
            Store (SizeOf (Arg0), Local0)
            Store (SizeOf (Arg1), Local1)
            If (LNotEqual (Local0, Local1))
            {
                Return (Zero)
            }

            Name (BUF0, Buffer (Local0) {})
            Store (Arg0, BUF0)
            Name (BUF1, Buffer (Local0) {})
            Store (Arg1, BUF1)
            Store (Zero, Local2)
            While (LLess (Local2, Local0))
            {
                Store (DerefOf (Index (BUF0, Local2)), Local3)
                Store (DerefOf (Index (BUF1, Local2)), Local4)
                If (LNotEqual (Local3, Local4))
                {
                    Return (Zero)
                }

                Increment (Local2)
            }

            Return (One)
        }
    }

    Name (FWSO, Zero)
    Name (RPEN, Zero)
    Name (RPDS, Zero)
    Name (BYIS, 0xFF)
    Name (EXIS, 0xFF)
    Name (PLWM, Zero)
    Name (PTAL, Zero)
    Name (LEDI, Zero)
    Name (BTNI, Zero)
    Name (NGTI, 0x06)
    Name (ECCI, 0x33)
    Name (GINT, Zero)
    Name (DPCI, One)
    Name (DPCS, Zero)
    Name (LIDS, Zero)
    Name (VSTH, Zero)
    Name (HDWA, Zero)
    Name (WSEF, Zero)
    Name (LIDF, Zero)
    Name (PREF, Zero)
    Name (THMC, Zero)
    Name (\GPIC, 0x00)
    Method (\_PIC, 1, NotSerialized)
    {
        Store (Arg0, GPIC)
    }

    Scope (\_SB)
    {
        OperationRegion (PSIO, SystemIO, 0x00000F40, 0x00000002)
        OperationRegion (PSBF, SystemMemory, 0x3F6E9E66, 0x00000090)
        OperationRegion (OEMT, SystemMemory, 0x3F6E9F9C, 0x00000020)
        OperationRegion (SYSC, SystemMemory, 0x3F6E9F92, 0x0000000A)
        OperationRegion (VDEX, SystemMemory, 0x3F6E9E56, 0x00000010)
        OperationRegion (THZN, SystemMemory, 0x3F6E9F82, 0x00000010)
        OperationRegion (BTNC, SystemMemory, 0x3F6E9F72, 0x00000010)
        OperationRegion (VIST, SystemMemory, 0x3F6E95C3, 0x00000893)
        OperationRegion (QBC, SystemMemory, 0x3F6E9F66, 0x0000000C)
        OperationRegion (TCG1, SystemMemory, 0x3F6E95BF, 0x00000004)
        OperationRegion (IO80, SystemIO, 0x80, 0x01)
        Scope (\)
        {
            Field (\_SB.PSIO, ByteAcc, NoLock, Preserve)
            {
                SSMI,   8
            }

            Field (\_SB.PSBF, ByteAcc, NoLock, Preserve)
            {
                CMD,    8, 
                DVID,   32, 
                PSDT,   32
            }

            Field (\_SB.PSBF, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x05), 
                INF,    8
            }

            Field (\_SB.PSBF, ByteAcc, NoLock, Preserve)
            {
                        Offset (0x05), 
                PIID,   320
            }

            Field (\_SB.OEMT, ByteAcc, NoLock, Preserve)
            {
                SPAF,   2, 
                SPBF,   2, 
                PPF,    3, 
                FDCF,   1, 
                SIDF,   2, 
                IMTF,   1, 
                BLEN,   1, 
                WLEN,   1, 
                BTEX,   1, 
                        Offset (0x04), 
                WAPB,   1, 
                    ,   3, 
                PSNM,   4, 
                        Offset (0x08), 
                FWHM,   1, 
                    ,   1, 
                TPMF,   2, 
                HWPM,   1, 
                RRCP,   1, 
                INTV,   1, 
                FSCM,   1, 
                    ,   1, 
                CPBL,   1, 
                AS34,   1, 
                        Offset (0x0A), 
                BIFL,   8, 
                DCLW,   7, 
                        Offset (0x10), 
                FDS0,   4, 
                FDS1,   4, 
                        Offset (0x18), 
                UMST,   32, 
                UMSZ,   32
            }

            Field (\_SB.SYSC, ByteAcc, NoLock, Preserve)
            {
                BHKF,   1, 
                    ,   2, 
                MHKF,   1, 
                        Offset (0x01), 
                BLLM,   8, 
                BLLT,   64
            }

            Field (\_SB.SYSC, ByteAcc, NoLock, Preserve)
            {
                AHKF,   8
            }

            Field (\_SB.VDEX, ByteAcc, NoLock, Preserve)
            {
                ADOS,   3, 
                CLCD,   1, 
                ALCD,   1, 
                CCRT,   1, 
                ACRT,   1, 
                CTV,    1, 
                ATV,    1, 
                CDVI,   1, 
                ADVI,   1, 
                DSWF,   2, 
                BSWF,   2
            }

            Field (\_SB.THZN, ByteAcc, NoLock, Preserve)
            {
                DTS1,   8, 
                DTS2,   8, 
                CRTT,   8, 
                PSVT,   8, 
                TC1V,   4, 
                TC2V,   4, 
                TSPV,   4, 
                MPEN,   1, 
                DTSE,   1
            }

            Field (\_SB.BTNC, ByteAcc, NoLock, Preserve)
            {
                IRBF,   1, 
                VLBF,   3, 
                    ,   3, 
                NGTF,   1, 
                        Offset (0x04), 
                IRBC,   16
            }

            Field (\_SB.QBC, ByteAcc, NoLock, Preserve)
            {
                QAG1,   32, 
                QAG2,   32, 
                QAG3,   32
            }

            Field (\_SB.TCG1, AnyAcc, NoLock, Preserve)
            {
                PPRQ,   8, 
                PPLO,   8, 
                PPRP,   8, 
                PPOR,   8
            }

            Field (\_SB.IO80, ByteAcc, NoLock, Preserve)
            {
                PO80,   8
            }
        }

        Method (_INI, 0, NotSerialized)
        {
            If (LGreaterEqual (\_SB.OSTP (), 0x40))
            {
                Load (VIST, VSTH)
            }

            And (G3P1, 0xC0, Local0)
            If (LEqual (Local0, 0xC0))
            {
                Store (Zero, LEDI)
                Store (Zero, BTNI)
            }
            Else
            {
                If (Local0)
                {
                    Store (Zero, LEDI)
                    Store (0x00FF0101, BTNI)
                }
                Else
                {
                    Store (Zero, LEDI)
                    Store (0x000F0001, BTNI)
                }
            }
        }

        Device (MCFG)
        {
            Name (_HID, EisaId ("PNP0C02"))
            Name (_CRS, ResourceTemplate ()
            {
                DWordMemory (ResourceConsumer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xF8000000,         // Range Minimum
                    0xFBFFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x04000000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
            })
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_BBN, 0x00)
            OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
            Field (HBUS, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x50), 
                    ,   4, 
                PM0H,   2, 
                        Offset (0x51), 
                PM1L,   2, 
                    ,   2, 
                PM1H,   2, 
                        Offset (0x52), 
                PM2L,   2, 
                    ,   2, 
                PM2H,   2, 
                        Offset (0x53), 
                PM3L,   2, 
                    ,   2, 
                PM3H,   2, 
                        Offset (0x54), 
                PM4L,   2, 
                    ,   2, 
                PM4H,   2, 
                        Offset (0x55), 
                PM5L,   2, 
                    ,   2, 
                PM5H,   2, 
                        Offset (0x56), 
                PM6L,   2, 
                    ,   2, 
                PM6H,   2, 
                        Offset (0x57), 
                    ,   7, 
                HENA,   1, 
                        Offset (0x5C), 
                    ,   3, 
                TOUD,   5
            }

            Name (BUF0, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x00FF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0100,             // Length
                    ,, )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0x00000CF7,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000CF8,         // Length
                    ,, , TypeStatic)
                IO (Decode16,
                    0x0CF8,             // Range Minimum
                    0x0CF8,             // Range Maximum
                    0x01,               // Alignment
                    0x08,               // Length
                    )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000D00,         // Range Minimum
                    0x0000FFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x0000F300,         // 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
                    0x000C0000,         // Range Minimum
                    0x000C3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C4000,         // Range Minimum
                    0x000C7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C8000,         // Range Minimum
                    0x000CBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000CC000,         // Range Minimum
                    0x000CFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D0000,         // Range Minimum
                    0x000D3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D4000,         // Range Minimum
                    0x000D7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D8000,         // Range Minimum
                    0x000DBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000DC000,         // Range Minimum
                    0x000DFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E0000,         // Range Minimum
                    0x000E3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E4000,         // Range Minimum
                    0x000E7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E8000,         // Range Minimum
                    0x000EBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000EC000,         // Range Minimum
                    0x000EFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000F0000,         // Range Minimum
                    0x000FFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00010000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0xFEBFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0xFED40000,         // Range Minimum
                    0xFED44FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00005000,         // Length
                    ,, , AddressRangeMemory, TypeStatic)
            })
            Method (_CRS, 0, Serialized)
            {
                If (PM1L)
                {
                    CreateDWordField (BUF0, 0x7C, C0LN)
                    Store (Zero, C0LN)
                }

                If (LEqual (PM1L, 0x01))
                {
                    CreateBitField (BUF0, 0x0358, C0RW)
                    Store (Zero, C0RW)
                }

                If (PM1H)
                {
                    CreateDWordField (BUF0, 0x96, C4LN)
                    Store (Zero, C4LN)
                }

                If (LEqual (PM1H, 0x01))
                {
                    CreateBitField (BUF0, 0x0428, C4RW)
                    Store (Zero, C4RW)
                }

                If (PM2L)
                {
                    CreateDWordField (BUF0, 0xB0, C8LN)
                    Store (Zero, C8LN)
                }

                If (LEqual (PM2L, 0x01))
                {
                    CreateBitField (BUF0, 0x04F8, C8RW)
                    Store (Zero, C8RW)
                }

                If (PM2H)
                {
                    CreateDWordField (BUF0, 0xCA, CCLN)
                    Store (Zero, CCLN)
                }

                If (LEqual (PM2H, 0x01))
                {
                    CreateBitField (BUF0, 0x05C8, CCRW)
                    Store (Zero, CCRW)
                }

                If (PM3L)
                {
                    CreateDWordField (BUF0, 0xE4, D0LN)
                    Store (Zero, D0LN)
                }

                If (LEqual (PM3L, 0x01))
                {
                    CreateBitField (BUF0, 0x0698, D0RW)
                    Store (Zero, D0RW)
                }

                If (PM3H)
                {
                    CreateDWordField (BUF0, 0xFE, D4LN)
                    Store (Zero, D4LN)
                }

                If (LEqual (PM3H, 0x01))
                {
                    CreateBitField (BUF0, 0x0768, D4RW)
                    Store (Zero, D4RW)
                }

                If (PM4L)
                {
                    CreateDWordField (BUF0, 0x0118, D8LN)
                    Store (Zero, D8LN)
                }

                If (LEqual (PM4L, 0x01))
                {
                    CreateBitField (BUF0, 0x0838, D8RW)
                    Store (Zero, D8RW)
                }

                If (PM4H)
                {
                    CreateDWordField (BUF0, 0x0132, DCLN)
                    Store (Zero, DCLN)
                }

                If (LEqual (PM4H, 0x01))
                {
                    CreateBitField (BUF0, 0x0908, DCRW)
                    Store (Zero, DCRW)
                }

                If (PM5L)
                {
                    CreateDWordField (BUF0, 0x014C, E0LN)
                    Store (Zero, E0LN)
                }

                If (LEqual (PM5L, 0x01))
                {
                    CreateBitField (BUF0, 0x09D8, E0RW)
                    Store (Zero, E0RW)
                }

                If (PM5H)
                {
                    CreateDWordField (BUF0, 0x0166, E4LN)
                    Store (Zero, E4LN)
                }

                If (LEqual (PM5H, 0x01))
                {
                    CreateBitField (BUF0, 0x0AA8, E4RW)
                    Store (Zero, E4RW)
                }

                If (PM6L)
                {
                    CreateDWordField (BUF0, 0x0180, E8LN)
                    Store (Zero, E8LN)
                }

                If (LEqual (PM6L, 0x01))
                {
                    CreateBitField (BUF0, 0x0B78, E8RW)
                    Store (Zero, E8RW)
                }

                If (PM6H)
                {
                    CreateDWordField (BUF0, 0x019A, ECLN)
                    Store (Zero, ECLN)
                }

                If (LEqual (PM6H, 0x01))
                {
                    CreateBitField (BUF0, 0x0C48, ECRW)
                    Store (Zero, ECRW)
                }

                If (PM0H)
                {
                    CreateDWordField (BUF0, 0x01B4, F0LN)
                    Store (Zero, F0LN)
                }

                If (LEqual (PM0H, 0x01))
                {
                    CreateBitField (BUF0, 0x0D18, F0RW)
                    Store (Zero, F0RW)
                }

                CreateDWordField (BUF0, 0x01C2, M1MN)
                CreateDWordField (BUF0, 0x01C6, M1MX)
                CreateDWordField (BUF0, 0x01CE, M1LN)
                ShiftLeft (TOUD, 0x1B, M1MN)
                Add (Subtract (M1MX, M1MN), 0x01, M1LN)
                CreateDWordField (BUF0, 0x01DC, TPMN)
                CreateDWordField (BUF0, 0x01E0, TPMX)
                CreateDWordField (BUF0, 0x01E8, TPML)
                If (LNotEqual (TPMF, 0x02))
                {
                    Store (Zero, TPMN)
                    Store (Zero, TPMX)
                    Store (Zero, TPML)
                }

                Return (BUF0)
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (GPIC)
                {
                    Return (Package (0x10)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            0x00, 
                            0x10
                        }, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            0x00, 
                            0x13
                        }
                    })
                }
                Else
                {
                    Return (Package (0x10)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x0002FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x0007FFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001BFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKB, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKG, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKF, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x02, 
                            \_SB.PCI0.LPCB.LNKE, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKH, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKE, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x02, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKG, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKE, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }
                    })
                }
            }

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

                Name (RSRC, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0010,             // Range Minimum
                        0x0010,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x0024,             // Range Minimum
                        0x0024,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0028,             // Range Minimum
                        0x0028,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x002C,             // Range Minimum
                        0x002C,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x002E,             // Range Minimum
                        0x002E,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0030,             // Range Minimum
                        0x0030,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0034,             // Range Minimum
                        0x0034,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0038,             // Range Minimum
                        0x0038,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x003C,             // Range Minimum
                        0x003C,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0050,             // Range Minimum
                        0x0050,             // Range Maximum
                        0x01,               // Alignment
                        0x04,               // Length
                        )
                    IO (Decode16,
                        0x0072,             // Range Minimum
                        0x0072,             // Range Maximum
                        0x01,               // Alignment
                        0x06,               // Length
                        )
                    IO (Decode16,
                        0x0080,             // Range Minimum
                        0x0080,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                    IO (Decode16,
                        0x0090,             // Range Minimum
                        0x0090,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x00A4,             // Range Minimum
                        0x00A4,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00A8,             // Range Minimum
                        0x00A8,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00AC,             // Range Minimum
                        0x00AC,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00B0,             // Range Minimum
                        0x00B0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00B2,             // Range Minimum
                        0x00B2,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00B4,             // Range Minimum
                        0x00B4,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00B8,             // Range Minimum
                        0x00B8,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00BC,             // Range Minimum
                        0x00BC,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x04D0,             // Range Minimum
                        0x04D0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0800,             // Range Minimum
                        0x0800,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x1000,             // Range Minimum
                        0x1000,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0x1080,             // Range Minimum
                        0x1080,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0x1100,             // Range Minimum
                        0x1100,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                    IO (Decode16,
                        0x1180,             // Range Minimum
                        0x1180,             // Range Maximum
                        0x01,               // Alignment
                        0x40,               // Length
                        )
                    IO (Decode16,
                        0xF800,             // Range Minimum
                        0xF800,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0xF880,             // Range Minimum
                        0xF880,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0xFC00,             // Range Minimum
                        0xFC00,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0xFC80,             // Range Minimum
                        0xFC80,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0xFD0C,             // Range Minimum
                        0xFD0C,             // Range Maximum
                        0x01,               // Alignment
                        0x74,               // Length
                        )
                    IO (Decode16,
                        0xFE00,             // Range Minimum
                        0xFE00,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xF8000000,         // Address Base
                        0x04000000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED14000,         // Address Base
                        0x00004000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED18000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED19000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED1C000,         // Address Base
                        0x00004000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED20000,         // Address Base
                        0x00020000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED45000,         // Address Base
                        0x0004B000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEC00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEE00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEF00000,         // Address Base
                        0x00100000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x000CF000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFFB00000,         // Address Base
                        0x00100000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED40000,         // Address Base
                        0x00005000,         // Address Length
                        )
                })
                Method (_CRS, 0, Serialized)
                {
                    CreateDWordField (RSRC, 0x0184, MBBS)
                    CreateDWordField (RSRC, 0x0188, MBLN)
                    CreateDWordField (RSRC, 0x0190, FWBS)
                    CreateDWordField (RSRC, 0x0194, FWLN)
                    CreateDWordField (RSRC, 0x019C, TPMB)
                    CreateDWordField (RSRC, 0x01A0, TPML)
                    Store (UMST, MBBS)
                    Store (UMSZ, MBLN)
                    If (FWHM)
                    {
                        Store (Zero, FWBS)
                        Store (Zero, FWLN)
                    }

                    If (LEqual (TPMF, 0x02))
                    {
                        Store (Zero, TPMB)
                        Store (Zero, TPML)
                    }

                    Return (RSRC)
                }
            }

            Device (GFX0)
            {
                Name (_ADR, 0x00020000)
                Method (XLCD, 0, NotSerialized)
                {
                    Return (One)
                }

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

                Method (XTV, 0, NotSerialized)
                {
                    Return (XOr (SOUT, One))
                }

                Method (XDVI, 0, NotSerialized)
                {
                    Return (BY2O)
                }

                Scope (\)
                {
                    Name (WLCD, Zero)
                    Name (WCRT, Zero)
                    Name (WTV, Zero)
                    Name (WDVI, Zero)
                }

                Method (PHTK, 0, NotSerialized)
                {
                    Store (Zero, DSWF)
                }

                Name (F10T, Package (0x0A)
                {
                    0x01, 
                    0x02, 
                    0x03, 
                    0x04, 
                    0x05, 
                    0x01, 
                    0x02, 
                    0x03, 
                    0x04, 
                    0x05
                })
                Method (AHTK, 0, NotSerialized)
                {
                    If (LAnd (LEqual (And (ADOS, 0x03), Zero), DSWF))
                    {
                        UPDD ()
                        If (LEqual (DSWF, 0x01))
                        {
                            Or (ShiftLeft (CDVI, 0x02), Or (ShiftLeft (CCRT, 0x01), 
                                CLCD), Local0)
                            Or (ShiftLeft (ADVI, 0x02), Or (ShiftLeft (ACRT, 0x01), 
                                ALCD), Local1)
                            Store (Zero, Local2)
                            Store (0xFF, Local3)
                            While (LAnd (LLess (Local2, 0x0A), LEqual (Local3, 0xFF)))
                            {
                                If (LEqual (DerefOf (Index (F10T, Local2)), Local0))
                                {
                                    If (LAnd (CTV, ATV))
                                    {
                                        Store (Local2, Local3)
                                    }
                                    Else
                                    {
                                        Add (Local2, 0x01, Local3)
                                    }
                                }

                                Increment (Local2)
                            }

                            Store (0xFF, Local2)
                            If (LNotEqual (Local3, 0xFF))
                            {
                                While (LAnd (LLess (Local3, 0x0A), LEqual (Local2, 0xFF)))
                                {
                                    If (LEqual (And (DerefOf (Index (F10T, Local3)), Local1), 
                                        DerefOf (Index (F10T, Local3))))
                                    {
                                        Store (DerefOf (Index (F10T, Local3)), Local2)
                                    }

                                    Increment (Local3)
                                }
                            }

                            If (LEqual (Local2, 0xFF))
                            {
                                If (ALCD)
                                {
                                    Store (0x01, Local2)
                                }
                                Else
                                {
                                    If (ACRT)
                                    {
                                        Store (0x02, Local2)
                                    }
                                    Else
                                    {
                                        If (ADVI)
                                        {
                                            Store (0x04, Local2)
                                        }
                                        Else
                                        {
                                            Store (0x02, Local2)
                                        }
                                    }
                                }
                            }

                            And (Local2, 0x01, WLCD)
                            ShiftRight (And (Local2, 0x02), 0x01, WCRT)
                            ShiftRight (And (Local2, 0x04), 0x02, WDVI)
                            Store (Zero, WTV)
                            Notify (\_SB.PCI0.GFX0, 0x80)
                        }
                        Else
                        {
                            If (LEqual (DSWF, 0x02))
                            {
                                And (CLCD, ALCD, WLCD)
                                And (CCRT, ACRT, WCRT)
                                And (CDVI, ADVI, WDVI)
                                And (XOr (CTV, 0x01), ATV, WTV)
                                If (LOr (LOr (WTV, WDVI), LOr (WCRT, WLCD)))
                                {
                                    If (LAnd (LAnd (WLCD, WCRT), WTV))
                                    {
                                        Store (Zero, WCRT)
                                    }

                                    If (LAnd (LAnd (WLCD, WDVI), WTV))
                                    {
                                        Store (Zero, WDVI)
                                    }

                                    If (LAnd (LAnd (WCRT, WDVI), WTV))
                                    {
                                        Store (Zero, WDVI)
                                    }

                                    Notify (\_SB.PCI0.GFX0, 0x80)
                                }
                            }
                        }
                    }
                }

                Method (UPDD, 0, NotSerialized)
                {
                    If (LGreaterEqual (\_SB.OSTP (), 0x08))
                    {
                        Notify (\_SB.PCI0, 0x00)
                    }
                    Else
                    {
                        Notify (\_SB.PCI0.GFX0, 0x00)
                    }

                    Sleep (0x02EE)
                    Store (0xFF, DVID)
                    Store (0x8E, CMD)
                    Store (Zero, SSMI)
                }

                Method (_DOS, 1, NotSerialized)
                {
                    And (Arg0, 0x07, ADOS)
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Return (Package (0x04)
                    {
                        0x00010100, 
                        0x00010400, 
                        0x00010200, 
                        0x00010300
                    })
                }

                Device (CRT)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0100)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        If (XCRT ())
                        {
                            UPDD ()
                            Return (Or (0x0D, Or (ShiftLeft (ACRT, 0x04), ShiftLeft (CCRT, 
                                0x01))))
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Return (WCRT)
                    }

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

                Device (LCD)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0400)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        If (XLCD ())
                        {
                            UPDD ()
                            Return (Or (0x0D, Or (ShiftLeft (ALCD, 0x04), ShiftLeft (CLCD, 
                                0x01))))
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Return (WLCD)
                    }

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

                Device (TV)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0200)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        If (XTV ())
                        {
                            UPDD ()
                            Return (Or (0x0D, Or (ShiftLeft (ATV, 0x04), ShiftLeft (CTV, 
                                0x01))))
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Return (WTV)
                    }

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

                Device (DVI)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0300)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        If (XDVI ())
                        {
                            UPDD ()
                            Return (Or (0x0D, Or (ShiftLeft (ADVI, 0x04), ShiftLeft (CDVI, 
                                0x01))))
                        }
                        Else
                        {
                            Return (Zero)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Return (WDVI)
                    }

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

                Scope (LCD)
                {
                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, LIDS)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (0x01, LIDS)
                    }
                }
            }

            Device (PCIB)
            {
                Name (_ADR, 0x001E0000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (GPIC)
                    {
                        Return (Package (0x02)
                        {
                            Package (0x04)
                            {
                                0x0003FFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0x0006FFFF, 
                                0x00, 
                                0x00, 
                                0x11
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x02)
                        {
                            Package (0x04)
                            {
                                0x0003FFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0006FFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }
                        })
                    }
                }

                Method (_INI, 0, NotSerialized)
                {
                }

                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x04
                })
            }

            Device (LPCB)
            {
                Name (_ADR, 0x001F0000)
                OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)
                Field (LPC0, AnyAcc, NoLock, Preserve)
                {
                            Offset (0x20), 
                    PARC,   8, 
                    PBRC,   8, 
                    PCRC,   8, 
                    PDRC,   8, 
                            Offset (0x28), 
                    PERC,   8, 
                    PFRC,   8, 
                    PGRC,   8, 
                    PHRC,   8, 
                            Offset (0x40), 
                    IOD0,   8, 
                    IOD1,   8, 
                            Offset (0x60), 
                        ,   2, 
                    CLKR,   1
                }

                OperationRegion (SIO, SystemIO, 0x2E, 0x02)
                OperationRegion (FJIO, SystemIO, 0xFD60, 0x15)
                Scope (\)
                {
                    Field (\_SB.PCI0.LPCB.FJIO, ByteAcc, NoLock, Preserve)
                    {
                        AIDC,   8, 
                        ADTC,   8, 
                        AIDB,   8, 
                        ADTB,   8, 
                        AIDA,   8, 
                        ADTA,   8, 
                        AIDD,   8, 
                        ADTD,   8, 
                                Offset (0x10), 
                        PMID,   8, 
                                Offset (0x14), 
                        PMDT,   8
                    }
                }

                OperationRegion (PMIO, SystemIO, 0x1000, 0x80)
                OperationRegion (OGIO, SystemIO, 0x1180, 0x3C)
                Scope (\)
                {
                    Field (\_SB.PCI0.LPCB.PMIO, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x42), 
                            ,   1, 
                        GPEC,   1
                    }

                    Field (\_SB.PCI0.LPCB.OGIO, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x2C), 
                                Offset (0x2D), 
                        LPOL,   1, 
                            ,   4, 
                        EXPL,   1, 
                                Offset (0x38), 
                            ,   1, 
                        PXRS,   1, 
                        PXCL,   1
                    }
                }

                OperationRegion (OPIO, SystemIO, 0x1000, 0x67)
                Scope (\)
                {
                    Field (\_SB.PCI0.LPCB.OPIO, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x10), 
                                Offset (0x11), 
                        FOCT,   1
                    }
                }

                Method (_INI, 0, NotSerialized)
                {
                    \_SB.OSTP ()
                    \_SB.PCI0.LPCB.CMBT.SWCF ()
                    AINI ()
                    PRCF ()
                    If (RRCP)
                    {
                        Store (One, RPEN)
                        Store (B2TC, RPDS)
                    }
                }

                Scope (\)
                {
                    IndexField (AIDA, ADTA, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x09), 
                        RI1M,   1, 
                        RI2M,   1, 
                        RI3M,   1, 
                        RI4M,   1, 
                        RI1,    1, 
                        RI2,    1, 
                        RI3,    1, 
                        RI4,    1, 
                            ,   2, 
                        CVCL,   1, 
                            ,   3, 
                        BLCT,   2, 
                                Offset (0x20), 
                        G5P0,   8, 
                        G5C0,   8, 
                        G3P0,   8, 
                        G3C0,   8, 
                                Offset (0x40), 
                        SSF0,   8, 
                        SSF1,   8, 
                        SSM0,   8, 
                        SSM1,   8, 
                        SSI0,   8, 
                        SSTM,   8, 
                        SSF2,   8, 
                        SSM2,   8, 
                        SSI1,   8, 
                                Offset (0x52), 
                        G3P1,   8, 
                        G3C1,   8, 
                        G3P2,   8, 
                        G3C2,   8, 
                        QSWC,   8, 
                                Offset (0x60), 
                        SSS0,   8, 
                        SSS1,   8
                    }

                    IndexField (AIDB, ADTB, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x29), 
                        BRCL,   8, 
                        LCDB,   8, 
                                Offset (0x30), 
                        LCDC,   8
                    }

                    IndexField (AIDC, ADTC, ByteAcc, NoLock, Preserve)
                    {
                        TASF,   1, 
                        TBSF,   1, 
                        B1SU,   1, 
                        B1SD,   1, 
                        B2SU,   1, 
                        B2SD,   1, 
                                Offset (0x02), 
                            ,   4, 
                        VSTB,   1, 
                                Offset (0x05), 
                            ,   6, 
                        ACPW,   1, 
                                Offset (0x20), 
                        BCTL,   8, 
                                Offset (0x23), 
                        TAF,    1, 
                        TASM,   1, 
                            ,   2, 
                        TBF,    1, 
                        TBSM,   1, 
                                Offset (0x24), 
                        TIMA,   8, 
                        TIMB,   8, 
                                Offset (0x28), 
                        CDLP,   8, 
                        HDLP,   8, 
                        FDLP,   8, 
                                Offset (0x4E), 
                        B1UM,   1, 
                        B1DM,   1, 
                            ,   1, 
                        B1TC,   1, 
                        B2UM,   1, 
                        B2DM,   1, 
                            ,   1, 
                        B2TC,   1, 
                        BAPC,   6
                    }

                    IndexField (AIDC, ADTC, ByteAcc, NoLock, Preserve)
                    {
                        STAE,   8
                    }

                    IndexField (AIDD, ADTD, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x80), 
                        GIDI,   8, 
                        GIDC,   8, 
                        GIDO,   8, 
                                Offset (0x90), 
                        G3SI,   8, 
                        G3SC,   8, 
                        G3SO,   8, 
                        G3SM,   8, 
                                Offset (0xA0), 
                        WOXF,   8, 
                        WOXE,   8, 
                        WOXD,   8, 
                        WOXS,   8, 
                                Offset (0xB0), 
                        AMPV,   6
                    }
                }

                Scope (\)
                {
                    IndexField (PMID, PMDT, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0xA0), 
                        UPPR,   1, 
                        ERRO,   1, 
                        PASS,   1, 
                        PSOK,   1, 
                        PSNG,   1, 
                        TOUT,   1, 
                        SIRN,   1, 
                        STSC,   1, 
                        OVFL,   1, 
                        LWMD,   1, 
                        TALM,   1, 
                        EMGC,   1, 
                        OCNT,   4, 
                        TDTC,   1, 
                            ,   4, 
                        AERR,   1, 
                        PERR,   1, 
                        ABSY,   1, 
                                Offset (0xA4), 
                        PDAT,   8, 
                                Offset (0xC0), 
                                Offset (0xC1), 
                        B1P,    1, 
                        B2P,    1, 
                        B1C,    1, 
                        B2C,    1, 
                        B1ER,   1, 
                        B2ER,   1, 
                        PKSH,   1, 
                        CMB,    1, 
                        B1CP,   8, 
                        B2CP,   8, 
                        BAVG,   8, 
                        B1VH,   8, 
                        B1VL,   8, 
                        B2VH,   8, 
                        B2VL,   8, 
                        B1TM,   8, 
                        B2TM,   8, 
                        B1CH,   8, 
                        B1CL,   8, 
                        B2CH,   8, 
                        B2CL,   8, 
                        BTMH,   8, 
                        BTML,   8, 
                        B1LH,   8, 
                        B1LL,   8, 
                        B2LH,   8, 
                        B2LL,   8, 
                        B1ID,   4, 
                        B1NO,   4, 
                        B2ID,   4, 
                        B2NO,   4, 
                        B1DV,   8, 
                        B2DV,   8, 
                        B1DH,   8, 
                        B1DL,   8, 
                        B2DH,   8, 
                        B2DL,   8, 
                        TBSI,   8, 
                        TBSH,   8, 
                        TBSL,   8, 
                        BHDD,   1, 
                        BOPT,   1, 
                            ,   5, 
                        ABLC,   1, 
                                Offset (0xE8), 
                        TBCM,   8, 
                        TBMD,   8, 
                        TBIN,   8, 
                        DCOL,   7, 
                        S3EN,   1
                    }

                    IndexField (PMID, PMDT, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0xA2), 
                        TCST,   8
                    }
                }

                Scope (\)
                {
                    IndexField (AIDA, ADTA, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x22), 
                            ,   4, 
                        SOUT,   1, 
                                Offset (0x52), 
                        BRST,   1, 
                            ,   1, 
                        BY1C,   2
                    }

                    IndexField (AIDC, ADTC, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x4F), 
                        BY1O,   1, 
                        BY2O,   1
                    }

                    IndexField (AIDD, ADTD, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x80), 
                        BY1I,   4
                    }
                }

                Method (AINI, 0, NotSerialized)
                {
                    And (SSM1, 0xCF, SSM1)
                    Store (0x01, TBSM)
                    Store (0x00, TBSF)
                    Store (0x0A, TIMB)
                    Store (LWMD, PLWM)
                    Store (TALM, PTAL)
                    Store (0x95, CMD)
                    Or (PLWM, ShiftLeft (PTAL, 0x01), DVID)
                    Store (Zero, SSMI)
                    If (LAnd (TALM, LNot (ACPW)))
                    {
                        Store (One, FOCT)
                    }
                    Else
                    {
                        Store (Zero, FOCT)
                    }

                    If (LGreaterEqual (\_SB.OSTP (), 0x40))
                    {
                        If (AS34)
                        {
                            Store (0x01, S3EN)
                        }

                        If (LEqual (DCLW, 0x7F))
                        {
                            Store (0x08, DCOL)
                        }
                        Else
                        {
                            Store (DCLW, DCOL)
                        }
                    }

                    Store (Zero, THMC)
                }

                Device (TPM)
                {
                    Name (_HID, EisaId ("IFX0102"))
                    Name (_CID, EisaId ("PNP0C31"))
                    Name (_UID, 0x01)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x004E,             // Range Minimum
                            0x004E,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0xFD00,             // Range Minimum
                            0xFD00,             // Range Maximum
                            0x01,               // Alignment
                            0x0C,               // Length
                            )
                        Memory32Fixed (ReadWrite,
                            0xFED40000,         // Address Base
                            0x00005000,         // Address Length
                            )
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (TPMF)
                        {
                            If (LEqual (TPMF, 0x02))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                }

                Name (RGSI, 0x19)
                Device (FJEX)
                {
                    Name (_HID, "FUJ02B1")
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (RBLL, 0, NotSerialized)
                    {
                        Return (BLLM)
                    }

                    Scope (\)
                    {
                        Name (LBLL, 0x00)
                        Name (LLCD, Ones)
                    }

                    Method (GBLL, 0, NotSerialized)
                    {
                        Store (LBLL, Local2)
                        Store (LCDB, Local1)
                        If (LNotEqual (LLCD, Local1))
                        {
                            Store (Local1, LLCD)
                            Name (BBCT, Buffer (BLLM) {})
                            Store (BLLT, BBCT)
                            Store (BLLM, Local0)
                            While (Local0)
                            {
                                Decrement (Local0)
                                If (LEqual (GBUF (BBCT, Local0), Local1))
                                {
                                    Store (Local0, Local2)
                                    Store (Local0, LBLL)
                                    Store (Zero, Local0)
                                }
                            }
                        }

                        If (BHKF)
                        {
                            Store (Zero, BHKF)
                            Or (Local2, 0x80000000, Local2)
                        }

                        Return (Local2)
                    }

                    Method (GBLS, 0, NotSerialized)
                    {
                        Store (LBLL, Local2)
                        Store (LCDB, Local1)
                        If (LNotEqual (LLCD, Local1))
                        {
                            Store (Local1, LLCD)
                            Name (BBCT, Buffer (BLLM) {})
                            Store (BLLT, BBCT)
                            Store (BLLM, Local0)
                            While (Local0)
                            {
                                Decrement (Local0)
                                If (LEqual (GBUF (BBCT, Local0), Local1))
                                {
                                    Store (Local0, Local2)
                                    Store (Local0, LBLL)
                                    Store (Zero, Local0)
                                }
                            }
                        }

                        If (BHKF)
                        {
                            Or (Local2, 0x80000000, Local2)
                        }

                        Return (Local2)
                    }

                    Method (SBLL, 1, NotSerialized)
                    {
                        If (NGTF)
                        {
                            Store (Arg0, LSBL)
                            Return (Zero)
                        }

                        If (LLess (Arg0, BLLM))
                        {
                            Name (BBCT, Buffer (BLLM) {})
                            Store (BLLT, BBCT)
                            CreateByteField (BBCT, Arg0, BLL0)
                            Store (BLL0, LCDB)
                            Store (Arg0, DVID)
                            Store (0x82, CMD)
                            Store (Zero, SSMI)
                        }
                    }

                    Method (GBUF, 2, NotSerialized)
                    {
                        CreateByteField (Arg0, Arg1, BLL0)
                        Return (BLL0)
                    }

                    Method (GMOU, 0, NotSerialized)
                    {
                        Store (0x02, DVID)
                        Store (0x91, CMD)
                        Store (Zero, SSMI)
                        Store (DVID, Local0)
                        If (MHKF)
                        {
                            Store (Zero, MHKF)
                            Or (Local0, 0x80000000, Local0)
                        }

                        Return (Local0)
                    }

                    Method (SMOU, 1, NotSerialized)
                    {
                        If (LLessEqual (Arg0, One))
                        {
                            Store (Arg0, DVID)
                            Store (0x91, CMD)
                            Store (Zero, SSMI)
                        }
                    }

                    Method (GHKS, 0, NotSerialized)
                    {
                        If (INTV)
                        {
                            ShiftLeft (VLBF, 0x04, Local0)
                            Store (Zero, VLBF)
                            Return (Or (Local0, AHKF))
                        }
                        Else
                        {
                            Return (AHKF)
                        }
                    }

                    Method (GSIF, 0, NotSerialized)
                    {
                        If (IMTF)
                        {
                            Or (RGSI, 0x08, RGSI)
                        }
                        Else
                        {
                            And (RGSI, 0xFFFFFFF7, RGSI)
                        }

                        If (INTV)
                        {
                            And (RGSI, 0xFFFFFFD1, RGSI)
                            Or (RGSI, 0x41, RGSI)
                        }

                        Return (RGSI)
                    }
                }

                Name (BTF1, 0x9A)
                Name (BTF2, 0x98)
                Scope (\)
                {
                    Name (BTBL, Zero)
                    Name (BTST, Zero)
                    IndexField (AIDA, ADTA, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x20), 
                            ,   5, 
                        ABEX,   1, 
                                Offset (0x44), 
                            ,   2, 
                        WLSW,   1
                    }

                    IndexField (AIDD, ADTD, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0x92), 
                            ,   2, 
                        WLRF,   1, 
                        ABON,   1
                    }
                }

                Device (CMBT)
                {
                    Name (_HID, "FUJ02E1")
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LGreaterEqual (\_SB.OSTP (), 0x40))
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            If (LNot (BTEX))
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                If (BLEN)
                                {
                                    Return (0x0F)
                                }
                                Else
                                {
                                    Return (0x0D)
                                }
                            }
                        }
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        Store (Zero, BTBL)
                    }

                    Method (INFO, 0, NotSerialized)
                    {
                        If (LEqual (_STA (), 0x0F))
                        {
                            Store (BTF1, Local0)
                        }
                        Else
                        {
                            Store (BTF2, Local0)
                        }

                        Or (Local0, 0x08, Local0)
                        Return (Local0)
                    }

                    Method (STAT, 0, NotSerialized)
                    {
                        Store (0x00, Local0)
                        If (ABON)
                        {
                            Or (Local0, 0x02, Local0)
                        }

                        If (WLRF)
                        {
                            Or (Local0, 0x08, Local0)
                        }

                        If (ABON)
                        {
                            Or (Local0, 0x10, Local0)
                        }

                        If (BTBL)
                        {
                            Or (Local0, 0x80, Local0)
                        }

                        Return (Local0)
                    }

                    Method (CNTL, 2, NotSerialized)
                    {
                        If (And (Arg0, 0x02))
                        {
                            If (LEqual (_STA (), 0x0F))
                            {
                                If (And (Arg1, 0x02))
                                {
                                    Store (One, ABON)
                                }
                                Else
                                {
                                    Store (Zero, ABON)
                                }
                            }
                        }

                        If (LAnd (And (Arg0, 0x08), WLEN))
                        {
                            ShiftRight (And (Arg1, 0x08), 0x03, WLRF)
                        }

                        If (And (Arg0, 0x80))
                        {
                            ShiftRight (And (Arg1, 0x80), 0x07, BTBL)
                            If (BTBL)
                            {
                                If (WLSW)
                                {
                                    Notify (CMBT, 0x81)
                                }
                                Else
                                {
                                    Notify (CMBT, 0x82)
                                }
                            }
                        }
                    }

                    Method (SWCF, 0, NotSerialized)
                    {
                        If (BTBL)
                        {
                            If (WLSW)
                            {
                                Notify (CMBT, 0x81)
                            }
                            Else
                            {
                                Notify (CMBT, 0x82)
                            }
                        }
                        Else
                        {
                            If (WLSW)
                            {
                                If (BLEN)
                                {
                                    Store (One, ABON)
                                    Store (One, ABLC)
                                    If (WLEN)
                                    {
                                        Store (One, WLRF)
                                    }
                                    Else
                                    {
                                        Store (Zero, WLRF)
                                    }
                                }
                                Else
                                {
                                    Store (Zero, ABON)
                                    If (WLEN)
                                    {
                                        Store (One, WLRF)
                                        Store (One, ABLC)
                                    }
                                    Else
                                    {
                                        Store (Zero, WLRF)
                                        Store (Zero, ABLC)
                                    }
                                }
                            }
                            Else
                            {
                                Store (Zero, ABON)
                                Store (Zero, WLRF)
                                Store (Zero, ABLC)
                            }
                        }
                    }

                    Method (BPTS, 1, NotSerialized)
                    {
                        If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04)))
                        {
                            Store (WLRF, BTST)
                            Or (ShiftLeft (WLSW, 0x01), BTST, BTST)
                            Or (ShiftLeft (ABON, 0x02), BTST, BTST)
                        }

                        Store (Zero, ABLC)
                        Store (Zero, ABON)
                    }

                    Method (BWAK, 1, NotSerialized)
                    {
                        If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04)))
                        {
                            Store (And (BTST, 0x01), WLRF)
                            ShiftRight (And (BTST, 0x04), 0x02, ABON)
                            If (LAnd (WLSW, LOr (WLRF, ABON)))
                            {
                                Store (One, ABLC)
                            }

                            If (LNotEqual (ShiftRight (And (BTST, 0x02), 0x01), 
                                WLSW))
                            {
                                SWCF ()
                            }
                        }
                    }
                }

                Device (EC)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0062,             // Range Minimum
                            0x0062,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IO (Decode16,
                            0x0066,             // Range Minimum
                            0x0066,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                    })
                    Name (_GPE, 0x17)
                    Scope (\)
                    {
                        Name (ECOK, Zero)
                    }

                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, ECOK)
                        }
                    }

                    OperationRegion (SMB, EmbeddedControl, 0x00, 0xFF)
                    Scope (\)
                    {
                        Field (\_SB.PCI0.LPCB.EC.SMB, ByteAcc, Lock, Preserve)
                        {
                                    Offset (0x04), 
                            ECCM,   8, 
                            ECD1,   8, 
                            ECD2,   8, 
                            ECD3,   8, 
                                    Offset (0xE0), 
                            ECBM,   8, 
                            ECB1,   8, 
                            ECB2,   8, 
                            ECB3,   8, 
                            ECB4,   8, 
                            ECB5,   8, 
                            ECB6,   8, 
                            ECB7,   8, 
                            ECB8,   8, 
                            ECB9,   8, 
                            ECBA,   8, 
                            ECBB,   8, 
                                    Offset (0xF8), 
                            ECGM,   8, 
                            ECG1,   8, 
                            ECG2,   8, 
                            ECG3,   8
                        }
                    }
                }

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x10,               // Length
                            )
                        IO (Decode16,
                            0x0081,             // Range Minimum
                            0x0081,             // Range Maximum
                            0x01,               // Alignment
                            0x0F,               // Length
                            )
                        IO (Decode16,
                            0x00C0,             // Range Minimum
                            0x00C0,             // Range Maximum
                            0x01,               // Alignment
                            0x20,               // Length
                            )
                        DMA (Compatibility, NotBusMaster, Transfer16, )
                            {4}
                    })
                }

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0040,             // Range Minimum
                            0x0040,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {0}
                    })
                }

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0020,             // Range Minimum
                            0x0020,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IO (Decode16,
                            0x00A0,             // Range Minimum
                            0x00A0,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {2}
                    })
                }

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0070,             // Range Minimum
                            0x0070,             // Range Maximum
                            0x01,               // Alignment
                            0x02,               // Length
                            )
                        IRQNoFlags ()
                            {8}
                    })
                }

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0061,             // Range Minimum
                            0x0061,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                    })
                }

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x00F0,             // Range Minimum
                            0x00F0,             // Range Maximum
                            0x01,               // Alignment
                            0x0F,               // Length
                            )
                        IRQNoFlags ()
                            {13}
                    })
                }

                Device (KBC)
                {
                    Name (R101, 0x0303D041)
                    Name (R106, 0x2003D041)
                    Method (_HID, 0, NotSerialized)
                    {
                        If (SIDF)
                        {
                            Return (R101)
                        }
                        Else
                        {
                            Return (R106)
                        }
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

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

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

                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {12}
                    })
                }

                Device (FWH)
                {
                    Name (_HID, EisaId ("INT0800"))
                    Method (_STA, 0, NotSerialized)
                    {
                        If (FWHM)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite,
                            0xFFB00000,         // Address Base
                            0x00100000,         // Address Length
                            )
                    })
                }

                Device (HPET)
                {
                    Name (_HID, EisaId ("PNP0103"))
                    Name (_CID, EisaId ("PNP0C01"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly,
                            0xFED00000,         // Address Base
                            0x00000400,         // Address Length
                            )
                    })
                    OperationRegion (RCRB, SystemMemory, 0xFED1C000, 0x4000)
                    Field (RCRB, DWordAcc, Lock, Preserve)
                    {
                                Offset (0x3404), 
                        HPAS,   2, 
                            ,   5, 
                        HPAE,   1
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LGreaterEqual (\_SB.OSTP (), 0x08))
                        {
                            If (HPAE)
                            {
                                Return (0x0F)
                            }
                        }
                        Else
                        {
                            If (HPAE)
                            {
                                Return (0x0B)
                            }
                        }

                        Return (0x00)
                    }

                    Method (_CRS, 0, Serialized)
                    {
                        If (HPAE)
                        {
                            CreateDWordField (BUF0, 0x04, HPT0)
                            If (LEqual (HPAS, 0x01))
                            {
                                Store (0xFED01000, HPT0)
                            }

                            If (LEqual (HPAS, 0x02))
                            {
                                Store (0xFED02000, HPT0)
                            }

                            If (LEqual (HPAS, 0x03))
                            {
                                Store (0xFED03000, HPT0)
                            }
                        }

                        Return (BUF0)
                    }
                }

                Scope (\_SB.PCI0.LPCB)
                {
                    OperationRegion (LIOD, PCI_Config, 0x80, 0x0A)
                    OperationRegion (MBAR, SystemMemory, 0xFED14000, 0x4000)
                    Field (MBAR, DWordAcc, Lock, Preserve)
                    {
                                Offset (0xF08), 
                            ,   4, 
                        C2SL,   1
                    }
                }

                Field (LIOD, AnyAcc, NoLock, Preserve)
                {
                    CADR,   3, 
                        ,   1, 
                    CBDR,   3, 
                            Offset (0x01), 
                    LPDR,   2, 
                        ,   2, 
                    FDDR,   1, 
                            Offset (0x02), 
                    CALE,   1, 
                    CBLE,   1, 
                    LPLE,   1, 
                    FDLE,   1, 
                            Offset (0x08), 
                    GD2E,   1, 
                        ,   3, 
                    GD2B,   12
                }

                Name (TCOM, Package (0x08)
                {
                    0x03F8, 
                    0x02F8, 
                    0x0220, 
                    0x0228, 
                    0x0238, 
                    0x02E8, 
                    0x0338, 
                    0x03E8
                })
                Name (TLPT, Package (0x03)
                {
                    0x0378, 
                    0x0278, 
                    0x03BC
                })
                Name (TFDD, Package (0x02)
                {
                    0x03F0, 
                    0x0370
                })
                Method (DENA, 3, Serialized)
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Match (TCOM, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
                        If (LNotEqual (Local0, Ones))
                        {
                            Store (Local0, CADR)
                            Store (One, CALE)
                        }
                    }
                    Else
                    {
                        If (LOr (LEqual (Arg0, 0x01), LEqual (Arg0, 0x02)))
                        {
                            Store (Match (TCOM, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
                            If (LNotEqual (Local0, Ones))
                            {
                                Store (Local0, CBDR)
                                Store (One, CBLE)
                            }
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x03))
                            {
                                Store (Match (TCOM, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
                                If (LNotEqual (Local0, Ones))
                                {
                                    Store (Local0, CBDR)
                                    Store (One, CBLE)
                                    ShiftRight (Arg2, 0x04, GD2B)
                                    Store (One, GD2E)
                                }
                            }
                            Else
                            {
                                If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x05)))
                                {
                                    Store (Match (TLPT, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
                                    If (LNotEqual (Local0, Ones))
                                    {
                                        Store (Local0, LPDR)
                                        Store (One, LPLE)
                                    }
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x07))
                                    {
                                        Store (Match (TFDD, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
                                        If (LNotEqual (Local0, Ones))
                                        {
                                            Store (Local0, FDDR)
                                            Store (One, FDLE)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                Method (DDIS, 1, Serialized)
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Zero, CALE)
                    }
                    Else
                    {
                        If (LOr (LEqual (Arg0, 0x01), LEqual (Arg0, 0x02)))
                        {
                            Store (Zero, CBLE)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x03))
                            {
                                Store (Zero, CBLE)
                                Store (Zero, GD2E)
                            }
                            Else
                            {
                                If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x05)))
                                {
                                    Store (Zero, LPLE)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x07))
                                    {
                                        Store (Zero, FDLE)
                                    }
                                }
                            }
                        }
                    }
                }

                Field (SIO, ByteAcc, NoLock, Preserve)
                {
                    SIID,   8, 
                    SIDT,   8
                }

                IndexField (SIID, SIDT, ByteAcc, NoLock, Preserve)
                {
                        ,   3, 
                    FDCP,   1, 
                            Offset (0x01), 
                        ,   2, 
                    PPP,    1, 
                    PPM,    1, 
                            Offset (0x02), 
                        ,   3, 
                    U1P,    1, 
                        ,   3, 
                    U2P,    1, 
                            Offset (0x04), 
                    PPEM,   2, 
                            Offset (0x0A), 
                    EFTM,   8, 
                            Offset (0x0C), 
                    U2MD,   6, 
                            Offset (0x20), 
                    FDA,    8, 
                        ,   2, 
                    ETOS,   1, 
                            Offset (0x23), 
                    PPA,    8, 
                    U1A,    8, 
                    U2A,    8, 
                    PPD,    4, 
                    FDD,    4, 
                    PPI,    4, 
                    FDI,    4, 
                    U2I,    4, 
                    U1I,    4, 
                            Offset (0x2B), 
                    IRA,    8, 
                    IRD,    4
                }

                Mutex (MTXS, 0x00)
                Method (ENTR, 0, NotSerialized)
                {
                    Acquire (MTXS, 0xFFFF)
                    Store (0x55, SIID)
                }

                Method (EXIT, 0, NotSerialized)
                {
                    Store (0xAA, SIID)
                    Release (MTXS)
                }

                Method (SETR, 5, NotSerialized)
                {
                    ENTR ()
                    If (Arg3)
                    {
                        Subtract (FindSetRightBit (Arg3), One, Local0)
                    }
                    Else
                    {
                        Store (Zero, Local0)
                    }

                    If (Arg4)
                    {
                        Subtract (FindSetRightBit (Arg4), One, Local1)
                    }
                    Else
                    {
                        Store (0x0F, Local1)
                    }

                    If (LEqual (Arg0, 0x00))
                    {
                        ShiftRight (Arg1, 0x02, U1A)
                        Store (Local0, U1I)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            ShiftRight (Arg1, 0x02, U2A)
                            Store (Local0, U2I)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                ShiftRight (Arg1, 0x02, U2A)
                                Store (Local0, U2I)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    ShiftRight (Arg1, 0x02, U2A)
                                    ShiftRight (Arg2, 0x03, IRA)
                                    Store (Local0, U2I)
                                    Store (Local1, IRD)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        ShiftRight (Arg1, 0x02, PPA)
                                        Store (Local0, PPI)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            ShiftRight (Arg1, 0x02, PPA)
                                            Store (Local0, PPI)
                                            Store (Local1, PPD)
                                        }
                                        Else
                                        {
                                            If (LEqual (Arg0, 0x07))
                                            {
                                                ShiftRight (Arg1, 0x02, FDA)
                                                Store (Local0, FDI)
                                                Store (Local1, FDD)
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    EXIT ()
                    If (Arg1)
                    {
                        If (CondRefOf (DENA, Local0))
                        {
                            DENA (Arg0, Arg1, Arg2)
                        }

                        SETM (Arg0)
                    }
                    Else
                    {
                        If (CondRefOf (DDIS, Local0))
                        {
                            DDIS (Arg0)
                        }
                    }
                }

                Method (GETR, 5, NotSerialized)
                {
                    ENTR ()
                    Store (Zero, Local0)
                    Store (0x0F, Local1)
                    If (LEqual (Arg0, 0x00))
                    {
                        ShiftLeft (U1A, 0x02, Arg1)
                        Store (U1I, Local0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            ShiftLeft (U2A, 0x02, Arg1)
                            Store (U2I, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                ShiftLeft (U2A, 0x02, Arg1)
                                Store (U2I, Local0)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    ShiftLeft (U2A, 0x02, Arg1)
                                    ShiftLeft (IRA, 0x03, Arg2)
                                    Store (U2I, Local0)
                                    Store (IRD, Local1)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        ShiftLeft (PPA, 0x02, Arg1)
                                        Store (PPI, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            ShiftLeft (PPA, 0x02, Arg1)
                                            Store (PPI, Local0)
                                            Store (PPD, Local1)
                                        }
                                        Else
                                        {
                                            If (LEqual (Arg0, 0x07))
                                            {
                                                ShiftLeft (FDA, 0x02, Arg1)
                                                Store (FDI, Local0)
                                                Store (FDD, Local1)
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    If (Local0)
                    {
                        ShiftLeft (One, Local0, Arg3)
                    }
                    Else
                    {
                        Store (Zero, Arg3)
                    }

                    If (LNotEqual (Local1, 0x0F))
                    {
                        ShiftLeft (One, Local1, Arg4)
                    }
                    Else
                    {
                        Store (Zero, Arg4)
                    }

                    EXIT ()
                }

                Method (SETM, 1, NotSerialized)
                {
                    ENTR ()
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (One, U1P)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x06, U2MD)
                            Store (One, U2P)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (0x0E, U2MD)
                                Store (One, U2P)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    Store (0x0E, U2MD)
                                    Store (One, U2P)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        If (LEqual (PPF, One))
                                        {
                                            Store (One, PPM)
                                        }
                                        Else
                                        {
                                            Store (Zero, PPM)
                                            Store (Zero, PPEM)
                                        }

                                        Store (One, PPP)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            Store (Zero, PPM)
                                            Store (0x02, PPEM)
                                            Store (One, PPP)
                                        }
                                    }
                                }
                            }
                        }
                    }

                    EXIT ()
                }

                Method (SETP, 2, NotSerialized)
                {
                    ENTR ()
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Arg1, U1P)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (Arg1, U2P)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (Arg1, U2P)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    Store (Arg1, U2P)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        Store (Arg1, PPP)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            Store (Arg1, PPP)
                                        }
                                    }
                                }
                            }
                        }
                    }

                    EXIT ()
                }

                Method (GETP, 1, NotSerialized)
                {
                    Store (Zero, Local0)
                    ENTR ()
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (U1P, Local0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (U2P, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                Store (U2P, Local0)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    Store (U2P, Local0)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        Store (PPP, Local0)
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            Store (PPP, Local0)
                                        }
                                    }
                                }
                            }
                        }
                    }

                    EXIT ()
                    Return (Local0)
                }

                Method (CHKM, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        If (SPAF)
                        {
                            Return (One)
                        }
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            If (LEqual (SPBF, 0x03))
                            {
                                Return (One)
                            }
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x02))
                            {
                                If (LEqual (SPBF, One))
                                {
                                    Return (One)
                                }
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x03))
                                {
                                    If (LEqual (SPBF, 0x02))
                                    {
                                        Return (One)
                                    }
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x04))
                                    {
                                        If (LOr (LEqual (PPF, One), LEqual (PPF, 0x02)))
                                        {
                                            Return (One)
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x05))
                                        {
                                            If (LEqual (PPF, 0x03))
                                            {
                                                Return (One)
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (Arg0, 0x07))
                                            {
                                                If (FDCF)
                                                {
                                                    Return (One)
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    Return (Zero)
                }

                Device (UAR1)
                {
                    Name (_HID, EisaId ("PNP0501"))
                    Name (_UID, 0x01)
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {4}
                    })
                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                        }
                        EndDependentFn ()
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (CHKM (0x00))
                        {
                            GETR (0x00, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                            If (Local0)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x02, IO11)
                        CreateWordField (RSRC, 0x04, IO12)
                        CreateWordField (RSRC, 0x09, IRQ1)
                        GETR (0x00, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                        Store (Local0, IO11)
                        Store (Local0, IO12)
                        Store (Local2, IRQ1)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x04, IO11)
                        CreateWordField (Arg0, 0x09, IRQ1)
                        SETR (0x00, IO11, Zero, IRQ1, Zero)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        SETR (0x00, Zero, Zero, Zero, Zero)
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        If (CHKM (0x00))
                        {
                            SETM (0x00)
                        }
                    }
                }

                Device (IRDA)
                {
                    Name (_HID, EisaId ("PNP0510"))
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3}
                    })
                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                        }
                        EndDependentFn ()
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (CHKM (0x02))
                        {
                            GETR (0x02, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                            If (Local0)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x02, IO11)
                        CreateWordField (RSRC, 0x04, IO12)
                        CreateWordField (RSRC, 0x09, IRQ1)
                        GETR (0x02, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                        Store (Local0, IO11)
                        Store (Local0, IO12)
                        Store (Local2, IRQ1)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x04, IO11)
                        CreateWordField (Arg0, 0x09, IRQ1)
                        SETR (0x02, IO11, Zero, IRQ1, Zero)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        SETR (0x02, Zero, Zero, Zero, Zero)
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        If (CHKM (0x02))
                        {
                            SETM (0x02)
                        }
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        If (GETP (0x02))
                        {
                            Return (Zero)
                        }
                        Else
                        {
                            Return (0x03)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        SETP (0x02, One)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        SETR (0x02, Zero, Zero, Zero, Zero)
                        SETP (0x02, Zero)
                    }
                }

                Device (FIR)
                {
                    Name (_HID, EisaId ("SMCF010"))
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x06F8,             // Range Minimum
                            0x06F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    })
                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03F8,             // Range Minimum
                                0x03F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x07F8,             // Range Minimum
                                0x07F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16,
                                0x02F8,             // Range Minimum
                                0x02F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x06F8,             // Range Minimum
                                0x06F8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x03E8,             // Range Minimum
                                0x03E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x07E8,             // Range Minimum
                                0x07E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {4}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x02E8,             // Range Minimum
                                0x02E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x06E8,             // Range Minimum
                                0x06E8,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IRQNoFlags ()
                                {3}
                        }
                        EndDependentFn ()
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {1,3}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (CHKM (0x03))
                        {
                            GETR (0x03, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                            If (Local0)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x02, IO11)
                        CreateWordField (RSRC, 0x04, IO12)
                        CreateWordField (RSRC, 0x0A, IO21)
                        CreateWordField (RSRC, 0x0C, IO22)
                        CreateWordField (RSRC, 0x11, IRQ1)
                        CreateByteField (RSRC, 0x14, DMA1)
                        GETR (0x03, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                        Store (Local0, IO11)
                        Store (Local0, IO12)
                        Store (Local1, IO21)
                        Store (Local1, IO22)
                        Store (Local2, IRQ1)
                        Store (Local3, DMA1)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x04, IO11)
                        CreateWordField (Arg0, 0x0C, IO21)
                        CreateWordField (Arg0, 0x11, IRQ1)
                        CreateByteField (Arg0, 0x14, DMA1)
                        SETR (0x03, IO11, IO21, IRQ1, DMA1)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        SETR (0x03, Zero, Zero, Zero, Zero)
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        If (CHKM (0x03))
                        {
                            SETM (0x03)
                        }
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        If (GETP (0x03))
                        {
                            Return (Zero)
                        }
                        Else
                        {
                            Return (0x03)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        SETP (0x03, One)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        SETR (0x03, Zero, Zero, Zero, Zero)
                        SETP (0x03, Zero)
                    }
                }

                Device (LPT)
                {
                    Name (_HID, EisaId ("PNP0400"))
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {7}
                    })
                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0678,             // Range Minimum
                                0x0678,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                        }
                        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 ()
                                {7}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {5}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0678,             // Range Minimum
                                0x0678,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {5}
                        }
                        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 ()
                                {5}
                        }
                        EndDependentFn ()
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (CHKM (0x04))
                        {
                            GETR (0x04, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                            If (Local0)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x02, IO11)
                        CreateWordField (RSRC, 0x04, IO12)
                        CreateByteField (RSRC, 0x07, IO1L)
                        CreateWordField (RSRC, 0x0A, IO21)
                        CreateWordField (RSRC, 0x0C, IO22)
                        CreateWordField (RSRC, 0x11, IRQ1)
                        GETR (0x04, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                        Store (Local0, IO11)
                        Store (Local0, IO12)
                        If (LEqual (Local0, 0x03BC))
                        {
                            Store (0x04, IO1L)
                        }
                        Else
                        {
                            Store (0x08, IO1L)
                        }

                        Add (Local0, 0x0400, IO21)
                        Store (IO21, IO22)
                        Store (Local2, IRQ1)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x04, IO11)
                        CreateWordField (Arg0, 0x11, IRQ1)
                        SETR (0x04, IO11, Zero, IRQ1, Zero)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        SETR (0x04, Zero, Zero, Zero, Zero)
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        If (CHKM (0x04))
                        {
                            SETM (0x04)
                        }
                    }
                }

                Device (ECP)
                {
                    Name (_HID, EisaId ("PNP0401"))
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {7}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {}
                    })
                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0678,             // Range Minimum
                                0x0678,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {7}
                        }
                        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 ()
                                {7}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16,
                                0x0378,             // Range Minimum
                                0x0378,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0778,             // Range Minimum
                                0x0778,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {5}
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16,
                                0x0278,             // Range Minimum
                                0x0278,             // Range Maximum
                                0x01,               // Alignment
                                0x08,               // Length
                                )
                            IO (Decode16,
                                0x0678,             // Range Minimum
                                0x0678,             // Range Maximum
                                0x01,               // Alignment
                                0x04,               // Length
                                )
                            IRQNoFlags ()
                                {5}
                        }
                        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 ()
                                {5}
                        }
                        EndDependentFn ()
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {1,3}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (CHKM (0x05))
                        {
                            GETR (0x05, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                            If (Local0)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x02, IO11)
                        CreateWordField (RSRC, 0x04, IO12)
                        CreateByteField (RSRC, 0x07, IO1L)
                        CreateWordField (RSRC, 0x0A, IO21)
                        CreateWordField (RSRC, 0x0C, IO22)
                        CreateWordField (RSRC, 0x11, IRQ1)
                        CreateByteField (RSRC, 0x14, DMA1)
                        GETR (0x05, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
                        Store (Local0, IO11)
                        Store (Local0, IO12)
                        If (LEqual (Local0, 0x03BC))
                        {
                            Store (0x04, IO1L)
                        }
                        Else
                        {
                            Store (0x08, IO1L)
                        }

                        Add (Local0, 0x0400, IO21)
                        Store (IO21, IO22)
                        Store (Local2, IRQ1)
                        Store (Local3, DMA1)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x04, IO11)
                        CreateWordField (Arg0, 0x11, IRQ1)
                        CreateByteField (Arg0, 0x14, DMA1)
                        SETR (0x05, IO11, Zero, IRQ1, DMA1)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        SETR (0x05, Zero, Zero, Zero, Zero)
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        If (CHKM (0x05))
                        {
                            SETM (0x05)
                        }
                    }
                }

                Scope (\_SB.PCI0.LPCB.UAR1)
                {
                    Name (_PRW, Package (0x02)
                    {
                        0x08, 
                        0x03
                    })
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            Store (Zero, RI1M)
                        }
                        Else
                        {
                            Store (One, RI1M)
                        }
                    }
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PARC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLA, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLA, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PARC, 0x0F), IRQ0)
                        Return (RTLA)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PARC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PARC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PBRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLB, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLB, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PBRC, 0x0F), IRQ0)
                        Return (RTLB)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PBRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PBRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PCRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLC, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLC, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PCRC, 0x0F), IRQ0)
                        Return (RTLC)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PCRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PCRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PDRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLD, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PDRC, 0x0F), IRQ0)
                        Return (RTLD)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PDRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PDRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PERC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLE, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLE, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PERC, 0x0F), IRQ0)
                        Return (RTLE)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PERC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PERC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PFRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLF, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLF, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PFRC, 0x0F), IRQ0)
                        Return (RTLF)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PFRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PFRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PGRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {1,3,4,5,6,7,10,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLG, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLG, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PGRC, 0x0F), IRQ0)
                        Return (RTLG)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PGRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PGRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PHRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared, )
                            {3,4,5,6,7,11,12,14,15}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLH, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared, )
                                {}
                        })
                        CreateWordField (RTLH, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PHRC, 0x0F), IRQ0)
                        Return (RTLH)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PHRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PHRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Method (PRCF, 0, NotSerialized)
                {
                    If (B2TC)
                    {
                        Store (One, BY2O)
                    }
                    Else
                    {
                        Store (Zero, BY2O)
                    }
                }
            }

            Device (PATA)
            {
                Name (_ADR, 0x001F0001)
                Name (PMMN, Buffer (0x28) {})
                Name (PSMN, Buffer (0x28) {})
                OperationRegion (ATIO, SystemIO, 0x01F7, 0x01)
                Field (ATIO, ByteAcc, NoLock, Preserve)
                {
                    STSR,   8
                }

                OperationRegion (PCI, PCI_Config, 0x40, 0x18)
                Field (PCI, ByteAcc, NoLock, Preserve)
                {
                    PTI0,   1, 
                    PIE0,   1, 
                    PPP0,   1, 
                    PDT0,   1, 
                    PTI1,   1, 
                    PIE1,   1, 
                    PPP1,   1, 
                    PDT1,   1, 
                    PRCT,   2, 
                        ,   2, 
                    PISP,   2, 
                    PSIT,   1, 
                    PIDE,   1, 
                            Offset (0x04), 
                    PRC1,   2, 
                    PIS1,   2, 
                            Offset (0x08), 
                    PSD0,   1, 
                    PSD1,   1, 
                            Offset (0x0A), 
                    PCT0,   2, 
                        ,   2, 
                    PCT1,   2, 
                            Offset (0x14), 
                    PCB0,   1, 
                    PCB1,   1, 
                        ,   2, 
                    PMCC,   1, 
                    PSCC,   1, 
                        ,   6, 
                    FPC0,   1, 
                    FPC1,   1, 
                            Offset (0x16), 
                    PSMD,   2
                }

                Device (PRIM)
                {
                    Name (_ADR, 0x00)
                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (GTFB, Buffer (0x15)
                            {
                                /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x00, 0x00, 0xA0, 0xF5
                            })
                            CreateByteField (GTFB, 0x01, SPIO)
                            CreateByteField (GTFB, 0x08, SDMA)
                            CreateByteField (GTFB, 0x14, SCMD)
                            If (LNot (SSUP ()))
                            {
                                Store (0x00, SCMD)
                            }

                            If (LNot (PIE0))
                            {
                                Store (0x01, SPIO)
                            }
                            Else
                            {
                                If (LOr (PDT0, LNot (PTI0)))
                                {
                                    Store (0x08, SPIO)
                                }
                                Else
                                {
                                    If (LLess (Add (PISP, PRCT), 0x03))
                                    {
                                        Store (0x0A, SPIO)
                                    }
                                    Else
                                    {
                                        If (LLess (Add (PISP, PRCT), 0x05))
                                        {
                                            Store (0x0B, SPIO)
                                        }
                                        Else
                                        {
                                            Store (0x0C, SPIO)
                                        }
                                    }
                                }
                            }

                            If (PSD0)
                            {
                                If (And (FPC0, PMCC))
                                {
                                    Store (0x45, SDMA)
                                }
                                Else
                                {
                                    If (And (PCB0, PMCC))
                                    {
                                        If (LEqual (PCT0, 0x02))
                                        {
                                            Store (0x44, SDMA)
                                        }
                                        Else
                                        {
                                            Store (0x43, SDMA)
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (PCT0, 0x02))
                                        {
                                            Store (0x42, SDMA)
                                        }
                                        Else
                                        {
                                            If (LEqual (PCT0, 0x01))
                                            {
                                                Store (0x41, SDMA)
                                            }
                                            Else
                                            {
                                                Store (0x40, SDMA)
                                            }
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                If (LLess (Add (PISP, PRCT), 0x05))
                                {
                                    Store (0x21, SDMA)
                                }
                                Else
                                {
                                    Store (0x22, SDMA)
                                }
                            }

                            Return (GTFB)
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (GTFB, Buffer (0x15)
                            {
                                /* 0000 */    0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                /* 0008 */    0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x00, 0x00, 0xB0, 0xF5
                            })
                            CreateByteField (GTFB, 0x01, SPIO)
                            CreateByteField (GTFB, 0x08, SDMA)
                            CreateByteField (GTFB, 0x14, SCMD)
                            If (LNot (SSUP ()))
                            {
                                Store (0x00, SCMD)
                            }

                            If (LNot (PIE1))
                            {
                                Store (0x01, SPIO)
                            }
                            Else
                            {
                                If (LOr (PDT1, LNot (PTI1)))
                                {
                                    Store (0x08, SPIO)
                                }
                                Else
                                {
                                    If (PSIT)
                                    {
                                        If (LLess (Add (PIS1, PRC1), 0x03))
                                        {
                                            Store (0x0A, SPIO)
                                        }
                                        Else
                                        {
                                            If (LLess (Add (PIS1, PRC1), 0x05))
                                            {
                                                Store (0x0B, SPIO)
                                            }
                                            Else
                                            {
                                                Store (0x0C, SPIO)
                                            }
                                        }
                                    }
                                    Else
                                    {
                                        If (LLess (Add (PISP, PRCT), 0x03))
                                        {
                                            Store (0x0A, SPIO)
                                        }
                                        Else
                                        {
                                            If (LLess (Add (PISP, PRCT), 0x05))
                                            {
                                                Store (0x0B, SPIO)
                                            }
                                            Else
                                            {
                                                Store (0x0C, SPIO)
                                            }
                                        }
                                    }
                                }
                            }

                            If (PSD1)
                            {
                                If (And (FPC1, PSCC))
                                {
                                    Store (0x45, SDMA)
                                }
                                Else
                                {
                                    If (And (PCB1, PSCC))
                                    {
                                        If (LEqual (PCT1, 0x02))
                                        {
                                            Store (0x44, SDMA)
                                        }
                                        Else
                                        {
                                            Store (0x43, SDMA)
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (PCT1, 0x02))
                                        {
                                            Store (0x42, SDMA)
                                        }
                                        Else
                                        {
                                            If (LEqual (PCT1, 0x01))
                                            {
                                                Store (0x41, SDMA)
                                            }
                                            Else
                                            {
                                                Store (0x40, SDMA)
                                            }
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                If (PSIT)
                                {
                                    If (LLess (Add (PIS1, PRC1), 0x05))
                                    {
                                        Store (0x21, SDMA)
                                    }
                                    Else
                                    {
                                        Store (0x22, SDMA)
                                    }
                                }
                                Else
                                {
                                    If (LLess (Add (PISP, PRCT), 0x05))
                                    {
                                        Store (0x21, SDMA)
                                    }
                                    Else
                                    {
                                        Store (0x22, SDMA)
                                    }
                                }
                            }

                            Return (GTFB)
                        }
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (GTMB, Buffer (0x14) {})
                        CreateDWordField (GTMB, 0x00, PIO0)
                        CreateDWordField (GTMB, 0x04, DMA0)
                        CreateDWordField (GTMB, 0x08, PIO1)
                        CreateDWordField (GTMB, 0x0C, DMA1)
                        CreateDWordField (GTMB, 0x10, FLAG)
                        Store (0x10, FLAG)
                        Or (FLAG, Or (ShiftLeft (PIE1, 0x03), ShiftLeft (PIE0, 0x01
                            )), FLAG)
                        If (LOr (PDT0, LNot (PTI0)))
                        {
                            Store (0x0384, PIO0)
                        }
                        Else
                        {
                            Multiply (Subtract (0x09, Add (PRCT, PISP)), 0x1E, PIO0)
                        }

                        If (LNot (PSD0))
                        {
                            Store (PIO0, DMA0)
                        }
                        Else
                        {
                            Or (FLAG, 0x01, FLAG)
                            If (And (FPC0, PMCC))
                            {
                                Store (0x14, DMA0)
                            }
                            Else
                            {
                                If (And (PCB0, PMCC))
                                {
                                    Multiply (Subtract (0x04, PCT0), 0x0F, DMA0)
                                }
                                Else
                                {
                                    Multiply (Subtract (0x04, PCT0), 0x1E, DMA0)
                                }
                            }
                        }

                        If (LOr (PDT1, LNot (PTI1)))
                        {
                            Store (0x0384, PIO1)
                        }
                        Else
                        {
                            If (LNot (PSIT))
                            {
                                Store (PIO0, PIO1)
                            }
                            Else
                            {
                                Multiply (Subtract (0x09, Add (PRC1, PIS1)), 0x1E, PIO1)
                            }
                        }

                        If (LNot (PSD1))
                        {
                            Store (PIO1, DMA1)
                        }
                        Else
                        {
                            Or (FLAG, 0x04, FLAG)
                            If (And (FPC1, PSCC))
                            {
                                Store (0x14, DMA1)
                            }
                            Else
                            {
                                If (And (PCB1, PSCC))
                                {
                                    Multiply (Subtract (0x04, PCT1), 0x0F, DMA1)
                                }
                                Else
                                {
                                    Multiply (Subtract (0x04, PCT1), 0x1E, DMA1)
                                }
                            }
                        }

                        Return (GTMB)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Store (0x00, PSIT)
                        If (LAnd (MSMF (), LEqual (SizeOf (Arg1), 0x0200)))
                        {
                            CreateField (Arg1, 0x01B0, 0x0140, MBUF)
                            Store (MBUF, PMMN)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x66, W510)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7C, W620)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            Store (0x00, PISP)
                            Store (0x00, PRCT)
                            Store (0x00, PDT0)
                            Store (0x00, PIE0)
                            Store (0x00, PTI0)
                            Store (0x00, PSD0)
                            Store (0x00, PCT0)
                            Store (0x00, PCB0)
                            Store (0x00, PMCC)
                            Store (0x00, FPC0)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Store (0x01, PIE0)
                            }

                            If (LAnd (LLessEqual (PIO0, 0x78), LAnd (And (W530, 0x02
                                ), And (W640, 0x02))))
                            {
                                Store (0x02, PISP)
                                Store (0x03, PRCT)
                                Store (0x01, PTI0)
                            }
                            Else
                            {
                                If (LAnd (LLessEqual (PIO0, 0xB4), LAnd (And (W530, 0x02
                                    ), And (W640, 0x01))))
                                {
                                    Store (0x02, PISP)
                                    Store (0x01, PRCT)
                                    Store (0x01, PTI0)
                                }
                                Else
                                {
                                    If (LAnd (LLessEqual (PIO0, 0xF0), LGreaterEqual (W510, 0x0200)))
                                    {
                                        Store (0x01, PISP)
                                        Store (0x01, PTI0)
                                    }
                                    Else
                                    {
                                        Noop
                                    }
                                }
                            }

                            If (LNotEqual (DMA0, 0xFFFFFFFF))
                            {
                                If (LAnd (And (FLAG, 0x01), LAnd (And (W530, 0x04
                                    ), And (W880, 0x3F))))
                                {
                                    Store (0x01, PSD0)
                                    If (LAnd (LLessEqual (DMA0, 0x14), And (W880, 0x20)))
                                    {
                                        Store (0x01, PCT0)
                                        Store (0x01, PMCC)
                                        Store (0x01, FPC0)
                                    }
                                    Else
                                    {
                                        If (LAnd (LLessEqual (DMA0, 0x1E), And (W880, 0x10)))
                                        {
                                            Store (0x02, PCT0)
                                            Store (0x01, PMCC)
                                            Store (0x01, PCB0)
                                        }
                                        Else
                                        {
                                            If (LAnd (LLessEqual (DMA0, 0x2D), And (W880, 0x08)))
                                            {
                                                Store (0x01, PCT0)
                                                Store (0x01, PMCC)
                                                Store (0x01, PCB0)
                                            }
                                            Else
                                            {
                                                If (LAnd (LLessEqual (DMA0, 0x3C), And (W880, 0x04)))
                                                {
                                                    Store (0x02, PCT0)
                                                }
                                                Else
                                                {
                                                    If (LAnd (LLessEqual (DMA0, 0x5A), And (W880, 0x02)))
                                                    {
                                                        Store (0x01, PCT0)
                                                    }
                                                    Else
                                                    {
                                                        Noop
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    If (LAnd (LLessEqual (DMA0, 0x78), And (W630, 0x04)))
                                    {
                                        Store (0x02, PISP)
                                        Store (0x03, PRCT)
                                        Store (0x01, PTI0)
                                    }
                                    Else
                                    {
                                        If (LAnd (LLessEqual (DMA0, 0xB4), And (W630, 0x02)))
                                        {
                                            Store (0x02, PISP)
                                            Store (0x01, PRCT)
                                            Store (0x01, PTI0)
                                        }
                                        Else
                                        {
                                            Noop
                                        }
                                    }
                                }
                            }
                        }

                        If (LAnd (SSMF (), LEqual (SizeOf (Arg2), 0x0200)))
                        {
                            CreateField (Arg2, 0x01B0, 0x0140, SBUF)
                            Store (SBUF, PSMN)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x66, W511)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7C, W621)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            Store (0x00, PIS1)
                            Store (0x00, PRC1)
                            Store (0x00, PDT1)
                            Store (0x00, PIE1)
                            Store (0x00, PTI1)
                            Store (0x00, PSD1)
                            Store (0x00, PCT1)
                            Store (0x00, PCB1)
                            Store (0x00, PSCC)
                            Store (0x00, FPC1)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Store (0x01, PIE1)
                            }

                            If (LAnd (And (FLAG, 0x10), LAnd (LNotEqual (PIO1, 
                                0xFFFFFFFF), LNotEqual (PIO1, PIO0))))
                            {
                                Store (0x01, PSIT)
                                If (LAnd (LLessEqual (PIO1, 0x78), LAnd (And (W531, 0x02
                                    ), And (W641, 0x02))))
                                {
                                    Store (0x02, PIS1)
                                    Store (0x03, PRC1)
                                    Store (0x01, PTI1)
                                }
                                Else
                                {
                                    If (LAnd (LLessEqual (PIO1, 0xB4), LAnd (And (W531, 0x02
                                        ), And (W641, 0x01))))
                                    {
                                        Store (0x02, PIS1)
                                        Store (0x01, PRC1)
                                        Store (0x01, PTI1)
                                    }
                                    Else
                                    {
                                        If (LAnd (LLessEqual (PIO1, 0xF0), LGreaterEqual (W511, 0x0200)))
                                        {
                                            Store (0x01, PIS1)
                                            Store (0x01, PTI1)
                                        }
                                        Else
                                        {
                                            Noop
                                        }
                                    }
                                }
                            }

                            If (LNotEqual (DMA1, 0xFFFFFFFF))
                            {
                                If (LAnd (And (FLAG, 0x04), LAnd (And (W531, 0x04
                                    ), And (W881, 0x3F))))
                                {
                                    Store (0x01, PSD1)
                                    If (LAnd (LLessEqual (DMA1, 0x14), And (W881, 0x20)))
                                    {
                                        Store (0x01, PCT1)
                                        Store (0x01, PSCC)
                                        Store (0x01, FPC1)
                                    }
                                    Else
                                    {
                                        If (LAnd (LLessEqual (DMA1, 0x1E), And (W881, 0x10)))
                                        {
                                            Store (0x02, PCT1)
                                            Store (0x01, PSCC)
                                            Store (0x01, PCB1)
                                        }
                                        Else
                                        {
                                            If (LAnd (LLessEqual (DMA1, 0x2D), And (W881, 0x08)))
                                            {
                                                Store (0x01, PCT1)
                                                Store (0x01, PSCC)
                                                Store (0x01, PCB1)
                                            }
                                            Else
                                            {
                                                If (LAnd (LLessEqual (DMA1, 0x3C), And (W881, 0x04)))
                                                {
                                                    Store (0x02, PCT1)
                                                }
                                                Else
                                                {
                                                    If (LAnd (LLessEqual (DMA1, 0x5A), And (W881, 0x02)))
                                                    {
                                                        Store (0x01, PCT1)
                                                    }
                                                    Else
                                                    {
                                                        Noop
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    If (LAnd (And (FLAG, 0x10), LNotEqual (DMA1, DMA0)))
                                    {
                                        Store (0x01, PSIT)
                                        If (LAnd (LLessEqual (DMA1, 0x78), And (W631, 0x04)))
                                        {
                                            Store (0x02, PIS1)
                                            Store (0x03, PRC1)
                                            Store (0x01, PTI1)
                                        }
                                        Else
                                        {
                                            If (LAnd (LLessEqual (DMA1, 0xB4), And (W631, 0x02)))
                                            {
                                                Store (0x02, PIS1)
                                                Store (0x01, PRC1)
                                                Store (0x01, PTI1)
                                            }
                                            Else
                                            {
                                                Noop
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Store (0x01, PIDE)
                    }
                }

                Scope (\_SB.PCI0.PATA.PRIM)
                {
                    Method (_STA, 0, NotSerialized)
                    {
                        If (CPBL)
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }

                    Method (MSMF, 0, NotSerialized)
                    {
                        Return (\_SB.PCI0.PATA.PRIM.MAST._STA ())
                    }

                    Method (SSMF, 0, NotSerialized)
                    {
                        Return (0x00)
                    }
                }

                Scope (\_SB.PCI0.PATA.PRIM.MAST)
                {
                    Method (_STA, 0, NotSerialized)
                    {
                        If (CPBL)
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            If (LAnd (\_SB.PCI0.PATA.PRIM.MAST.BIDE (), LAnd (BRST, BY1O)))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Method (SSUP, 0, NotSerialized)
                    {
                        Return (LEqual (BY1I, 0x0A))
                    }

                    Method (BIDE, 0, NotSerialized)
                    {
                        Store (BY1I, Local0)
                        Store (LEqual (Local0, 0x08), Local1)
                        Or (LEqual (Local0, 0x0A), Local1, Local1)
                        Or (LEqual (Local0, 0x0B), Local1, Local1)
                        Or (LEqual (Local0, 0x0D), Local1, Local1)
                        Return (Local1)
                    }

                    Method (_EJ0, 1, NotSerialized)
                    {
                        BOFF ()
                        Return (Zero)
                    }

                    Method (BON, 0, NotSerialized)
                    {
                        Store (Zero, BRST)
                        Store (Zero, PIE0)
                        Store (0x02, PSMD)
                        If (LEqual (BY1C, Zero))
                        {
                            Sleep (0x64)
                            Store (BY1I, Local0)
                            If (LNotEqual (Local0, 0x01))
                            {
                                Store (One, BY1O)
                                If (LEqual (BY1I, 0x0A))
                                {
                                    Sleep (0x32)
                                }

                                Sleep (0x46)
                                Store (Zero, PSMD)
                                Store (0x01, PIDE)
                                Store (0x01, PSD0)
                                Store (0x01, PMCC)
                                Store (0x01, FPC0)
                                And (BOPT, 0xFE, BOPT)
                                And (BHDD, 0xFE, BHDD)
                                If (LEqual (Local0, 0x08))
                                {
                                    Or (BOPT, One, BOPT)
                                }

                                If (LEqual (Local0, 0x0A))
                                {
                                    Or (BHDD, One, BHDD)
                                }

                                If (LEqual (Local0, 0x0B))
                                {
                                    Or (BOPT, One, BOPT)
                                }

                                If (LEqual (Local0, 0x0D))
                                {
                                    Or (BOPT, One, BOPT)
                                }

                                Sleep (0x1E)
                                Store (One, BRST)
                                Sleep (0x64)
                                Store (Zero, Local1)
                                While (LAnd (LAnd (And (STSR, 0x80), B1TC), LLess (Local1, 
                                    0x015E)))
                                {
                                    Sleep (0x64)
                                    Add (Local1, 0x01, Local1)
                                }
                            }
                        }
                    }

                    Method (BOFF, 0, NotSerialized)
                    {
                        Store (Zero, BRST)
                        And (BOPT, 0xFE, BOPT)
                        And (BHDD, 0xFE, BHDD)
                        Sleep (0x1E)
                        TMCL ()
                        Store (0x02, PSMD)
                        Sleep (0x46)
                        Store (Zero, BY1O)
                        Sleep (0x64)
                    }

                    Method (TMCL, 0, NotSerialized)
                    {
                        Store (0x00, PIDE)
                        Store (0x00, PISP)
                        Store (0x00, PRCT)
                        Store (0x00, PDT0)
                        Store (0x00, PIE0)
                        Store (0x00, PTI0)
                        Store (0x00, PSD0)
                        Store (0x00, PCT0)
                        Store (0x00, PCB0)
                        Store (0x00, PMCC)
                        Store (0x00, FPC0)
                        Store (0x01, PIDE)
                    }
                }

                Scope (\_SB.PCI0.PATA.PRIM.SLAV)
                {
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x00)
                    }

                    Method (SSUP, 0, NotSerialized)
                    {
                        Return (0x00)
                    }
                }
            }

            Device (SATA)
            {
                Name (_ADR, 0x001F0002)
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)
            }

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)
            }

            Device (USB3)
            {
                Name (_ADR, 0x001D0002)
                Device (HUB3)
                {
                    Name (_ADR, 0x00)
                    Device (PRT1)
                    {
                        Name (_EJD, "\\_SB.PCI0.RP02.PXS2")
                        Name (_ADR, 0x01)
                    }
                }
            }

            Device (USB4)
            {
                Name (_ADR, 0x001D0003)
            }

            Device (USB7)
            {
                Name (_ADR, 0x001D0007)
                Device (HUB7)
                {
                    Name (_ADR, 0x00)
                    Device (PRT5)
                    {
                        Name (_ADR, 0x05)
                        Name (_EJD, "\\_SB.PCI0.RP02.PXS2")
                    }
                }
            }

            Device (SBUS)
            {
                Name (_ADR, 0x001F0003)
            }

            Device (AUD0)
            {
                Name (_ADR, 0x001E0002)
            }

            Device (MODM)
            {
                Name (_ADR, 0x001E0003)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
            }

            Device (HDEF)
            {
                Name (_ADR, 0x001B0000)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Name (_PSC, 0x00)
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, _PSC)
                    If (LAnd (HDWA, LGreaterEqual (\_SB.OSTP (), 0x40)))
                    {
                        Store (Zero, HDWA)
                        Sleep (0x01F4)
                    }
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (0x03, _PSC)
                }
            }

            Device (RP01)
            {
                Name (_ADR, 0x001C0000)
                OperationRegion (P1CS, PCI_Config, 0x40, 0x0100)
                Field (P1CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP1,   1, 
                        ,   2, 
                    PDC1,   1, 
                        ,   2, 
                    PDS1,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP1,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

                Device (PXS1)
                {
                    Name (_ADR, 0x00)
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

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

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

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x13
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (RP02)
            {
                Name (_ADR, 0x001C0001)
                OperationRegion (P2CS, PCI_Config, 0x40, 0x0100)
                Field (P2CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP2,   1, 
                        ,   2, 
                    PDC2,   1, 
                        ,   2, 
                    PDS2,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP2,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

                Device (PXS2)
                {
                    Name (_ADR, 0x00)
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x11
                            }, 

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

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

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x10
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }
                        })
                    }
                }
            }

            Device (RP03)
            {
                Name (_ADR, 0x001C0002)
                OperationRegion (P3CS, PCI_Config, 0x40, 0x0100)
                Field (P3CS, AnyAcc, NoLock, WriteAsZeros)
                {
                            Offset (0x1A), 
                    ABP3,   1, 
                        ,   2, 
                    PDC3,   1, 
                        ,   2, 
                    PDS3,   1, 
                            Offset (0x20), 
                            Offset (0x22), 
                    PSP3,   1, 
                            Offset (0x9C), 
                        ,   30, 
                    HPCS,   1, 
                    PMCS,   1
                }

                Device (PXS3)
                {
                    Name (_ADR, 0x00)
                }

                Method (_PRT, 0, NotSerialized)
                {
                    If (\GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x12
                            }, 

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

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

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x11
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPCB.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPCB.LNKD, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPCB.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPCB.LNKB, 
                                0x00
                            }
                        })
                    }
                }
            }

            Scope (\_SB.PCI0.RP01.PXS1)
            {
                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x04
                })
            }

            Scope (\_SB.PCI0.RP02.PXS2)
            {
                Name (_EJD, "\\_SB.PCI0.USB7.HUB7.PRT5")
                Method (_STA, 0, NotSerialized)
                {
                    If (PXRS)
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x04
                })
                Method (_RMV, 0, NotSerialized)
                {
                    Return (One)
                }

                Method (EXIN, 0, NotSerialized)
                {
                    Sleep (0x64)
                    Store (Zero, PXCL)
                    Sleep (0x01)
                    Store (One, PXRS)
                    Store (Zero, EXPL)
                }

                Method (EXRM, 0, NotSerialized)
                {
                    Store (Zero, PXRS)
                    Store (One, PXCL)
                    Store (One, EXPL)
                }
            }
        }

        Scope (\)
        {
            Name (WBTN, Zero)
            Name (NGTM, Zero)
            Name (LSBL, Zero)
            Name (BNBF, Buffer (0x20) {})
            Name (BNSP, Zero)
            Name (BNGP, Zero)
            Name (BNCT, Zero)
        }

        Device (FEXT)
        {
            Name (_HID, "FUJ02E3")
            Method (_STA, 0, NotSerialized)
            {
                Return (0x0F)
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (Zero, BNSP)
                Store (Zero, BNGP)
                Store (Zero, BNCT)
                Store (Zero, IRBC)
                Store (Zero, IRBF)
            }

            Method (FUNC, 4, Serialized)
            {
                Store (0x80000000, Local0)
                If (LEqual (Arg0, 0x1001))
                {
                    Store (S001 (Arg1, Arg2, Arg3), Local0)
                }
                Else
                {
                    If (LEqual (Arg0, 0x1002))
                    {
                        Store (S002 (Arg1, Arg2, Arg3), Local0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x1004))
                        {
                            Store (S004 (Arg1, Arg2, Arg3), Local0)
                        }
                    }
                }

                If (LEqual (Arg0, 0x1005))
                {
                    Store (S005 (Arg1, Arg2, Arg3), Local0)
                }

                If (LEqual (Arg0, 0x1006))
                {
                    Store (S006 (Arg1, Arg2, Arg3), Local0)
                }

                If (LEqual (Arg0, 0x1008))
                {
                    Store (S008 (Arg1, Arg2, Arg3), Local0)
                }

                If (LEqual (Arg0, 0x1000))
                {
                    Store (S000 (Arg1, Arg2, Arg3), Local0)
                }

                Return (Local0)
            }

            Method (S001, 3, NotSerialized)
            {
                Store (0x80000000, Local0)
                If (LEqual (Arg0, Zero))
                {
                    Store (LEDI, Local0)
                }
                Else
                {
                    If (LEqual (Arg0, One))
                    {
                        And (Arg2, 0x03, Local1)
                        If (LAnd (And (Arg1, LEDI), Local1))
                        {
                            Store (0x9B, CMD)
                            ShiftRight (And (Arg2, 0x00030000), 0x08, DVID)
                            Store (Zero, SSMI)
                        }

                        Store (Zero, Local0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x02))
                        {
                            If (And (Arg1, LEDI))
                            {
                                Store (0x9B, CMD)
                                Store (One, DVID)
                                Store (Zero, SSMI)
                                Or (ShiftLeft (DVID, 0x10), One, Local0)
                            }
                            Else
                            {
                                Store (Zero, Local0)
                            }
                        }
                    }
                }

                Return (Local0)
            }

            Method (S002, 3, NotSerialized)
            {
                Store (0x80000000, Local0)
                If (LEqual (Arg0, Zero))
                {
                    Store (BTNI, Local0)
                }
                Else
                {
                    If (LEqual (Arg0, One))
                    {
                        Store (GIRB (), Local0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x02))
                        {
                            Store (0x9B, CMD)
                            Store (0x02, DVID)
                            Store (Zero, SSMI)
                            Store (DVID, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x03))
                            {
                                If (Arg1)
                                {
                                    Not (Arg1, Local1)
                                    And (Arg2, Arg1, Local2)
                                    Or (And (WBTN, Local1), Local2, WBTN)
                                    Store (0x9B, CMD)
                                    Or (ShiftLeft (WBTN, 0x08), 0x03, DVID)
                                    Store (Zero, SSMI)
                                }

                                Store (WBTN, Local0)
                            }
                        }
                    }
                }

                Return (Local0)
            }

            Method (SIRB, 1, NotSerialized)
            {
                If (LLess (BNCT, 0x10))
                {
                    CreateWordField (BNBF, BNSP, BNP1)
                    Store (Arg0, BNP1)
                    Increment (BNCT)
                    Add (BNSP, 0x02, BNSP)
                    If (LGreaterEqual (BNSP, 0x20))
                    {
                        Store (Zero, BNSP)
                    }
                }
            }

            Method (GIRB, 0, NotSerialized)
            {
                If (BNCT)
                {
                    CreateWordField (BNBF, BNGP, BNP2)
                    Store (BNP2, Local0)
                    Or (Local0, 0x40000000, Local0)
                    Decrement (BNCT)
                    Add (BNGP, 0x02, BNGP)
                    If (LGreaterEqual (BNGP, 0x20))
                    {
                        Store (Zero, BNGP)
                    }
                }
                Else
                {
                    Store (Zero, Local0)
                }

                Return (Local0)
            }

            Method (S004, 3, NotSerialized)
            {
                Store (0x80000000, Local0)
                If (LEqual (Arg0, Zero))
                {
                    Store (NGTI, Local0)
                }
                Else
                {
                    If (LEqual (Arg0, One))
                    {
                        If (LAnd (LEqual (Arg1, 0x04), And (NGTI, 0x04)))
                        {
                            And (Arg2, 0x03, Local1)
                            If (LOr (LEqual (Local1, 0x03), LEqual (Local1, 0x02)))
                            {
                                If (LNot (NGTF))
                                {
                                    SVBL ()
                                    Store (One, NGTF)
                                }

                                SBLC (Local1)
                                Store (Local1, NGTM)
                                Store (Zero, Local0)
                            }

                            If (LNot (Local1))
                            {
                                If (NGTF)
                                {
                                    Store (Zero, NGTF)
                                    RSBL ()
                                    SBLC (Zero)
                                }

                                Store (Zero, NGTM)
                                Store (Zero, Local0)
                            }
                        }
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x02))
                        {
                            If (LAnd (LEqual (Arg1, 0x04), And (NGTI, 0x04)))
                            {
                                Store (NGTM, Local0)
                            }
                        }
                    }
                }

                Return (Local0)
            }

            Method (S008, 3, NotSerialized)
            {
                Store (0x80000000, Local0)
                If (LEqual (Arg0, 0x00))
                {
                    If (LAnd (LGreaterEqual (Arg1, 0x00), LLessEqual (Arg1, 0x05)))
                    {
                        If (LEqual (Arg1, Zero))
                        {
                            Store (Zero, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg1, One))
                            {
                                If (LGreaterEqual (\_SB.OSTP (), 0x40))
                                {
                                    Store (0x02, Local0)
                                }
                                Else
                                {
                                    Store (Zero, Local0)
                                }
                            }
                            Else
                            {
                                Store (0xA4, CMD)
                                Store (Arg0, QAG1)
                                Store (Arg1, QAG2)
                                Store (Arg2, QAG3)
                                Store (Zero, DVID)
                                Store (Zero, SSMI)
                                Store (DVID, Local0)
                            }
                        }
                    }
                }
                Else
                {
                    If (LEqual (Arg0, 0x01))
                    {
                        If (LAnd (LGreaterEqual (Arg1, 0x00), LLessEqual (Arg1, 0x01)))
                        {
                            Store (0xA4, CMD)
                            Store (Arg0, QAG1)
                            Store (Arg1, QAG2)
                            Store (Arg2, QAG3)
                            Store (Zero, DVID)
                            Store (Zero, SSMI)
                            Store (DVID, Local0)
                        }
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x02))
                        {
                            If (LAnd (LGreaterEqual (Arg1, 0x00), LLessEqual (Arg1, 0x01)))
                            {
                                Store (0xA4, CMD)
                                Store (Arg0, QAG1)
                                Store (Arg1, QAG2)
                                Store (Arg2, QAG3)
                                Store (Zero, DVID)
                                Store (Zero, SSMI)
                                Store (DVID, Local0)
                            }
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x03))
                            {
                                If (LEqual (Arg1, 0x00))
                                {
                                    Store (0xA4, CMD)
                                    Store (Arg0, QAG1)
                                    Store (Arg1, QAG2)
                                    Store (Arg2, QAG3)
                                    Store (Zero, DVID)
                                    Store (Zero, SSMI)
                                    Store (DVID, Local0)
                                }
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x04))
                                {
                                    If (LAnd (LGreaterEqual (Arg1, 0x00), LLessEqual (Arg1, 0x01)))
                                    {
                                        Store (0xA4, CMD)
                                        Store (Arg0, QAG1)
                                        Store (Arg1, QAG2)
                                        Store (Arg2, QAG3)
                                        Store (Zero, DVID)
                                        Store (Zero, SSMI)
                                        Store (DVID, Local0)
                                    }
                                }
                            }
                        }
                    }
                }

                Return (Local0)
            }
        }

        Scope (\_SB.FEXT)
        {
            Method (SBLC, 1, NotSerialized)
            {
                If (LNot (Arg0))
                {
                    Store (Zero, BLCT)
                }
                Else
                {
                    If (LEqual (Arg0, 0x03))
                    {
                        Store (One, BLCT)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x02))
                        {
                            Name (BBCT, Buffer (BLLM) {})
                            Store (BLLT, BBCT)
                            CreateByteField (BBCT, Zero, BLL0)
                            Store (BLL0, LCDB)
                            Store (0x01000000, DVID)
                            Or (DVID, BLL0, DVID)
                            Store (0x82, CMD)
                            Store (Zero, SSMI)
                            Store (Zero, BLCT)
                        }
                    }
                }
            }

            Method (SVBL, 0, NotSerialized)
            {
                And (\_SB.PCI0.LPCB.FJEX.GBLL (), 0x7FFFFFFF, LSBL)
            }

            Method (RSBL, 0, NotSerialized)
            {
                \_SB.PCI0.LPCB.FJEX.SBLL (LSBL)
            }

            Method (S000, 3, NotSerialized)
            {
                Store (0x80000000, Local0)
                If (LEqual (Arg0, 0x00))
                {
                    Store (Zero, Local0)
                    Or (Local0, 0x20, Local0)
                    Or (Local0, 0x0100, Local0)
                    Or (Local0, 0x0200, Local0)
                }
                Else
                {
                    If (LEqual (Arg0, 0x01))
                    {
                        Store (Zero, Local0)
                        Or (Local0, ShiftLeft (WSEF, 0x05), Local0)
                        Store (Zero, WSEF)
                        Or (Local0, ShiftLeft (LIDF, 0x08), Local0)
                        Store (Zero, LIDF)
                        Or (Local0, ShiftLeft (PREF, 0x09), Local0)
                        Store (Zero, PREF)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x04))
                        {
                            Store (Zero, Local0)
                            Or (Local0, ShiftLeft (WLSW, 0x05), Local0)
                            Or (Local0, ShiftLeft (\_SB.LID._LID (), 0x08), Local0)
                            Or (Local0, ShiftLeft (BY2O, 0x09), Local0)
                        }
                    }
                }

                Return (Local0)
            }

            Method (S005, 3, NotSerialized)
            {
                Store (0x80000000, Local0)
                If (LEqual (Arg0, Zero))
                {
                    If (CPBL)
                    {
                        Store (And (DPCI, Not (One)), Local0)
                    }
                    Else
                    {
                        Store (DPCI, Local0)
                    }
                }
                Else
                {
                    If (LEqual (Arg0, One))
                    {
                        If (And (Arg1, One))
                        {
                            If (And (Arg2, One))
                            {
                                If (\_SB.PCI0.PATA.PRIM.MAST.BIDE ())
                                {
                                    \_SB.PCI0.PATA.PRIM.MAST.BOFF ()
                                }

                                Or (DPCS, One, DPCS)
                            }
                            Else
                            {
                                If (\_SB.PCI0.PATA.PRIM.MAST.BIDE ())
                                {
                                    \_SB.PCI0.PATA.PRIM.MAST.BON ()
                                }

                                And (DPCS, 0xFFFFFFFE, DPCS)
                            }

                            Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
                        }

                        And (DPCS, DPCI, Local0)
                    }
                }

                Return (Local0)
            }

            Method (S006, 3, NotSerialized)
            {
                Store (0x80000000, Local0)
                If (ECOK)
                {
                    If (LEqual (Arg0, Zero))
                    {
                        Store (ECCI, Local0)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x10))
                        {
                            If (Arg1)
                            {
                                And (Arg1, 0xFF, ECG1)
                                Store (0x23, ECGM)
                                Store (Zero, Local1)
                                While (LAnd (ECGM, LLess (Local1, 0x64)))
                                {
                                    Sleep (0x01)
                                    Increment (Local1)
                                }

                                If (LGreaterEqual (Local1, 0x64))
                                {
                                    Store (0x80000001, Local0)
                                }
                                Else
                                {
                                    Or (ShiftLeft (ECG2, 0x08), ECG3, Local0)
                                }
                            }
                            Else
                            {
                                Store (0xFD70, Local0)
                            }
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x11))
                            {
                                And (Arg1, 0xFF, ECG1)
                                ShiftRight (And (Arg2, 0xFF00), 0x08, ECG2)
                                And (Arg2, 0xFF, ECG3)
                                Store (0x22, ECGM)
                                Store (Zero, Local1)
                                While (LAnd (ECGM, LLess (Local1, 0x64)))
                                {
                                    Sleep (0x01)
                                    Increment (Local1)
                                }

                                If (LGreaterEqual (Local1, 0x64))
                                {
                                    Store (0x80000001, Local0)
                                }
                                Else
                                {
                                    Store (Zero, Local0)
                                }
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x12))
                                {
                                    Store (GINT, Local0)
                                    Store (Zero, GINT)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x20))
                                    {
                                        ShiftRight (And (Arg1, 0xFF000000), 0x18, ECD3)
                                        ShiftRight (And (Arg1, 0x00FF0000), 0x10, ECD2)
                                        ShiftRight (And (Arg1, 0xFF00), 0x08, ECD1)
                                        And (Arg1, 0xFF, ECCM)
                                        Store (Zero, Local1)
                                        While (LAnd (ECCM, LLess (Local1, 0x64)))
                                        {
                                            Sleep (0x01)
                                            Increment (Local1)
                                        }

                                        If (LGreaterEqual (Local1, 0x64))
                                        {
                                            Store (0x80000001, Local0)
                                        }
                                        Else
                                        {
                                            Or (Or (ShiftLeft (ECD3, 0x10), ShiftLeft (ECD2, 0x08)
                                                ), ECD1, Local0)
                                        }
                                    }
                                    Else
                                    {
                                        If (LEqual (Arg0, 0x30))
                                        {
                                            Store (0x80000001, Local0)
                                            ShiftRight (And (Arg1, 0xFF00), 0x08, Local1)
                                            ShiftRight (And (Arg1, 0xFFFF0000), 0x10, Local2)
                                            If (LOr (LEqual (Local2, 0xFD64), LEqual (Local2, 0xFD65)))
                                            {
                                                Store (Local1, AIDA)
                                                Store (ADTA, Local0)
                                            }

                                            If (LOr (LEqual (Local2, 0xFD62), LEqual (Local2, 0xFD63)))
                                            {
                                                Store (Local1, AIDB)
                                                Store (ADTB, Local0)
                                            }

                                            If (LOr (LEqual (Local2, 0xFD60), LEqual (Local2, 0xFD61)))
                                            {
                                                Store (Local1, AIDC)
                                                Store (ADTC, Local0)
                                            }

                                            If (LOr (LEqual (Local2, 0xFD66), LEqual (Local2, 0xFD67)))
                                            {
                                                Store (Local1, AIDD)
                                                Store (ADTD, Local0)
                                            }

                                            If (LOr (LEqual (Local2, 0xFD70), LEqual (Local2, 0xFD74)))
                                            {
                                                Store (Local1, PMID)
                                                Store (PMDT, Local0)
                                            }
                                        }
                                        Else
                                        {
                                            If (LEqual (Arg0, 0x31))
                                            {
                                                Store (0x80000001, Local0)
                                                And (Arg1, 0xFF, Local1)
                                                ShiftRight (And (Arg1, 0xFF00), 0x08, Local2)
                                                ShiftRight (And (Arg1, 0xFFFF0000), 0x10, Local3)
                                                If (LOr (LEqual (Local3, 0xFD64), LEqual (Local3, 0xFD65)))
                                                {
                                                    Store (Local2, AIDA)
                                                    Store (Local1, ADTA)
                                                    Store (Zero, Local0)
                                                }

                                                If (LOr (LEqual (Local3, 0xFD62), LEqual (Local3, 0xFD63)))
                                                {
                                                    Store (Local2, AIDB)
                                                    Store (Local1, ADTB)
                                                    Store (Zero, Local0)
                                                }

                                                If (LOr (LEqual (Local3, 0xFD60), LEqual (Local3, 0xFD61)))
                                                {
                                                    Store (Local2, AIDC)
                                                    Store (Local1, ADTC)
                                                    Store (Zero, Local0)
                                                }

                                                If (LOr (LEqual (Local3, 0xFD66), LEqual (Local3, 0xFD67)))
                                                {
                                                    Store (Local2, AIDD)
                                                    Store (Local1, ADTD)
                                                    Store (Zero, Local0)
                                                }

                                                If (LOr (LEqual (Local3, 0xFD70), LEqual (Local3, 0xFD74)))
                                                {
                                                    Store (Local2, PMID)
                                                    Store (Local1, PMDT)
                                                    Store (Zero, Local0)
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                Return (Local0)
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                If (CVCL)
                {
                    Return (Zero)
                }
                Else
                {
                    Return (One)
                }
            }

            Name (_PRW, Package (0x02)
            {
                0x18, 
                0x04
            })
            Method (_PSW, 1, NotSerialized)
            {
                Noop
            }
        }

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

        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Scope (\)
            {
                Name (ACPS, Ones)
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (ACPW, ACPS)
            }

            Method (_STA, 0, NotSerialized)
            {
                Return (0x0F)
            }

            Method (_PSR, 0, NotSerialized)
            {
                _INI ()
                If (ACPW)
                {
                    Return (One)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (ACHK, 0, NotSerialized)
            {
                Store (ACPW, Local0)
                If (LNotEqual (Local0, ACPS))
                {
                    Sleep (0x28)
                    Notify (\_SB.AC, 0x80)
                    Store (Zero, DVID)
                    Store (0x8D, CMD)
                    Store (Zero, SSMI)
                    Notify (\_PR.CPU0, 0x80)
                    Store (Local0, ACPS)
                }
            }
        }

        Device (CMB1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, One)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Scope (\)
            {
                Name (B1PS, Ones)
                Name (B1RS, Ones)
                Name (B1CS, Ones)
                Name (B1LS, Ones)
                Name (B1IS, Ones)
                Name (BIF1, Package (0x0D)
                {
                    0x01, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x00, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x01, 
                    "", 
                    "1", 
                    "LION", 
                    "Fujitsu"
                })
                Name (BST1, Package (0x04) {})
            }

            Method (MKWD, 2, NotSerialized)
            {
                If (And (Arg1, 0x80))
                {
                    Or (0xFFFF0000, Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                    Subtract (Zero, Local0, Local0)
                }
                Else
                {
                    Store (Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                }

                Return (Local0)
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (B1P, B1PS)
                Store (B1CP, B1RS)
                Store (B1C, B1CS)
                Store (MKWD (B1LL, B1LH), B1LS)
                Store (B1ID, B1IS)
            }

            Method (_BIF, 0, NotSerialized)
            {
                Name (BUFF, Buffer (0x0C) {})
                Store (B1NO, Local5)
                CreateByteField (BIDT, B1ID, B1IX)
                Store (MKWD (B1DL, B1DH), Index (BIF1, 0x01))
                Store (MKWD (B1LL, B1LH), Index (BIF1, 0x02))
                Store (Multiply (Add (And (B1DV, 0xEF), 0x02), 0x0E10
                    ), Index (BIF1, 0x04))
                If (LGreaterEqual (\_SB.OSTP (), 0x40))
                {
                    Divide (Multiply (Add (Multiply (0x0C, 0x0A), 0x04), DerefOf (
                        Index (BIF1, 0x01))), 0x03E8, Local0, Index (BIF1, 0x05))
                }

                If (LGreaterEqual (\_SB.OSTP (), 0x40))
                {
                    If (LEqual (BIFL, 0xFF))
                    {
                        Store (0x0A, Local1)
                    }
                    Else
                    {
                        Store (BIFL, Local1)
                    }

                    Divide (Multiply (Add (Multiply (Local1, 0x0A), 0x04), DerefOf (
                        Index (BIF1, 0x01))), 0x03E8, Local0, Index (BIF1, 0x06))
                }

                If (Local5)
                {
                    Store (DerefOf (Index (BMST, B1IX)), BUFF)
                    Store (0x07, Local0)
                    Store (Local5, Local2)
                    While (LAnd (Local2, LGreaterEqual (Local0, 0x02)))
                    {
                        Store (Subtract (DerefOf (Index (BUFF, Local0)), 0x30), Local1)
                        Divide (Add (Local1, Local2), 0x0A, Local1, Local2)
                        Store (Add (Local1, 0x30), Index (BUFF, Local0))
                        Decrement (Local0)
                    }

                    Store (BUFF, Index (BIF1, 0x09))
                }
                Else
                {
                    Store (DerefOf (Index (BMNT, B1IX)), Index (BIF1, 0x09))
                }

                Store (B1P, B1PS)
                Store (MKWD (B1LL, B1LH), B1LS)
                Store (B1ID, B1IS)
                Return (BIF1)
            }

            Method (_BST, 0, NotSerialized)
            {
                Store (B1CP, B1RS)
                Store (B1C, B1CS)
                Store (Zero, Local0)
                If (B1P)
                {
                    If (B1C)
                    {
                        Or (Local0, 0x02, Local0)
                    }
                    Else
                    {
                        If (LNot (ACPS))
                        {
                            Or (Local0, One, Local0)
                        }
                    }

                    If (LLessEqual (B1CP, One))
                    {
                        Or (Local0, 0x04, Local0)
                    }
                }

                Store (MKWD (B1CL, B1CH), Local1)
                Divide (Multiply (B1CP, MKWD (B1LL, B1LH)), 0x03E8, Local4, Local2)
                If (Local4)
                {
                    Increment (Local2)
                }

                Multiply (Local2, 0x0A, Local2)
                Store (MKWD (B1VL, B1VH), Local3)
                Store (Local0, Index (BST1, Zero))
                Store (Local1, Index (BST1, One))
                Store (Local2, Index (BST1, 0x02))
                Store (Local3, Index (BST1, 0x03))
                Return (BST1)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (B1P)
                {
                    Return (0x1F)
                }

                Return (0x0F)
            }

            Method (BCHK, 0, NotSerialized)
            {
                If (LNotEqual (B1P, B1PS))
                {
                    Notify (\_SB.CMB1, 0x81)
                    Store (B1P, B1PS)
                }

                If (LNotEqual (B1ID, B1IS))
                {
                    Notify (\_SB.CMB1, 0x81)
                    Store (B1ID, B1IS)
                }

                If (B1PS)
                {
                    Store (MKWD (B1LL, B1LH), Local0)
                    If (LNotEqual (Local0, B1LS))
                    {
                        Notify (\_SB.CMB1, 0x81)
                    }

                    If (LOr (LNotEqual (B1C, B1CS), LNotEqual (B1CP, B1RS)))
                    {
                        Notify (\_SB.CMB1, 0x80)
                    }

                    Store (Local0, B1LS)
                    Store (B1C, B1CS)
                    Store (B1CP, B1RS)
                }
            }
        }

        Device (CMB2)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x02)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Scope (\)
            {
                Name (B2PS, Ones)
                Name (B2RS, Ones)
                Name (B2CS, Ones)
                Name (B2LS, Ones)
                Name (B2IS, Ones)
                Name (BIF2, Package (0x0D)
                {
                    0x01, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x00, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x01, 
                    "", 
                    "2", 
                    "LION", 
                    "Fujitsu"
                })
                Name (BST2, Package (0x04) {})
            }

            Method (MKWD, 2, NotSerialized)
            {
                If (And (Arg1, 0x80))
                {
                    Or (0xFFFF0000, Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                    Subtract (Zero, Local0, Local0)
                }
                Else
                {
                    Store (Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                }

                Return (Local0)
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (B2P, B2PS)
                Store (B2CP, B2RS)
                Store (B2C, B2CS)
                Store (MKWD (B2LL, B2LH), B2LS)
                Store (B2ID, B2IS)
            }

            Method (_BIF, 0, NotSerialized)
            {
                Name (BUFF, Buffer (0x0C) {})
                Store (B2NO, Local5)
                CreateByteField (BIDT, B2ID, B2IX)
                Store (MKWD (B2DL, B2DH), Index (BIF2, 0x01))
                Store (MKWD (B2LL, B2LH), Index (BIF2, 0x02))
                Store (Multiply (Add (And (B2DV, 0xEF), 0x02), 0x0E10
                    ), Index (BIF2, 0x04))
                If (LGreaterEqual (\_SB.OSTP (), 0x40))
                {
                    Divide (Multiply (Add (Multiply (0x0C, 0x0A), 0x04), DerefOf (
                        Index (BIF2, 0x01))), 0x03E8, Local0, Index (BIF2, 0x05))
                }

                If (LGreaterEqual (\_SB.OSTP (), 0x40))
                {
                    If (LEqual (BIFL, 0xFF))
                    {
                        Store (0x0A, Local1)
                    }
                    Else
                    {
                        Store (BIFL, Local1)
                    }

                    Divide (Multiply (Add (Multiply (Local1, 0x0A), 0x04), DerefOf (
                        Index (BIF2, 0x01))), 0x03E8, Local0, Index (BIF2, 0x06))
                }

                If (Local5)
                {
                    Store (DerefOf (Index (BMST, B2IX)), BUFF)
                    Store (0x07, Local0)
                    Store (Local5, Local2)
                    While (LAnd (Local2, LGreaterEqual (Local0, 0x02)))
                    {
                        Store (Subtract (DerefOf (Index (BUFF, Local0)), 0x30), Local1)
                        Divide (Add (Local1, Local2), 0x0A, Local1, Local2)
                        Store (Add (Local1, 0x30), Index (BUFF, Local0))
                        Decrement (Local0)
                    }

                    Store (BUFF, Index (BIF2, 0x09))
                }
                Else
                {
                    Store (DerefOf (Index (BMNT, B2IX)), Index (BIF2, 0x09))
                }

                Store (B2P, B2PS)
                Store (MKWD (B2LL, B2LH), B2LS)
                Store (B2ID, B2IS)
                Return (BIF2)
            }

            Method (_BST, 0, NotSerialized)
            {
                Store (B2CP, B2RS)
                Store (B2C, B2CS)
                Store (Zero, Local0)
                If (B2P)
                {
                    If (B2C)
                    {
                        Or (Local0, 0x02, Local0)
                    }
                    Else
                    {
                        If (LNot (ACPS))
                        {
                            Or (Local0, One, Local0)
                        }
                    }

                    If (LLessEqual (B2CP, One))
                    {
                        Or (Local0, 0x04, Local0)
                    }
                }

                Store (MKWD (B2CL, B2CH), Local1)
                Divide (Multiply (B2CP, MKWD (B2LL, B2LH)), 0x03E8, Local4, Local2)
                If (Local4)
                {
                    Increment (Local2)
                }

                Multiply (Local2, 0x0A, Local2)
                Store (MKWD (B2VL, B2VH), Local3)
                Store (Local0, Index (BST2, Zero))
                Store (Local1, Index (BST2, One))
                Store (Local2, Index (BST2, 0x02))
                Store (Local3, Index (BST2, 0x03))
                Return (BST2)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (B2P)
                {
                    Return (0x1F)
                }

                Return (0x0F)
            }

            Method (BCHK, 0, NotSerialized)
            {
                If (LNotEqual (B2P, B2PS))
                {
                    Notify (\_SB.CMB2, 0x81)
                    Store (B2P, B2PS)
                }

                If (LNotEqual (B2ID, B2IS))
                {
                    Notify (\_SB.CMB2, 0x81)
                    Store (B2ID, B2IS)
                }

                If (B2PS)
                {
                    Store (MKWD (B2LL, B2LH), Local0)
                    If (LNotEqual (Local0, B2LS))
                    {
                        Notify (\_SB.CMB2, 0x81)
                    }

                    If (LOr (LNotEqual (B2C, B2CS), LNotEqual (B2CP, B2RS)))
                    {
                        Notify (\_SB.CMB2, 0x80)
                    }

                    Store (Local0, B2LS)
                    Store (B2C, B2CS)
                    Store (B2CP, B2RS)
                }
            }
        }

        Device (SLPB)
        {
            Name (_HID, EisaId ("PNP0C0E"))
            Method (_STA, 0, NotSerialized)
            {
                If (FSCM)
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (0x00)
                }
            }
        }
    }

    Scope (_TZ)
    {
        ThermalZone (TZ00)
        {
            Method (_CRT, 0, Serialized)
            {
                Return (Add (0x0AAC, 0x041A))
            }

            Method (_TMP, 0, Serialized)
            {
                If (LGreaterEqual (THMC, 0x78))
                {
                    Return (Add (_CRT (), 0x0A))
                }

                Store (0x9C, CMD)
                Store (0x00, DVID)
                Store (Zero, SSMI)
                If (DTS1)
                {
                    Return (Add (0x0AAC, Multiply (DTS1, 0x0A)))
                }
                Else
                {
                    Return (0x0C3C)
                }
            }

            Method (TCTR, 0, NotSerialized)
            {
                Store (0x9C, CMD)
                Store (0x00, DVID)
                Store (Zero, SSMI)
                If (DTS1)
                {
                    If (LGreaterEqual (DTS1, 0x64))
                    {
                        If (CondRefOf (\_PR.CPU0._PPC, Local0))
                        {
                            If (LNot (\_PR.CPU0._PPC))
                            {
                                Subtract (PSNM, One, \_PR.CPU0._PPC)
                                Notify (\_PR.CPU0, 0x80)
                                If (MPEN)
                                {
                                    Notify (\_PR.CPU1, 0x80)
                                }
                            }
                        }
                    }

                    If (LLessEqual (DTS1, 0x5F))
                    {
                        If (CondRefOf (\_PR.CPU0._PPC, Local0))
                        {
                            If (\_PR.CPU0._PPC)
                            {
                                Store (Zero, \_PR.CPU0._PPC)
                                Notify (\_PR.CPU0, 0x80)
                                If (MPEN)
                                {
                                    Notify (\_PR.CPU1, 0x80)
                                }
                            }
                        }
                    }

                    If (LGreaterEqual (DTS1, 0x64))
                    {
                        Increment (THMC)
                        If (LGreaterEqual (THMC, 0x78))
                        {
                            Notify (\_TZ.TZ00, 0x80)
                        }
                    }
                    Else
                    {
                        Store (Zero, THMC)
                    }
                }
            }

            Method (TPTS, 0, NotSerialized)
            {
                If (CondRefOf (\_PR.CPU0._PPC, Local0))
                {
                    If (\_PR.CPU0._PPC)
                    {
                        Store (Zero, \_PR.CPU0._PPC)
                        Notify (\_PR.CPU0, 0x80)
                        If (MPEN)
                        {
                            Notify (\_PR.CPU1, 0x80)
                        }
                    }
                }
            }
        }

        ThermalZone (TZ01)
        {
            Method (_CRT, 0, Serialized)
            {
                Return (Add (0x0AAC, 0x041A))
            }

            Method (_TMP, 0, Serialized)
            {
                Store (0x9C, CMD)
                Store (0x01, DVID)
                Store (Zero, SSMI)
                If (DTS2)
                {
                    Return (Add (0x0AAC, Multiply (DTS2, 0x0A)))
                }

                Return (0x0C3C)
            }
        }
    }

    Scope (\)
    {
        Method (TZSM, 1, NotSerialized)
        {
            Store (0x9C, CMD)
            Store (Arg0, DVID)
            Store (Zero, SSMI)
        }
    }

    Scope (\_GPE)
    {
        Method (_L02, 0, NotSerialized)
        {
            Store (0x00, GPEC)
            Notify (\_TZ.TZ00, 0x80)
            Notify (\_TZ.TZ01, 0x80)
        }

        Method (_L05, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.HDEF, 0x02)
        }

        Method (_L08, 0, NotSerialized)
        {
        }

        Method (_L09, 0, NotSerialized)
        {
            If (\_SB.PCI0.RP01.PSP1)
            {
                Store (0x01, \_SB.PCI0.RP01.PSP1)
                Store (0x01, \_SB.PCI0.RP01.PMCS)
                Notify (\_SB.PCI0.RP01, 0x02)
            }

            If (\_SB.PCI0.RP02.PSP2)
            {
                Store (0x01, \_SB.PCI0.RP02.PSP2)
                Store (0x01, \_SB.PCI0.RP02.PMCS)
                Notify (\_SB.PCI0.RP02, 0x02)
            }

            If (\_SB.PCI0.RP03.PSP3)
            {
                Store (0x01, \_SB.PCI0.RP03.PSP3)
                Store (0x01, \_SB.PCI0.RP03.PMCS)
                Notify (\_SB.PCI0.RP03, 0x02)
            }
        }

        Method (_L0B, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.PCIB, 0x02)
        }

        Method (_L18, 0, NotSerialized)
        {
            Sleep (0xFA)
            If (LNot (LIDS))
            {
                Store (0x97, CMD)
                Store (Zero, SSMI)
            }

            Not (LPOL, LPOL)
            Store (One, LIDF)
            Notify (\_SB.FEXT, 0x80)
            Notify (\_SB.LID, 0x80)
        }

        Method (_L19, 0, NotSerialized)
        {
            Store (SSF0, Local0)
            Store (Local0, SSF0)
            And (Local0, Not (SSM0), Local0)
            Store (SSF1, Local1)
            Store (Local1, SSF1)
            And (Local1, Not (SSM1), Local1)
            Store (SSF2, Local2)
            Store (Local2, SSF2)
            And (Local2, Not (SSM2), Local2)
            If (And (Local2, 0x10))
            {
                \_SB.AC.ACHK ()
                \_SB.CMB1.BCHK ()
                \_SB.CMB2.BCHK ()
                If (LOr (LNotEqual (LWMD, PLWM), LNotEqual (TALM, PTAL)))
                {
                    Store (LWMD, PLWM)
                    Store (TALM, PTAL)
                    Store (0x95, CMD)
                    Or (PLWM, ShiftLeft (PTAL, 0x01), DVID)
                    Store (Zero, SSMI)
                }

                If (LAnd (TALM, LNot (ACPW)))
                {
                    Store (One, FOCT)
                }
                Else
                {
                    Store (Zero, FOCT)
                }
            }

            If (And (Local0, 0x01))
            {
                \_SB.PCI0.GFX0.PHTK ()
                Store (0x80, CMD)
                Store (Zero, SSMI)
                \_SB.PCI0.GFX0.AHTK ()
                If (BSWF)
                {
                    If (LGreaterEqual (\_SB.OSTP (), 0x40))
                    {
                        \_SB.PCI0.GFX0.LCD.BLNF ()
                    }
                }

                If (LOr (AHKF, VLBF))
                {
                    Notify (\_SB.PCI0.LPCB.FJEX, 0x80)
                }

                If (IRBF)
                {
                    If (LEqual (IRBC, 0xFD00))
                    {
                        Store (One, GINT)
                    }
                    Else
                    {
                        \_SB.FEXT.SIRB (IRBC)
                    }

                    Notify (\_SB.FEXT, 0x80)
                    Store (Zero, IRBF)
                }
            }

            If (And (Local1, 0x30))
            {
                Store (One, WSEF)
                Notify (\_SB.FEXT, 0x80)
                \_SB.PCI0.LPCB.CMBT.SWCF ()
            }

            If (And (Local2, 0x08))
            {
                Store (B1SU, Local3)
                Store (B1SD, Local4)
                Store (TBSF, Local5)
                Store (B2SU, Local6)
                Store (B2SD, Local7)
                Store (Zero, STAE)
                If (LAnd (Local3, LNot (B1TC)))
                {
                    If (LNot (CPBL))
                    {
                        \_SB.PCI0.PATA.PRIM.MAST.BOFF ()
                        Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
                    }
                }

                If (Local5)
                {
                    If (LEqual (TIMB, 0x0A))
                    {
                        Store (Zero, Local5)
                        \_TZ.TZ00.TCTR ()
                    }

                    Store (0x01, TBSM)
                    Store (0x00, TBSF)
                    Store (0x0A, TIMB)
                }

                If (LOr (LAnd (Local4, B1TC), Local5))
                {
                    If (LEqual (BY1I, 0x0C))
                    {
                        Store (One, BY1O)
                    }
                    Else
                    {
                        If (LNot (Or (DPCS, CPBL)))
                        {
                            \_SB.PCI0.PATA.PRIM.MAST.BON ()
                            If (LAnd (LAnd (BRST, BY1O), B1TC))
                            {
                                Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
                            }
                        }
                    }
                }

                If (LOr (Local6, Local7))
                {
                    Sleep (0x03E8)
                    Store (Zero, B2SU)
                    Store (Zero, B2SD)
                    \_SB.PCI0.LPCB.PRCF ()
                    Store (One, PREF)
                    Notify (\_SB.FEXT, 0x80)
                    If (RPEN)
                    {
                        If (LNotEqual (B2TC, RPDS))
                        {
                            Store (B2TC, RPDS)
                            If (RPDS)
                            {
                                Notify (\_SB.REPL, Zero)
                            }
                            Else
                            {
                                Sleep (0x0FA0)
                                Notify (\_SB.REPL, One)
                            }
                        }
                    }
                }
            }
        }

        Method (_L1D, 0, NotSerialized)
        {
            If (EXPL)
            {
                \_SB.PCI0.RP02.PXS2.EXIN ()
            }
            Else
            {
                \_SB.PCI0.RP02.PXS2.EXRM ()
            }

            Sleep (0x64)
            Notify (\_SB.PCI0.RP02, Zero)
        }
    }

    Name (_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (_S3, Package (0x04)
    {
        0x05, 
        0x05, 
        0x00, 
        0x00
    })
    Name (_S4, Package (0x04)
    {
        0x06, 
        0x06, 
        0x00, 
        0x00
    })
    Name (_S5, Package (0x04)
    {
        0x07, 
        0x07, 
        0x00, 
        0x00
    })
    Method (_PTS, 1, NotSerialized)
    {
        Add (0xDD, Arg0, PO80)
        If (LAnd (LGreaterEqual (Arg0, One), LLessEqual (Arg0, 0x04)))
        {
            If (LNot (CPBL))
            {
                If (\_SB.PCI0.PATA.PRIM.MAST._STA ())
                {
                    Store (Zero, BYIS)
                }
                Else
                {
                    Store (0xFF, BYIS)
                }
            }

            If (RPEN)
            {
                Store (RPDS, DC1S)
            }

            If (\_SB.PCI0.RP02.PXS2._STA ())
            {
                Store (Zero, EXIS)
            }
            Else
            {
                Store (0xFF, EXIS)
            }
        }

        \_SB.PCI0.LPCB.CMBT.BPTS (Arg0)
        Store (Zero, WAPB)
        Store (One, HDWA)
        \_TZ.TZ00.TPTS ()
        Add (0xE0, Arg0, PO80)
    }

    Method (_WAK, 1, NotSerialized)
    {
        Add (0xEE, Arg0, PO80)
        \_SB.PCI0.LPCB.AINI ()
        \_SB.PCI0.PCIB._INI ()
        \_SB.FEXT._INI ()
        If (LEqual (Arg0, 0x03))
        {
            Store (0xA3, CMD)
            Store (0x00, INF)
            Store (Zero, SSMI)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (0x9B, CMD)
            Store (0x04, DVID)
            Store (Zero, SSMI)
        }

        If (WAPB)
        {
            Notify (\_SB.PWRB, 0x02)
        }

        If (LEqual (Arg0, 0x04))
        {
            \_SB.FEXT.FUNC (0x1002, 0x03, Ones, WBTN)
        }

        \_SB.PCI0.LPCB.CMBT.BWAK (Arg0)
        If (LAnd (LGreaterEqual (Arg0, One), LLessEqual (Arg0, 0x04)))
        {
            If (LNot (CPBL))
            {
                If (LEqual (BYIS, 0xFF))
                {
                    If (\_SB.PCI0.PATA.PRIM.MAST.BIDE ())
                    {
                        If (DPCS)
                        {
                            \_SB.PCI0.PATA.PRIM.MAST.BOFF ()
                        }
                        Else
                        {
                            If (LNot (\_SB.PCI0.PATA.PRIM.MAST._STA ()))
                            {
                                \_SB.PCI0.PATA.PRIM.MAST.BON ()
                            }

                            If (LAnd (LAnd (BRST, BY1O), B1TC))
                            {
                                Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
                            }
                        }
                    }
                }
                Else
                {
                    If (LNot (\_SB.PCI0.PATA.PRIM.MAST._STA ()))
                    {
                        \_SB.PCI0.PATA.PRIM.MAST.TMCL ()
                        Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
                    }
                    Else
                    {
                        If (LEqual (Arg0, 0x04))
                        {
                            Store (0x87, CMD)
                            Store (Zero, DVID)
                            Store (Zero, SSMI)
                            Name (BFMN, Buffer (0x28) {})
                            Store (PIID, BFMN)
                            Store (Zero, Local0)
                            Store (Zero, Local1)
                            While (LAnd (LNot (Local0), LLess (Local1, 0x28)))
                            {
                                If (LEqual (DerefOf (Index (\_SB.PCI0.PATA.PMMN, Local1)), DerefOf (Index (BFMN, 
                                    Local1))))
                                {
                                    Increment (Local1)
                                }
                                Else
                                {
                                    Store (0x01, Local0)
                                }
                            }

                            If (Local0)
                            {
                                \_SB.PCI0.PATA.PRIM.MAST.BOFF ()
                                Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
                            }
                        }
                    }

                    If (LAnd (\_SB.PCI0.PATA.PRIM.MAST.BIDE (), LNot (\_SB.PCI0.PATA.PRIM.MAST._STA ())))
                    {
                        Store (0x01, TBSM)
                        Store (0x00, TBSF)
                        Store (0x1E, TIMB)
                    }
                }
            }

            \_SB.PCI0.LPCB.PRCF ()
            If (RPEN)
            {
                If (LNotEqual (B2TC, DC1S))
                {
                    Store (B2TC, RPDS)
                    If (RPDS)
                    {
                        Notify (\_SB.REPL, Zero)
                    }
                    Else
                    {
                        Notify (\_SB.REPL, One)
                    }
                }
            }

            If (\_SB.PCI0.RP02.PXS2._STA ())
            {
                If (EXIS)
                {
                    Notify (\_SB.PCI0.RP02, Zero)
                }
            }
            Else
            {
                If (LNot (EXIS))
                {
                    Notify (\_SB.PCI0.RP02, Zero)
                }
            }

            If (NGTM)
            {
                \_SB.FEXT.FUNC (0x1004, 0x01, 0x04, 0x00)
            }
        }

        \_SB.CMB1.BCHK ()
        \_SB.CMB2.BCHK ()
        Add (0xF0, Arg0, PO80)
        Return (Zero)
    }
}