/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20030619
 *
 * Disassembly of cf-r1n.dsdt, Sat Sep  6 13:58:29 2003
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "MATBIO", "CFR1-3", 100925440)
{
    Scope (_SB)
    {
        OperationRegion (SMI0, SystemIO, 0x0000FE00, 0x00000002)
        Field (SMI0, AnyAcc, NoLock, Preserve)
        {
            SMIC,   8
        }

        OperationRegion (SMI1, SystemMemory, 0x1F77FD4D, 0x00000200)
        Field (SMI1, AnyAcc, NoLock, Preserve)
        {
            BCMD,   8, 
            DID,    32, 
            INFO,   4056
        }

        Field (SMI1, AnyAcc, NoLock, Preserve)
        {
            Offset (0x05), 
            INF,    8
        }

        Field (SMI1, AnyAcc, NoLock, Preserve)
        {
            Offset (0x05), 
            INFD,   32
        }

        Field (SMI1, AnyAcc, NoLock, Preserve)
        {
            Offset (0x05), 
            INFP,   128
        }

        Mutex (PSMX, 0x01)
        Method (PSRV, 5, Serialized)
        {
            Acquire (PSMX, 0xFFFF)
            If (Arg2)
            {
                Store (Arg3, INFO)
            }

            Store (Arg1, DID)
            Store (Arg0, BCMD)
            Store (0x00, SMIC)
            If (LEqual (Arg4, 0x00))
            {
                Store (Zero, Local0)
            }
            Else
            {
                If (LEqual (Arg4, 0x01))
                {
                    Store (INF, Local0)
                }
                Else
                {
                    If (LEqual (Arg4, 0x03))
                    {
                        Store (INFD, Local0)
                    }
                    Else
                    {
                        If (LEqual (Arg4, 0x04))
                        {
                            Store (INFP, Local0)
                        }
                        Else
                        {
                            Store (INFO, Local0)
                        }
                    }
                }
            }

            Release (PSMX)
            Return (Local0)
        }

        Method (ECRD, 1, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            Return (PSRV (0x98, Local0, 0x00, 0x00, 0x01))
        }

        Method (ECER, 1, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            Return (PSRV (0xB2, Local0, 0x00, 0x00, 0x01))
        }

        Method (ECR2, 1, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            Return (PSRV (0x9A, Local0, 0x00, 0x00, 0x03))
        }

        Method (ECMD, 3, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            And (Arg1, 0xFF, Local1)
            And (Arg2, 0xFF, Local2)
            PSRV (0x99, Add (Add (Local0, ShiftLeft (Local1, 0x08)), ShiftLeft (Local2, 0x10)), 0x00, 0x00, 0x00)
        }

        Method (ECWR, 2, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            And (Arg1, 0xFF, Local1)
            PSRV (0x99, Add (Local0, ShiftLeft (Local1, 0x10)), 0x00, 0x00, 0x00)
        }

        Method (ECEW, 2, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            PSRV (0xB3, Local0, 0x01, Arg1, 0x00)
        }

        Method (ECW4, 2, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            PSRV (0xA2, Local0, 0x01, Arg1, 0x00)
        }

        Method (ECW2, 2, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            PSRV (0xA3, Local0, 0x01, Arg1, 0x00)
        }

        Method (ECRB, 1, NotSerialized)
        {
            Store (\_SB.ECR2 (Arg0), Local0)
            If (And (Local0, 0x8000))
            {
                Or (0xFFFF0000, Local0, Local0)
            }

            Return (Local0)
        }

        Method (RRTC, 1, NotSerialized)
        {
            And (Arg0, 0xFF, Local0)
            Return (PSRV (0xAF, Local0, 0x00, 0x00, 0x01))
        }
    }

    Scope (_SB)
    {
        Method (ECPF, 3, NotSerialized)
        {
            If (LEqual (Arg0, 0x0100))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC01 ())
            }

            If (LEqual (Arg0, 0x0101))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC02 (Arg1))
            }

            If (LEqual (Arg0, 0x0110))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC03 (Arg1, Arg2))
            }

            If (LEqual (Arg0, 0x0111))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC04 (Arg1, Arg2))
            }

            If (LEqual (Arg0, 0x0112))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC05 (Arg1, Arg2))
            }

            If (LEqual (Arg0, 0x0200))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC06 ())
            }

            If (LEqual (Arg0, 0x0201))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC07 ())
            }

            If (LEqual (Arg0, 0x0202))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC08 ())
            }

            If (LEqual (Arg0, 0x0203))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC09 ())
            }

            If (LEqual (Arg0, 0x0204))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC0A ())
            }

            If (LEqual (Arg0, 0x0205))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC0B (Arg1))
            }

            If (LEqual (Arg0, 0x0206))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC0C (Arg1))
            }

            If (LEqual (Arg0, 0x0207))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC0D (Arg1))
            }

            If (LEqual (Arg0, 0x0208))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC0E (Arg1))
            }

            If (LEqual (Arg0, 0x0209))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC0F (Arg1))
            }

            If (LEqual (Arg0, 0x020A))
            {
                Return (\_SB.PCI0.LPC0.EC0.EC10 (Arg1, Arg2))
            }

            Return (0xFFFFFFFF)
        }
    }

    Scope (\_SB)
    {
        Name (CRUN, Zero)
        Method (CRST, 0, NotSerialized)
        {
            If (CRUN)
            {
                Store (Zero, \_SB.PCI0.LPC0.CREN)
            }
            Else
            {
                Store (One, \_SB.PCI0.LPC0.CREN)
            }
        }

        Method (CRIN, 0, NotSerialized)
        {
            If (LNot (PSRV (0xB8, Zero, Zero, Zero, One)))
            {
                Or (CRUN, One, CRUN)
            }

            CRST ()
        }

        Method (CRCT, 2, NotSerialized)
        {
            If (Arg1)
            {
                And (CRUN, Not (Arg0), CRUN)
            }
            Else
            {
                Or (CRUN, Arg0, CRUN)
            }

            CRST ()
        }
    }

    Scope (_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06)
        {
            Method (_CST, 0, NotSerialized)
            {
                Return (Package (0x04)
                {
                    0x03, 
                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
                        }, 

                        0x01, 
                        0x01, 
                        0x03E8
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001014)
                        }, 

                        0x02, 
                        0x01, 
                        0x01F4
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001015)
                        }, 

                        0x03, 
                        0xB9, 
                        0x64
                    }
                })
            }

            Name (_PCT, Package (0x02)
            {
                ResourceTemplate ()
                {
                    Register (SystemIO, 0x08, 0x00, 0x00000000000000B2)
                }, 

                ResourceTemplate ()
                {
                    Register (SystemIO, 0x08, 0x00, 0x0000000000001050)
                }
            })
            Name (_PSS, Package (0x02)
            {
                Package (0x06)
                {
                    0x0362, 
                    0x2008, 
                    0xFA, 
                    0xDC, 
                    0x83, 
                    0x00
                }, 

                Package (0x06)
                {
                    0x0190, 
                    0x11F8, 
                    0xFA, 
                    0xDC, 
                    0x84, 
                    0x01
                }
            })
            Method (_PPC, 0, NotSerialized)
            {
                Return (0x00)
            }
        }
    }

    Method (MIN, 2, NotSerialized)
    {
        If (LLess (Arg0, Arg1))
        {
            Return (Arg0)
        }
        Else
        {
            Return (Arg1)
        }
    }

    Method (SLEN, 1, NotSerialized)
    {
        Return (SizeOf (Arg0))
    }

    Method (S2BF, 1, Serialized)
    {
        Add (SLEN (Arg0), One, Local0)
        Name (BUFF, Buffer (Local0) {})
        Store (Arg0, BUFF)
        Return (BUFF)
    }

    Method (SCMP, 2, NotSerialized)
    {
        Store (S2BF (Arg0), Local0)
        Store (S2BF (Arg1), Local1)
        Store (Zero, Local4)
        Store (SLEN (Arg0), Local5)
        Store (SLEN (Arg1), Local6)
        Store (MIN (Local5, Local6), Local7)
        While (LLess (Local4, Local7))
        {
            Store (DerefOf (Index (Local0, Local4)), Local2)
            Store (DerefOf (Index (Local1, Local4)), Local3)
            If (LGreater (Local2, Local3))
            {
                Return (One)
            }
            Else
            {
                If (LLess (Local2, Local3))
                {
                    Return (Ones)
                }
            }

            Increment (Local4)
        }

        If (LLess (Local4, Local5))
        {
            Return (One)
        }
        Else
        {
            If (LLess (Local4, Local6))
            {
                Return (Ones)
            }
            Else
            {
                Return (Zero)
            }
        }
    }

    Name (OSID, 0x00)
    Method (CKOS, 0, NotSerialized)
    {
        If (OSID)
        {
            Return (OSID)
        }

        If (CondRefOf (\_OSI, Local0))
        {
            Store (0x82, OSID)
        }
        Else
        {
            If (LEqual (SCMP (\_OS, "Microsoft Windows NT"), Zero))
            {
                Store (0x81, OSID)
            }
            Else
            {
                If (LEqual (SCMP (\_OS, "Microsoft Windows"), Zero))
                {
                    Store (0x01, OSID)
                }
                Else
                {
                    If (LEqual (SCMP (\_OS, "Microsoft WindowsME: Millennium Edition"), Zero))
                    {
                        Store (0x02, OSID)
                    }
                    Else
                    {
                        Store (0xFF, OSID)
                    }
                }
            }
        }

        Return (OSID)
    }

    Method (SPOS, 0, NotSerialized)
    {
        Return (And (CKOS (), 0x80))
    }

    Scope (\_TZ)
    {
        ThermalZone (TZC)
        {
            Name (INIT, 0x00)
            Name (CSCP, 0x00)
            Name (PSV, 0x0DCA)
            Name (CRT, 0x0E2E)
            Method (INIP, 0, NotSerialized)
            {
                If (LEqual (INIT, 0x00))
                {
                    Store (\_SB.ECPF (0x0204, 0x00, 0x00), CRT)
                    Store (\_SB.ECPF (0x0203, 0x00, 0x00), PSV)
                    Store (\_SB.ECPF (0x0202, 0x00, 0x00), _TC2)
                    Store (One, INIT)
                }
            }

            Name (_TC1, 0x00)
            Name (_TC2, 0x0C)
            Name (_TSP, 0x28)
            Method (_TMP, 0, NotSerialized)
            {
                Return (\_SB.ECPF (0x0201, 0x00, 0x00))
            }

            Method (_PSV, 0, NotSerialized)
            {
                \_TZ.TZC.INIP ()
                Return (PSV)
            }

            Name (_PSL, Package (0x01)
            {
                \_PR.CPU0
            })
            Method (_CRT, 0, NotSerialized)
            {
                \_TZ.TZC.INIP ()
                Return (CRT)
            }

            Method (_SCP, 1, NotSerialized)
            {
                Store (Arg0, CSCP)
                Store (Zero, INIT)
                \_TZ.TZC.INIP ()
                Notify (\_TZ.TZC, 0x81)
            }
        }
    }

    Name (_S0, Package (0x03)
    {
        0x00, 
        0x00, 
        0x00
    })
    Name (_S3, Package (0x03)
    {
        0x05, 
        0x05, 
        0x00
    })
    Name (_S4, Package (0x03)
    {
        0x06, 
        0x06, 
        0x00
    })
    Name (_S5, Package (0x03)
    {
        0x07, 
        0x07, 
        0x00
    })
    Name (\_SB.BAST, 0x00)
    Name (\_SB.BBST, 0x00)
    Name (FWSO, "FWSO")
    Method (_PTS, 1, NotSerialized)
    {
        \_SB.CRCT (0x02, Zero)
        If (LNot (LEqual (Arg0, 0x05)))
        {
            \_SB.PSRV (0xB1, 0x00, 0x00, 0x00, 0x00)
        }

        If (LEqual (Arg0, 0x03))
        {
            \_SB.PSRV (0xC7, \_SB.PCI0.SMDM.MPSW, 0x00, 0x00, 0x00)
            \_SB.PSRV (0x90, 0x00, 0x00, 0x00, 0x00)
            \_SB.PSRV (0x91, 0x10, 0x00, 0x00, 0x00)
            \_SB.PSRV (0x91, 0x40, 0x00, 0x00, 0x00)
        }

        If (LEqual (Arg0, 0x04))
        {
            \_SB.PCI0.IDEC.SVS4 ()
            \_SB.PSRV (0x9E, 0x00, 0x00, 0x00, 0x00)
        }

        If (LEqual (Arg0, 0x05))
        {
            \_SB.PSRV (0x95, 0x00, 0x00, 0x00, 0x00)
        }

        If (LAnd (LNot (LLess (Arg0, 0x03)), LNot (LGreater (Arg0, 0x05))))
        {
            \_SB.HKEY.HSAV ()
        }

        Store (\_SB.ECPF (0x0101, 0x00, 0x00), \_SB.BAST)
        \_SB.ECPF (0x0206, Arg0, 0x00)
    }

    Method (_WAK, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x01))
        {
            \_SB.PSRV (0xA4, 0x00, 0x00, 0x00, 0x00)
        }

        If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x03)))
        {
            Store (\_SB.PSRV (0xA9, 0x00, 0x00, 0x00, 0x03), Local0)
            If (LOr (LEqual (Local0, 0x06), LEqual (Local0, 0x01)))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        If (LAnd (LNot (LLess (Arg0, 0x03)), LNot (LGreater (Arg0, 0x05))))
        {
            \_SB.HKEY.HRES ()
        }

        \_SB.PSRV (0x92, 0x10, 0x00, 0x00, 0x00)
        \_SB.PSRV (0x92, 0x40, 0x00, 0x00, 0x00)
        \_SB.ECPF (0x0206, 0x00, 0x00)
        Store (\_SB.ECPF (0x0101, 0x00, 0x00), Local0)
        If (XOr (\_SB.BAST, Local0))
        {
            If (LEqual (Local0, 0x01))
            {
                Notify (\_SB.BATA, 0x00)
            }
            Else
            {
                Notify (\_SB.BATA, 0x01)
            }

            \_SB.PCI0.LPC0.EC0._INI ()
        }

        \_SB.CRCT (0x02, One)
        \_SB.CSTS (0x00)
        Return (Package (0x02)
        {
            0x00, 
            0x00
        })
    }

    Scope (\_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            If (LAnd (LNot (LEqual (Arg0, 0x04)), LNot (LEqual (Arg0, 0x00))))
            {
                \_SB.PSRV (0x93, Arg0, 0x00, 0x00, 0x00)
            }
        }
    }

    Scope (_GPE)
    {
        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
        }

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

        Method (_L1B, 0, NotSerialized)
        {
            Notify (\_SB.PWRB, 0x02)
        }

        Method (_L1D, 0, NotSerialized)
        {
        }
    }

    Scope (_SB)
    {
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_BBN, 0x00)
            Method (_INI, 0, NotSerialized)
            {
                \_SB.PSRV (0xCB, 0x00, 0x00, 0x00, 0x00)
            }

            Name (_ADR, 0x00)
            OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
            Field (HBUS, DWordAcc, NoLock, Preserve)
            {
                Offset (0x18), 
                    ,   7, 
                HENA,   1, 
                    ,   4, 
                PM0H,   2, 
                Offset (0x1A), 
                PM1L,   2, 
                    ,   2, 
                PM1H,   2, 
                Offset (0x1B), 
                PM2L,   2, 
                    ,   2, 
                PM2H,   2, 
                Offset (0x1C), 
                PM3L,   2, 
                    ,   2, 
                PM3H,   2, 
                Offset (0x1D), 
                PM4L,   2, 
                    ,   2, 
                PM4H,   2, 
                Offset (0x1E), 
                PM5L,   2, 
                    ,   2, 
                PM5H,   2, 
                Offset (0x1F), 
                PM6L,   2, 
                    ,   2, 
                PM6H,   2, 
                Offset (0x20), 
                DRB0,   8, 
                DRB1,   8, 
                DRB2,   8, 
                DRB3,   8, 
                DRB4,   8, 
                DRB5,   8, 
                DRB6,   8, 
                DRB7,   8, 
                Offset (0x30), 
                DRA0,   3, 
                    ,   1, 
                DRA1,   3, 
                Offset (0x31), 
                DRA2,   3, 
                    ,   1, 
                DRA3,   3, 
                Offset (0x32), 
                DRA4,   3, 
                    ,   1, 
                DRA5,   3, 
                Offset (0x33), 
                DRA6,   3, 
                    ,   1, 
                DRA7,   3, 
                Offset (0x34)
            }

            Name (BUF0, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,
                    0x0000,
                    0x00FF,
                    0x0000,
                    0x0100, 0x00)
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,
                    0x00000000,
                    0x00000CF7,
                    0x00000000,
                    0x00000CF8, 0x00)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,
                    0x00000D00,
                    0x0000FFFF,
                    0x00000000,
                    0x0000F300, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000A0000,
                    0x000BFFFF,
                    0x00000000,
                    0x00020000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C0000,
                    0x000C3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C4000,
                    0x000C7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C8000,
                    0x000CBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000CC000,
                    0x000CFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D0000,
                    0x000D3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D4000,
                    0x000D7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D8000,
                    0x000DBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000DC000,
                    0x000DFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E0000,
                    0x000E3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E4000,
                    0x000E7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E8000,
                    0x000EBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000EC000,
                    0x000EFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000F0000,
                    0x000FFFFF,
                    0x00000000,
                    0x00010000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x00000000,
                    0xFEBFFFFF,
                    0x00000000,
                    0x00000000, 0x00)
            })
            Method (_CRS, 0, Serialized)
            {
                If (PM1L)
                {
                    CreateDWordField (BUF0, 0x80, C0LN)
                    Store (Zero, C0LN)
                }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                CreateDWordField (BUF0, 0x01D3, M1MN)
                CreateDWordField (BUF0, 0x01D7, M1MX)
                CreateDWordField (BUF0, 0x01DF, M1LN)
                Multiply (0x02000000, DRB5, M1MN)
                Add (Subtract (M1MX, M1MN), 0x01, M1LN)
                Return (BUF0)
            }

            Name (_PRT, Package (0x06)
            {
                Package (0x04)
                {
                    0x001FFFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKB, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x01, 
                    \_SB.PCI0.LPC0.LNKD, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.LPC0.LNKA, 
                    0x00
                }
            })
            OperationRegion (GMCH, PCI_Config, 0x00, 0xC0)
            Field (GMCH, DWordAcc, NoLock, Preserve)
            {
                Offset (0x08), 
                RID,    8
            }

            Device (FIGD)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    If (And (CKOS (), 0x80))
                    {
                        If (LNot (LGreater (\_SB.PCI0.RID, 0x03)))
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16, 0x07B0, 0x07B0, 0x01, 0x0C)
                    IO (Decode16, 0x07C0, 0x07C0, 0x01, 0x20)
                    IO (Decode16, 0x0BB0, 0x0BB0, 0x01, 0x0C)
                    IO (Decode16, 0x0BC0, 0x0BC0, 0x01, 0x20)
                    IO (Decode16, 0x0FB0, 0x0FB0, 0x01, 0x0C)
                    IO (Decode16, 0x0FC0, 0x0FC0, 0x01, 0x20)
                    IO (Decode16, 0x13B0, 0x13B0, 0x01, 0x0C)
                    IO (Decode16, 0x13C0, 0x13C0, 0x01, 0x20)
                    IO (Decode16, 0x17B0, 0x17B0, 0x01, 0x0C)
                    IO (Decode16, 0x17C0, 0x17C0, 0x01, 0x20)
                    IO (Decode16, 0x1BB0, 0x1BB0, 0x01, 0x0C)
                    IO (Decode16, 0x1BC0, 0x1BC0, 0x01, 0x20)
                    IO (Decode16, 0x1FB0, 0x1FB0, 0x01, 0x0C)
                    IO (Decode16, 0x1FC0, 0x1FC0, 0x01, 0x20)
                    IO (Decode16, 0x23B0, 0x23B0, 0x01, 0x0C)
                    IO (Decode16, 0x23C0, 0x23C0, 0x01, 0x20)
                    IO (Decode16, 0x27B0, 0x27B0, 0x01, 0x0C)
                    IO (Decode16, 0x27C0, 0x27C0, 0x01, 0x20)
                    IO (Decode16, 0x2BB0, 0x2BB0, 0x01, 0x0C)
                    IO (Decode16, 0x2BC0, 0x2BC0, 0x01, 0x20)
                    IO (Decode16, 0x2FB0, 0x2FB0, 0x01, 0x0C)
                    IO (Decode16, 0x2FC0, 0x2FC0, 0x01, 0x20)
                    IO (Decode16, 0x33B0, 0x33B0, 0x01, 0x0C)
                    IO (Decode16, 0x33C0, 0x33C0, 0x01, 0x20)
                    IO (Decode16, 0x37B0, 0x37B0, 0x01, 0x0C)
                    IO (Decode16, 0x37C0, 0x37C0, 0x01, 0x20)
                    IO (Decode16, 0x3BB0, 0x3BB0, 0x01, 0x0C)
                    IO (Decode16, 0x3BC0, 0x3BC0, 0x01, 0x20)
                    IO (Decode16, 0x3FB0, 0x3FB0, 0x01, 0x0C)
                    IO (Decode16, 0x3FC0, 0x3FC0, 0x01, 0x20)
                    IO (Decode16, 0x43B0, 0x43B0, 0x01, 0x0C)
                    IO (Decode16, 0x43C0, 0x43C0, 0x01, 0x20)
                    IO (Decode16, 0x47B0, 0x47B0, 0x01, 0x0C)
                    IO (Decode16, 0x47C0, 0x47C0, 0x01, 0x20)
                    IO (Decode16, 0x4BB0, 0x4BB0, 0x01, 0x0C)
                    IO (Decode16, 0x4BC0, 0x4BC0, 0x01, 0x20)
                    IO (Decode16, 0x4FB0, 0x4FB0, 0x01, 0x0C)
                    IO (Decode16, 0x4FC0, 0x4FC0, 0x01, 0x20)
                    IO (Decode16, 0x53B0, 0x53B0, 0x01, 0x0C)
                    IO (Decode16, 0x53C0, 0x53C0, 0x01, 0x20)
                    IO (Decode16, 0x57B0, 0x57B0, 0x01, 0x0C)
                    IO (Decode16, 0x57C0, 0x57C0, 0x01, 0x20)
                    IO (Decode16, 0x5BB0, 0x5BB0, 0x01, 0x0C)
                    IO (Decode16, 0x5BC0, 0x5BC0, 0x01, 0x20)
                    IO (Decode16, 0x5FB0, 0x5FB0, 0x01, 0x0C)
                    IO (Decode16, 0x5FC0, 0x5FC0, 0x01, 0x20)
                    IO (Decode16, 0x63B0, 0x63B0, 0x01, 0x0C)
                    IO (Decode16, 0x63C0, 0x63C0, 0x01, 0x20)
                    IO (Decode16, 0x67B0, 0x67B0, 0x01, 0x0C)
                    IO (Decode16, 0x67C0, 0x67C0, 0x01, 0x20)
                    IO (Decode16, 0x6BB0, 0x6BB0, 0x01, 0x0C)
                    IO (Decode16, 0x6BC0, 0x6BC0, 0x01, 0x20)
                    IO (Decode16, 0x6FB0, 0x6FB0, 0x01, 0x0C)
                    IO (Decode16, 0x6FC0, 0x6FC0, 0x01, 0x20)
                    IO (Decode16, 0x73B0, 0x73B0, 0x01, 0x0C)
                    IO (Decode16, 0x73C0, 0x73C0, 0x01, 0x20)
                    IO (Decode16, 0x77B0, 0x77B0, 0x01, 0x0C)
                    IO (Decode16, 0x77C0, 0x77C0, 0x01, 0x20)
                    IO (Decode16, 0x7BB0, 0x7BB0, 0x01, 0x0C)
                    IO (Decode16, 0x7BC0, 0x7BC0, 0x01, 0x20)
                    IO (Decode16, 0x7FB0, 0x7FB0, 0x01, 0x0C)
                    IO (Decode16, 0x7FC0, 0x7FC0, 0x01, 0x20)
                    IO (Decode16, 0x83B0, 0x83B0, 0x01, 0x0C)
                    IO (Decode16, 0x83C0, 0x83C0, 0x01, 0x20)
                    IO (Decode16, 0x87B0, 0x87B0, 0x01, 0x0C)
                    IO (Decode16, 0x87C0, 0x87C0, 0x01, 0x20)
                    IO (Decode16, 0x8BB0, 0x8BB0, 0x01, 0x0C)
                    IO (Decode16, 0x8BC0, 0x8BC0, 0x01, 0x20)
                    IO (Decode16, 0x8FB0, 0x8FB0, 0x01, 0x0C)
                    IO (Decode16, 0x8FC0, 0x8FC0, 0x01, 0x20)
                    IO (Decode16, 0x93B0, 0x93B0, 0x01, 0x0C)
                    IO (Decode16, 0x93C0, 0x93C0, 0x01, 0x20)
                    IO (Decode16, 0x97B0, 0x97B0, 0x01, 0x0C)
                    IO (Decode16, 0x97C0, 0x97C0, 0x01, 0x20)
                    IO (Decode16, 0x9BB0, 0x9BB0, 0x01, 0x0C)
                    IO (Decode16, 0x9BC0, 0x9BC0, 0x01, 0x20)
                    IO (Decode16, 0x9FB0, 0x9FB0, 0x01, 0x0C)
                    IO (Decode16, 0x9FC0, 0x9FC0, 0x01, 0x20)
                    IO (Decode16, 0xA3B0, 0xA3B0, 0x01, 0x0C)
                    IO (Decode16, 0xA3C0, 0xA3C0, 0x01, 0x20)
                    IO (Decode16, 0xA7B0, 0xA7B0, 0x01, 0x0C)
                    IO (Decode16, 0xA7C0, 0xA7C0, 0x01, 0x20)
                    IO (Decode16, 0xABB0, 0xABB0, 0x01, 0x0C)
                    IO (Decode16, 0xABC0, 0xABC0, 0x01, 0x20)
                    IO (Decode16, 0xAFB0, 0xAFB0, 0x01, 0x0C)
                    IO (Decode16, 0xAFC0, 0xAFC0, 0x01, 0x20)
                    IO (Decode16, 0xB3B0, 0xB3B0, 0x01, 0x0C)
                    IO (Decode16, 0xB3C0, 0xB3C0, 0x01, 0x20)
                    IO (Decode16, 0xB7B0, 0xB7B0, 0x01, 0x0C)
                    IO (Decode16, 0xB7C0, 0xB7C0, 0x01, 0x20)
                    IO (Decode16, 0xBBB0, 0xBBB0, 0x01, 0x0C)
                    IO (Decode16, 0xBBC0, 0xBBC0, 0x01, 0x20)
                    IO (Decode16, 0xBFB0, 0xBFB0, 0x01, 0x0C)
                    IO (Decode16, 0xBFC0, 0xBFC0, 0x01, 0x20)
                    IO (Decode16, 0xC3B0, 0xC3B0, 0x01, 0x0C)
                    IO (Decode16, 0xC3C0, 0xC3C0, 0x01, 0x20)
                    IO (Decode16, 0xC7B0, 0xC7B0, 0x01, 0x0C)
                    IO (Decode16, 0xC7C0, 0xC7C0, 0x01, 0x20)
                    IO (Decode16, 0xCBB0, 0xCBB0, 0x01, 0x0C)
                    IO (Decode16, 0xCBC0, 0xCBC0, 0x01, 0x20)
                    IO (Decode16, 0xCFB0, 0xCFB0, 0x01, 0x0C)
                    IO (Decode16, 0xCFC0, 0xCFC0, 0x01, 0x20)
                    IO (Decode16, 0xD3B0, 0xD3B0, 0x01, 0x0C)
                    IO (Decode16, 0xD3C0, 0xD3C0, 0x01, 0x20)
                    IO (Decode16, 0xD7B0, 0xD7B0, 0x01, 0x0C)
                    IO (Decode16, 0xD7C0, 0xD7C0, 0x01, 0x20)
                    IO (Decode16, 0xDBB0, 0xDBB0, 0x01, 0x0C)
                    IO (Decode16, 0xDBC0, 0xDBC0, 0x01, 0x20)
                    IO (Decode16, 0xDFB0, 0xDFB0, 0x01, 0x0C)
                    IO (Decode16, 0xDFC0, 0xDFC0, 0x01, 0x20)
                    IO (Decode16, 0xE3B0, 0xE3B0, 0x01, 0x0C)
                    IO (Decode16, 0xE3C0, 0xE3C0, 0x01, 0x20)
                    IO (Decode16, 0xE7B0, 0xE7B0, 0x01, 0x0C)
                    IO (Decode16, 0xE7C0, 0xE7C0, 0x01, 0x20)
                    IO (Decode16, 0xEBB0, 0xEBB0, 0x01, 0x0C)
                    IO (Decode16, 0xEBC0, 0xEBC0, 0x01, 0x20)
                    IO (Decode16, 0xEFB0, 0xEFB0, 0x01, 0x0C)
                    IO (Decode16, 0xEFC0, 0xEFC0, 0x01, 0x20)
                    IO (Decode16, 0xF3B0, 0xF3B0, 0x01, 0x0C)
                    IO (Decode16, 0xF3C0, 0xF3C0, 0x01, 0x20)
                    IO (Decode16, 0xF7B0, 0xF7B0, 0x01, 0x0C)
                    IO (Decode16, 0xF7C0, 0xF7C0, 0x01, 0x20)
                    IO (Decode16, 0xFBB0, 0xFBB0, 0x01, 0x0C)
                    IO (Decode16, 0xFBC0, 0xFBC0, 0x01, 0x20)
                    IO (Decode16, 0xFFB0, 0xFFB0, 0x01, 0x0C)
                    IO (Decode16, 0xFFC0, 0xFFC0, 0x01, 0x20)
                })
            }

            Device (GRFX)
            {
                Name (_ADR, 0x00020000)
                Name (SSTE, 0x00)
                Name (NSTE, 0x00)
                Name (VCPS, 0x00)
                Method (_PS0, 0, NotSerialized)
                {
                    If (LEqual (VCPS, 0x03))
                    {
                        Sleep (0x01F4)
                    }

                    \_SB.PSRV (0x94, 0x00, 0x00, 0x00, 0x00)
                    Store (0x00, VCPS)
                }

                Method (_PS1, 0, NotSerialized)
                {
                    \_SB.PSRV (0x94, 0x01, 0x00, 0x00, 0x00)
                    Store (0x01, VCPS)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    \_SB.PSRV (0x94, 0x02, 0x00, 0x00, 0x00)
                    Store (0x02, VCPS)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    \_SB.PSRV (0x94, 0x03, 0x00, 0x00, 0x00)
                    Store (0x03, VCPS)
                }

                Method (_DOS, 1, NotSerialized)
                {
                    Store (And (Arg0, 0x03), Local0)
                    \_SB.PSRV (0xB9, 0x20, 0x01, Local0, 0x00)
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Name (BUF3, Package (0x02)
                    {
                        0x00010100, 
                        0x00010400
                    })
                    Return (BUF3)
                }

                Device (CRT1)
                {
                    Name (_ADR, 0x0100)
                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (\_SB.PSRV (0xB9, 0x01, 0x00, 0x00, 0x03), Local0)
                        If (And (Local0, 0x01))
                        {
                            Return (0x1F)
                        }
                        Else
                        {
                            Return (0x1D)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Store (NSTE, Local0)
                        If (And (Local0, 0x01))
                        {
                            Return (0x01)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (LEqual (And (Arg0, 0xC0000000), 0x80000000))
                        {
                            \_SB.PSRV (0xB9, 0x00, 0x01, NSTE, 0x00)
                        }

                        If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
                        {
                            Store (NSTE, SSTE)
                        }
                    }
                }

                Device (LCD1)
                {
                    Name (_ADR, 0x0400)
                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (\_SB.PSRV (0xB9, 0x01, 0x00, 0x00, 0x03), Local0)
                        If (And (Local0, 0x08))
                        {
                            Return (0x1F)
                        }
                        Else
                        {
                            Return (0x1D)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Store (NSTE, Local0)
                        If (And (Local0, 0x08))
                        {
                            Return (0x01)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (LEqual (And (Arg0, 0xC0000000), 0x80000000))
                        {
                            \_SB.PSRV (0xB9, 0x00, 0x01, NSTE, 0x00)
                        }

                        If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
                        {
                            Store (NSTE, SSTE)
                        }
                    }
                }
            }

            Device (LPC0)
            {
                Name (_ADR, 0x001F0000)
                OperationRegion (REGS, PCI_Config, 0x40, 0xC0)
                Field (REGS, DWordAcc, NoLock, Preserve)
                {
                    PMBA,   16, 
                    Offset (0x18), 
                    GPBA,   16, 
                    Offset (0x60), 
                        ,   2, 
                    CREN,   1, 
                    Offset (0x90), 
                    MTSE,   32, 
                    Offset (0xB0), 
                        ,   5, 
                    FUND,   2
                }

                Method (_INI, 0, NotSerialized)
                {
                    \_SB.CRIN ()
                }

                Device (MBRD)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x1F)
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0010, 0x0010, 0x01, 0x10)
                        IO (Decode16, 0x0024, 0x0024, 0x01, 0x02)
                        IO (Decode16, 0x0028, 0x0028, 0x01, 0x02)
                        IO (Decode16, 0x002C, 0x002C, 0x01, 0x02)
                        IO (Decode16, 0x0030, 0x0030, 0x01, 0x02)
                        IO (Decode16, 0x0034, 0x0034, 0x01, 0x02)
                        IO (Decode16, 0x0038, 0x0038, 0x01, 0x02)
                        IO (Decode16, 0x003C, 0x003C, 0x01, 0x02)
                        IO (Decode16, 0x0050, 0x0050, 0x01, 0x04)
                        IO (Decode16, 0x0072, 0x0072, 0x01, 0x06)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x0090, 0x0090, 0x01, 0x10)
                        IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
                        IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x06)
                        IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
                        IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
                        IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
                        IO (Decode16, 0x1180, 0x1180, 0x01, 0x40)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IO (Decode16, 0x0362, 0x0362, 0x01, 0x01)
                        IO (Decode16, 0x0366, 0x0366, 0x01, 0x01)
                        IO (Decode16, 0xFE00, 0xFE00, 0x02, 0x02)
                        IO (Decode16, 0x0580, 0x0580, 0x01, 0x08)
                        Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)
                        Memory32Fixed (ReadOnly, 0xFF800000, 0x00800000)
                    })
                    Method (ISSD, 1, NotSerialized)
                    {
                        Store (0x03, Local0)
                        If (And (Arg0, 0x4000))
                        {
                            Store (0x30, Local0)
                        }

                        Store (ShiftRight (Subtract (Arg0, 0x000C0000), 0x0F), Local1)
                        If (LEqual (Local1, 0x00))
                        {
                            Add (Multiply (\_SB.PCI0.PM1H, 0x10), \_SB.PCI0.PM1L, Local2)
                        }

                        If (LEqual (Local1, 0x01))
                        {
                            Add (Multiply (\_SB.PCI0.PM2H, 0x10), \_SB.PCI0.PM2L, Local2)
                        }

                        If (LEqual (Local1, 0x02))
                        {
                            Add (Multiply (\_SB.PCI0.PM3H, 0x10), \_SB.PCI0.PM3L, Local2)
                        }

                        If (LEqual (Local1, 0x03))
                        {
                            Add (Multiply (\_SB.PCI0.PM4H, 0x10), \_SB.PCI0.PM4L, Local2)
                        }

                        If (LEqual (Local1, 0x04))
                        {
                            Add (Multiply (\_SB.PCI0.PM5H, 0x10), \_SB.PCI0.PM5L, Local2)
                        }

                        If (LEqual (Local1, 0x05))
                        {
                            Add (Multiply (\_SB.PCI0.PM6H, 0x10), \_SB.PCI0.PM6L, Local2)
                        }

                        Return (And (Local2, Local0))
                    }

                    Method (ROMS, 1, NotSerialized)
                    {
                        If (ISSD (Arg0))
                        {
                            OperationRegion (XROM, SystemMemory, Arg0, 0x04)
                            Field (XROM, ByteAcc, NoLock, Preserve)
                            {
                                SIG,    16, 
                                SIZ,    8
                            }

                            If (LEqual (SIG, 0xAA55))
                            {
                                Return (Multiply (SIZ, 0x0200))
                            }
                        }

                        Return (Zero)
                    }

                    Name (XBAS, Zero)
                    Name (XSIZ, Zero)
                    Method (SRCH, 0, NotSerialized)
                    {
                        If (LEqual (XBAS, Zero))
                        {
                            Store (0x000C0000, XBAS)
                            While (LLess (XBAS, 0x000E0000))
                            {
                                Store (ROMS (XBAS), Local1)
                                Add (XBAS, Local1, XBAS)
                                If (LEqual (Local1, Zero))
                                {
                                    Divide (XBAS, 0x4000, Local2)
                                    If (Local2)
                                    {
                                        Subtract (0x4000, Local2, XSIZ)
                                    }

                                    Return (0x00)
                                }
                            }
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x92, PMMN)
                        CreateWordField (RSRC, 0x94, PMMX)
                        And (^^PMBA, 0xFF80, PMMN)
                        Store (PMMN, PMMX)
                        CreateWordField (RSRC, 0x9A, GPMN)
                        CreateWordField (RSRC, 0x9C, GPMX)
                        And (^^GPBA, 0xFF80, GPMN)
                        Store (GPMN, GPMX)
                        SRCH ()
                        CreateDWordField (RSRC, 0xCC, ROMB)
                        CreateDWordField (RSRC, 0xD0, ROML)
                        Store (XBAS, ROMB)
                        Store (XSIZ, ROML)
                        \_SB.CSTS (0x00)
                        Return (RSRC)
                    }
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x10)
                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
                        DMA (Compatibility, NotBusMaster, Transfer8_16) {4}
                    })
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
                        IRQNoFlags () {2}
                    })
                }

                Device (TIME)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                        IRQNoFlags () {0}
                    })
                }

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x02)
                        IRQNoFlags () {8}
                    })
                }

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x10)
                        IRQNoFlags () {13}
                    })
                }

                Name (\ECST, 0x00)
                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0062, 0x0062, 0x00, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x00, 0x01)
                    })
                    Mutex (ECEX, 0x00)
                    Name (BFCA, 0x00)
                    Name (BFCB, 0x00)
                    Name (BSFA, Package (0x04)
                    {
                        0xFFFFFFFF, 
                        0x00, 
                        0xFFFFFFFF, 
                        0x2EE0
                    })
                    Name (BSNA, Package (0x04)
                    {
                        0xFFFFFFFF, 
                        0x00, 
                        0xFFFFFFFF, 
                        0x2EE0
                    })
                    Name (BERA, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, ECST)
                        }
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        Store (EC04 (0x00, 0x02), BFCA)
                    }

                    Name (_GPE, 0x1C)
                    OperationRegion (ECR, EmbeddedControl, 0x00, 0xFF)
                    Field (ECR, ByteAcc, NoLock, Preserve)
                    {
                        BRST,   8, 
                        CTRL,   8, 
                        Offset (0x04), 
                        ECCR,   8, 
                        DAT1,   8, 
                        DAT2,   8, 
                        DAT3,   8, 
                        Offset (0x17), 
                        SLPT,   8, 
                        Offset (0xC0), 
                        CPUT,   10
                    }

                    Method (HCNV, 1, Serialized)
                    {
                        Store (0xFFFFFFFF, Local0)
                        If (LAnd (LNot (LLess (Arg0, 0x0A)), LNot (LGreater (Arg0, 0x15))))
                        {
                            Subtract (Arg0, 0x09, Local0)
                            If (And (0x00, ShiftLeft (0x01, Local0)))
                            {
                                Store (0xFFFFFFFF, Local0)
                            }
                        }

                        If (LAnd (LNot (LLess (Arg0, 0x70)), LNot (LGreater (Arg0, 0x7B))))
                        {
                            Add (Arg0, 0x11, Local0)
                            Subtract (Arg0, 0x6F, Local1)
                            If (And (0x0480, ShiftLeft (0x01, Local1)))
                            {
                                Store (0xFFFFFFFF, Local0)
                            }
                        }

                        If (LAnd (LNot (LLess (Arg0, 0x81)), LNot (LGreater (Arg0, 0x82))))
                        {
                            Subtract (Arg0, 0x51, Local0)
                        }

                        If (LNot (LEqual (Local0, 0xFFFFFFFF)))
                        {
                            \_SB.HKEY.HIND (Local0)
                            Notify (\_SB.HKEY, 0x80)
                        }
                        Else
                        {
                        }
                    }

                    Method (_Q0A, 0, Serialized)
                    {
                        HCNV (0x0A)
                    }

                    Method (_Q0B, 0, Serialized)
                    {
                        HCNV (0x0B)
                    }

                    Method (_Q0D, 0, Serialized)
                    {
                        HCNV (0x0D)
                    }

                    Method (_Q0E, 0, Serialized)
                    {
                        HCNV (0x0E)
                    }

                    Method (_Q0F, 0, Serialized)
                    {
                        HCNV (0x0F)
                    }

                    Method (_Q10, 0, Serialized)
                    {
                        HCNV (0x10)
                    }

                    Method (_Q11, 0, Serialized)
                    {
                        HCNV (0x11)
                    }

                    Method (_Q12, 0, Serialized)
                    {
                        HCNV (0x12)
                    }

                    Method (_Q13, 0, Serialized)
                    {
                        HCNV (0x13)
                    }

                    Method (_Q14, 0, Serialized)
                    {
                        HCNV (0x14)
                    }

                    Method (_Q15, 0, Serialized)
                    {
                        HCNV (0x15)
                    }

                    Method (_Q70, 0, Serialized)
                    {
                        HCNV (0x70)
                    }

                    Method (_Q71, 0, Serialized)
                    {
                        HCNV (0x71)
                    }

                    Method (_Q73, 0, Serialized)
                    {
                        HCNV (0x73)
                    }

                    Method (_Q74, 0, Serialized)
                    {
                        HCNV (0x74)
                    }

                    Method (_Q75, 0, Serialized)
                    {
                        HCNV (0x75)
                    }

                    Method (_Q76, 0, Serialized)
                    {
                        HCNV (0x76)
                    }

                    Method (_Q77, 0, Serialized)
                    {
                        HCNV (0x77)
                    }

                    Method (_Q78, 0, Serialized)
                    {
                        HCNV (0x78)
                    }

                    Method (_Q79, 0, Serialized)
                    {
                        HCNV (0x79)
                    }

                    Method (_Q7A, 0, Serialized)
                    {
                        HCNV (0x7A)
                    }

                    Method (_Q7B, 0, Serialized)
                    {
                        HCNV (0x7B)
                    }

                    Method (_Q81, 0, Serialized)
                    {
                        HCNV (0x81)
                    }

                    Method (_Q82, 0, Serialized)
                    {
                        HCNV (0x82)
                    }

                    Method (_Q0C, 0, Serialized)
                    {
                        \_SB.CHGD ()
                    }

                    Method (_Q72, 0, NotSerialized)
                    {
                    }

                    Method (_Q23, 0, Serialized)
                    {
                        Store (EC04 (0x00, 0x02), Local0)
                        If (LOr (LNot (LEqual (Local0, BFCA)), LEqual (Local0, 0xFFFFFFFF)))
                        {
                            Store (Local0, BFCA)
                            Store (0x00, BERA)
                            Notify (\_SB.BATA, 0x81)
                        }
                        Else
                        {
                            Notify (\_SB.BATA, 0x80)
                        }
                    }

                    Method (_Q24, 0, Serialized)
                    {
                    }

                    Method (_Q58, 0, Serialized)
                    {
                        Notify (\_TZ.TZC, 0x80)
                    }

                    Method (_Q80, 0, Serialized)
                    {
                        Store (EC01 (), Local0)
                        \_SB.PSRV (0xC4, Local0, 0x00, 0x00, 0x00)
                        Notify (\_SB.AC, 0x80)
                        \_SB.CSTS (0x01)
                    }

                    Method (_Q83, 0, Serialized)
                    {
                        Notify (\_SB.LID, 0x80)
                    }

                    Method (EC06, 0, Serialized)
                    {
                        Store (0x09, Local0)
                        Store (0x02, Local1)
                        Store (EC89 (Local0, Local1), Local2)
                        If (LEqual (Local2, 0xFFFFFFFF))
                        {
                            Return (0x01)
                        }
                        Else
                        {
                            Return (Local2)
                        }
                    }

                    Method (EC07, 0, Serialized)
                    {
                        Return (EC88 (EC87 (0x04, 0xC8)))
                    }

                    Method (EC08, 0, Serialized)
                    {
                        Return (0x03)
                    }

                    Method (EC09, 0, Serialized)
                    {
                        Return (EC88 (EC87 (0x04, 0xC5)))
                    }

                    Method (EC0A, 0, Serialized)
                    {
                        Return (EC88 (EC87 (0x04, 0xC6)))
                    }

                    Method (EC0B, 1, Serialized)
                    {
                        EC83 (0x0B, Arg0)
                        Return (0x00)
                    }

                    Method (EC01, 0, Serialized)
                    {
                        Return (And (EC86 (0x08), 0x01))
                    }

                    Method (EC02, 1, Serialized)
                    {
                        Store (EC86 (0x08), Local0)
                        If (LEqual (Local0, 0xFFFFFFFF))
                        {
                            Return (0x00)
                        }

                        If (LEqual (Arg0, 0x00))
                        {
                            If (And (Local0, 0x04))
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }

                    Method (EC03, 2, Serialized)
                    {
                        If (LEqual (Arg1, 0x00))
                        {
                            If (LEqual (Arg0, 0x00))
                            {
                                Store (EC86 (0x6A), Local0)
                                If (LEqual (Local0, 0xFFFFFFFF))
                                {
                                    Return (0x00)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }
                        }

                        If (LEqual (Arg1, 0x01))
                        {
                            Store (EC80 (Arg0, 0x02), Local0)
                            Store (EC80 (Arg0, 0x03), Local1)
                            If (LOr (LEqual (Local0, 0xFFFFFFFF), LEqual (Local1, 0xFFFFFFFF)))
                            {
                                Return (0x00)
                            }

                            If (And (Local0, 0x8000))
                            {
                                Subtract (0x00010000, Local0, Local0)
                            }

                            If (LEqual (EC04 (Arg0, 0x00), 0x00))
                            {
                                Multiply (Local0, Local1, Local0)
                                Divide (Local0, 0x2710, Local3, Local0)
                            }

                            Return (Local0)
                        }

                        If (LEqual (Arg1, 0x02))
                        {
                            Store (EC80 (Arg0, 0x00), Local0)
                            If (LEqual (Local0, 0xFFFFFFFF))
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                Return (Local0)
                            }
                        }

                        If (LEqual (Arg1, 0x03))
                        {
                            Store (EC80 (Arg0, 0x03), Local0)
                            If (LEqual (Local0, 0xFFFFFFFF))
                            {
                                If (LAnd (LEqual (Arg0, 0x00), LLess (BERA, 0x1E)))
                                {
                                    Increment (BERA)
                                    Notify (\_SB.BATA, 0x81)
                                }
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x00))
                                {
                                    Store (0x00, BERA)
                                }
                            }

                            If (LEqual (Local0, 0xFFFFFFFF))
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                Return (Local0)
                            }
                        }
                    }

                    Method (EC04, 2, Serialized)
                    {
                        Name (BUF, Buffer (0x10) {})
                        If (LEqual (Arg0, 0x00))
                        {
                            If (LEqual (Arg1, 0x00))
                            {
                                Store (EC85 (0x60), Local0)
                                If (LEqual (Local0, 0xFFFFFFFF))
                                {
                                    Return (0x01)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x01))
                            {
                                Store (EC85 (0x62), Local0)
                                If (LOr (LEqual (Local0, 0x00), LNot (LLess (Local0, 0xFFFF))))
                                {
                                    Return (0xFFFFFFFF)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x02))
                            {
                                Store (EC85 (0x64), Local0)
                                If (LOr (LEqual (Local0, 0x00), LNot (LLess (Local0, 0xFFFF))))
                                {
                                    Return (0xFFFFFFFF)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x03))
                            {
                                Return (One)
                            }

                            If (LEqual (Arg1, 0x04))
                            {
                                Store (EC85 (0x68), Local0)
                                If (LOr (LEqual (Local0, 0x00), LNot (LLess (Local0, 0xFFFF))))
                                {
                                    Return (0xFFFFFFFF)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x05))
                            {
                                Store (EC85 (0x72), Local0)
                                If (LEqual (Local0, 0xFFFFFFFF))
                                {
                                    Return (0x00)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x06))
                            {
                                Store (EC85 (0x74), Local0)
                                If (LEqual (Local0, 0xFFFFFFFF))
                                {
                                    Return (0x00)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x07))
                            {
                                Store (EC85 (0x76), Local0)
                                If (LEqual (Local0, 0xFFFFFFFF))
                                {
                                    Return (0x01)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x08))
                            {
                                Store (EC85 (0x78), Local0)
                                If (LEqual (Local0, 0xFFFFFFFF))
                                {
                                    Return (0x01)
                                }
                                Else
                                {
                                    Return (Local0)
                                }
                            }

                            If (LEqual (Arg1, 0x09))
                            {
                                Store (0x00, BUF)
                                Store (EC84 (0x8C, 0x0C), BUF)
                                Return (BUF)
                            }

                            If (LEqual (Arg1, 0x0A))
                            {
                                Store (0x00, BUF)
                                Store (EC85 (0x9A), Local0)
                                Store (EC8C (Local0, 0x05), BUF)
                                Return (BUF)
                            }

                            If (LEqual (Arg1, 0x0B))
                            {
                                Store (0x00, BUF)
                                Store (EC84 (0x9C, 0x08), BUF)
                                Return (BUF)
                            }

                            If (LEqual (Arg1, 0x0C))
                            {
                                Store ("Panasonic", BUF)
                                Return (BUF)
                            }
                        }
                    }

                    Method (EC05, 2, Serialized)
                    {
                        If (LEqual (Arg0, 0x00))
                        {
                            EC82 (0xF0, Arg1)
                        }
                    }

                    Method (EC0C, 1, Serialized)
                    {
                        Store (And (Arg0, 0x07), SLPT)
                        Return (0x00)
                    }

                    Method (EC0D, 1, Serialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x98, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x00))
                            {
                                Store (0x81, Local0)
                            }
                            Else
                            {
                                Return (0xFFFFFFFF)
                            }
                        }

                        Return (EC8B (0x43, Local0))
                    }

                    Method (EC0E, 1, Serialized)
                    {
                        If (LNot (LEqual (EC8A (0x00, 0x23, And (EC87 (0x00, 0x23), 0xFD)), 0x00)))
                        {
                            Return (0xFFFFFFFF)
                        }

                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x80, Local0)
                        }
                        Else
                        {
                            Store (0x00, Local0)
                        }

                        If (LEqual (EC8A (0x01, 0x9C, 0xFF), 0x00))
                        {
                            Return (EC8A (0x01, 0x9D, Local0))
                        }
                        Else
                        {
                            Return (0xFFFFFFFF)
                        }
                    }

                    Method (EC0F, 1, Serialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (0x01, Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x00))
                            {
                                Store (0x00, Local0)
                            }
                            Else
                            {
                                Return (0xFFFFFFFF)
                            }
                        }

                        EC83 (0x17, Local0)
                        Return (0xFFFFFFFF)
                    }

                    Method (EC10, 2, Serialized)
                    {
                        Store (EC89 (Arg0, Arg1), Local0)
                        If (LEqual (Local0, 0xFFFFFFFF))
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            Return (Local0)
                        }
                    }

                    Method (EC80, 2, Serialized)
                    {
                        If (LGreater (Arg1, 0x03))
                        {
                            Return (0xFFFFFFFF)
                        }

                        If (LEqual (Arg0, 0x00))
                        {
                            Store (Add (Arg1, 0x21), Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x01))
                            {
                                Store (Add (Arg1, 0x25), Local0)
                            }
                            Else
                            {
                                Return (0xFFFFFFFF)
                            }
                        }

                        Store (EC82 (Local0, 0x00), Local0)
                        If (LEqual (Local0, 0xFFFFFFFF)) {}
                        Else
                        {
                            Store (And (Local0, 0x00800000), Local1)
                            Store (And (Local0, 0xFFFF), Local0)
                            If (LEqual (Arg0, 0x00))
                            {
                                Store (Local0, Index (BSNA, Arg1))
                                If (LEqual (Local1, 0x00))
                                {
                                    Store (DerefOf (Index (BSNA, 0x00)), Index (BSFA, 0x00))
                                    Store (DerefOf (Index (BSNA, 0x01)), Index (BSFA, 0x01))
                                    Store (DerefOf (Index (BSNA, 0x02)), Index (BSFA, 0x02))
                                    Store (DerefOf (Index (BSNA, 0x03)), Index (BSFA, 0x03))
                                }
                                Else
                                {
                                    Store (DerefOf (Index (BSFA, Arg1)), Local0)
                                }
                            }
                        }

                        If (LEqual (Arg0, 0x00))
                        {
                            EC82 (0x41, 0x00)
                        }

                        Return (Local0)
                    }

                    Method (EC82, 2, Serialized)
                    {
                        If (LEqual (ECST, 0x00))
                        {
                            If (LAnd (LNot (LLess (Arg0, 0xF0)), LNot (LGreater (Arg0, 0xF3))))
                            {
                                Store (ShiftLeft (Arg1, 0x08), Local0)
                            }
                            Else
                            {
                                Store (0x00, Local0)
                            }

                            Store (Add (ShiftLeft (Local0, 0x08), Arg0), Local0)
                            Store (Add (ShiftLeft (Local0, 0x08), 0xDD), Local0)
                            Store (\_SB.PSRV (0xC3, Local0, 0x00, 0x00, 0x03), Local0)
                            If (And (Local0, 0x400000FF))
                            {
                                Return (0xFFFFFFFF)
                            }
                            Else
                            {
                                If (LAnd (LNot (LLess (Arg0, 0x20)), LNot (LGreater (Arg0, 0x37))))
                                {
                                    Store (And (ShiftRight (Local0, 0x08), 0x0080FFFF), Local0)
                                    Return (Local0)
                                }
                                Else
                                {
                                    Return (0x00)
                                }
                            }
                        }

                        Acquire (ECEX, 0xFFFF)
                        If (LAnd (LNot (LLess (Arg0, 0xF0)), LNot (LGreater (Arg0, 0xF3))))
                        {
                            Store (And (Arg1, 0xFF), DAT2)
                            Store (And (ShiftRight (Arg1, 0x08), 0xFF), DAT3)
                        }

                        Store (Arg0, DAT1)
                        Store (0xDD, ECCR)
                        Store (0xC8, Local4)
                        While (LAnd (LNot (LEqual (Local4, 0x00)), LNot (LEqual (ECCR, 0x00))))
                        {
                            Stall (0x19)
                            Decrement (Local4)
                        }

                        Store (DAT1, Local1)
                        Store (DAT2, Local2)
                        Store (DAT3, Local3)
                        Release (ECEX)
                        If (LOr (LEqual (Local4, 0x00), And (Local3, 0x40)))
                        {
                            Return (0xFFFFFFFF)
                        }

                        If (LAnd (LNot (LLess (Arg0, 0x20)), LNot (LGreater (Arg0, 0x37))))
                        {
                            Store (Add (ShiftLeft (Local2, 0x08), Local1), Local0)
                            If (And (Local3, 0x80))
                            {
                                Or (Local0, 0x00800000)
                            }

                            Return (Local0)
                        }

                        Return (0x00)
                    }

                    Method (EC83, 2, Serialized)
                    {
                        If (LEqual (ECST, 0x00))
                        {
                            If (LEqual (Arg0, 0x0B))
                            {
                                \_SB.ECWR (0x0B, Arg1)
                            }

                            If (LEqual (Arg0, 0x17))
                            {
                                \_SB.ECWR (0x17, Arg1)
                            }
                        }
                        Else
                        {
                            Acquire (ECEX, 0xFFFF)
                            Store (Arg0, DAT1)
                            Store (Arg1, DAT2)
                            Store (0xB5, ECCR)
                            Store (0xC8, Local1)
                            While (LAnd (LNot (LEqual (Local1, 0x00)), LNot (LEqual (ECCR, 0x00))))
                            {
                                Stall (0x19)
                                Decrement (Local1)
                            }

                            Release (ECEX)
                        }
                    }

                    Method (EC89, 2, Serialized)
                    {
                        If (LOr (LOr (LLess (Arg0, 0x01), LGreater (Arg0, 0x10)), LGreater (Arg1, 0x07)))
                        {
                            Return (0xFFFFFFFF)
                        }

                        Store (EC87 (0x12, 0xEF), Local0)
                        If (LEqual (Local0, 0xFFFFFFFF))
                        {
                            Return (0xFFFFFFFF)
                        }

                        Store (0x0A, Local1)
                        While (LAnd (LNot (LEqual (Local1, 0x00)), LEqual (EC87 (0x12, 0xEF), Local0)))
                        {
                            Sleep (0x01)
                            Decrement (Local1)
                        }

                        If (LEqual (Local1, 0x00))
                        {
                            Return (0xFFFFFFFF)
                        }

                        Store (EC87 (0x12, Add (0xEF, Arg0)), Local0)
                        If (LEqual (Local0, 0xFFFFFFFF))
                        {
                            Return (0xFFFFFFFF)
                        }

                        Return (And (ShiftRight (Local0, Arg1), 0x01))
                    }

                    Method (EC84, 2, Serialized)
                    {
                        Name (EBUF, Buffer (0x10) {})
                        Store (0x00, Local0)
                        If (LGreater (Arg1, 0x00))
                        {
                            While (LLess (Local0, Arg1))
                            {
                                Store (EC86 (Add (Arg0, Local0)), Local1)
                                If (LEqual (Local1, 0xFFFFFFFF))
                                {
                                    Break
                                }

                                Store (Local1, Index (EBUF, Local0))
                                Increment (Local0)
                            }

                            If (LNot (LEqual (Local0, Arg1)))
                            {
                                Store (0x00, EBUF)
                            }
                        }

                        Return (EBUF)
                    }

                    Method (EC85, 1, Serialized)
                    {
                        Add (Arg0, 0x01, Local1)
                        Store (0xFFFFFFFF, Local0)
                        If (LNot (LGreater (Local1, 0xFF)))
                        {
                            Store (EC86 (Local1), Local2)
                            If (LNot (LGreater (Local2, 0xFF)))
                            {
                                ShiftLeft (Local2, 0x08, Local2)
                                Store (EC86 (Arg0), Local3)
                                If (LNot (LGreater (Local3, 0xFF)))
                                {
                                    Add (Local3, Local2, Local0)
                                }
                            }
                        }

                        Return (Local0)
                    }

                    Method (EC86, 1, Serialized)
                    {
                        Store (0xFFFFFFFF, Local0)
                        If (LNot (LGreater (Arg0, 0x7F)))
                        {
                            Store (EC87 (0x13, Or (Arg0, 0x80)), Local0)
                        }
                        Else
                        {
                            If (LNot (LGreater (Arg0, 0xFF)))
                            {
                                Store (EC87 (0x14, Arg0), Local0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (EC87, 2, Serialized)
                    {
                        If (LEqual (ECST, 0x00))
                        {
                            Store (Arg0, Local0)
                            Store (Add (ShiftLeft (Local0, 0x08), Arg1), Local0)
                            Store (Add (ShiftLeft (Local0, 0x10), 0xBA), Local0)
                            Store (\_SB.PSRV (0xC3, Local0, 0x00, 0x00, 0x03), Local0)
                            If (And (Local0, 0xFF))
                            {
                                Return (0xFFFFFFFF)
                            }
                            Else
                            {
                                Return (And (ShiftRight (Local0, 0x08), 0xFF))
                            }
                        }

                        Acquire (ECEX, 0xFFFF)
                        Store (0xFFFFFFFF, Local0)
                        If (LAnd (LNot (LGreater (Arg1, 0xFF)), LNot (LGreater (Arg0, 0x17))))
                        {
                            Store (Arg1, DAT2)
                            Store (Arg0, DAT3)
                            Store (0xBA, ECCR)
                            Store (0xC8, Local1)
                            While (LAnd (LNot (LEqual (Local1, 0x00)), LNot (LEqual (ECCR, 0x00))))
                            {
                                Stall (0x19)
                                Decrement (Local1)
                            }

                            If (LEqual (Local1, 0x00))
                            {
                                Store (0xFFFFFFFF, Local0)
                            }
                            Else
                            {
                                Store (DAT1, Local0)
                            }
                        }

                        Release (ECEX)
                        Return (Local0)
                    }

                    Method (EC8B, 2, Serialized)
                    {
                        Store (0xFFFFFFFF, Local0)
                        If (LNot (LGreater (Arg0, 0x7F)))
                        {
                            Store (EC8A (0x13, Or (Arg0, 0x80), Arg1), Local0)
                        }
                        Else
                        {
                            If (LNot (LGreater (Arg0, 0xFF)))
                            {
                                Store (EC8A (0x14, Arg0, Arg1), Local0)
                            }
                        }

                        Return (Local0)
                    }

                    Method (EC8A, 3, Serialized)
                    {
                        If (LEqual (ECST, 0x00))
                        {
                            Store (Arg0, Local0)
                            Store (Add (ShiftLeft (Local0, 0x08), Arg1), Local0)
                            Store (Add (ShiftLeft (Local0, 0x08), Arg2), Local0)
                            Store (Add (ShiftLeft (Local0, 0x08), 0xBB), Local0)
                            Store (\_SB.PSRV (0xC3, Local0, 0x00, 0x00, 0x03), Local0)
                            If (And (Local0, 0xFF))
                            {
                                Return (0xFFFFFFFF)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Acquire (ECEX, 0xFFFF)
                        Store (0xFFFFFFFF, Local0)
                        If (LAnd (LNot (LGreater (Arg1, 0xFF)), LNot (LGreater (Arg0, 0x17))))
                        {
                            Store (Arg2, DAT1)
                            Store (Arg1, DAT2)
                            Store (Arg0, DAT3)
                            Store (0xBB, ECCR)
                            Store (0xC8, Local1)
                            While (LAnd (LNot (LEqual (Local1, 0x00)), LNot (LEqual (ECCR, 0x00))))
                            {
                                Stall (0x19)
                                Decrement (Local1)
                            }

                            If (LEqual (Local1, 0x00))
                            {
                                Store (0xFFFFFFFF, Local0)
                            }
                            Else
                            {
                                Store (0x00, Local0)
                            }
                        }

                        Release (ECEX)
                        Return (Local0)
                    }

                    Method (EC88, 1, Serialized)
                    {
                        If (LGreater (Arg0, 0xFF))
                        {
                            Store (0xFFFFFFFF, Local0)
                        }
                        Else
                        {
                            Add (Arg0, 0x11, Local0)
                            If (LEqual (And (Arg0, 0x80), 0x00))
                            {
                                Add (Local0, 0x0100, Local0)
                            }

                            Multiply (Local0, 0x0A, Local0)
                        }

                        Return (Local0)
                    }

                    Method (EC8C, 2, Serialized)
                    {
                        Name (BUF, Buffer (0x10) {})
                        Store (0x00, BUF)
                        If (LOr (LLess (Arg1, 0x01), LGreater (Arg1, 0x10)))
                        {
                            Return (BUF)
                        }

                        Store (Arg0, Local0)
                        Store (0x00, Local1)
                        While (LLess (Local1, Arg1))
                        {
                            Divide (Local0, 0x0A, Local2, Local0)
                            Subtract (Arg1, Local1, Local3)
                            Decrement (Local3)
                            Add (Local2, 0x30, Index (BUF, Local3))
                            Increment (Local1)
                        }

                        Return (BUF)
                    }
                }

                Device (K101)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQNoFlags () {1}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNot (LEqual (PSRV (0x9B, 0x00, 0x00, 0x00, 0x03), 0x01)))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                }

                Device (K106)
                {
                    Name (_HID, EisaId ("PNP0320"))
                    Name (_CID, 0x0303D041)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQNoFlags () {1}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (PSRV (0x9B, 0x00, 0x00, 0x00, 0x03), 0x01))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                }

                Device (MOUS)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags () {12}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store (\_SB.PSRV (0xB6, 0x00, 0x00, 0x00, 0x01), Local0)
                        If (LEqual (Local0, 0x01))
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            Return (0x0F)
                        }

                        OperationRegion (BDA, SystemMemory, 0x0400, 0x0100)
                        Field (BDA, ByteAcc, NoLock, Preserve)
                        {
                            Offset (0x10), 
                                ,   2, 
                            MFLG,   1
                        }

                        If (MFLG)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                }

                Device (MOU3)
                {
                    Name (_HID, EisaId ("SYN0002"))
                    Name (_CID, 0x130FD041)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags () {12}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store (\_SB.PSRV (0xB6, 0x00, 0x00, 0x00, 0x01), Local0)
                        If (LEqual (Local0, 0x01))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }

                        OperationRegion (BDA, SystemMemory, 0x0400, 0x0100)
                        Field (BDA, ByteAcc, NoLock, Preserve)
                        {
                            Offset (0x10), 
                                ,   2, 
                            MFLG,   1
                        }

                        If (MFLG)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                }

                OperationRegion (PIRX, PCI_Config, 0x60, 0x04)
                Field (PIRX, DWordAcc, NoLock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8
                }

                OperationRegion (PIRY, PCI_Config, 0x68, 0x04)
                Field (PIRY, DWordAcc, NoLock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    PIRE,   8, 
                    PIRF,   8, 
                    PIRG,   8, 
                    PIRH,   8
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {5}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {5}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRA, 0x80, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRA, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Store (RSRC, Debug)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRA, 0x70), PIRA)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRA, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {5}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {5}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRB, 0x80, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRB, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRB, 0x70), PIRB)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRB, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {5}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {5}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRC, 0x80, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRC, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRC, 0x70), PIRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRC, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {7}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {7}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRD, 0x80, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRD, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRD, 0x70), PIRD)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRD, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {10}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {10}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRE, 0x80, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRE, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRE, 0x70), PIRE)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRE, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {10}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {10}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRF, 0x80, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRF, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRF, 0x70), PIRF)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRF, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {11}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {11}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRG, 0x80, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRG, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRG, 0x70), PIRG)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRG, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Method (_PRS, 0, NotSerialized)
                    {
                        If (LEqual (\CKOS (), 0x01))
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {10}
                            })
                        }
                        Else
                        {
                            Return (ResourceTemplate ()
                            {
                                IRQ (Level, ActiveLow, Shared) {10}
                            })
                        }
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRH, 0x80, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRH, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRH, 0x70), PIRH)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRH, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }
            }

            Device (PCIB)
            {
                Name (_ADR, 0x001E0000)
                Name (_PRT, Package (0x0C)
                {
                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKH, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0002FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x03, 
                        \_SB.PCI0.LPC0.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x00, 
                        \_SB.PCI0.LPC0.LNKE, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x01, 
                        \_SB.PCI0.LPC0.LNKF, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0003FFFF, 
                        0x02, 
                        \_SB.PCI0.LPC0.LNKG, 
                        0x00
                    }
                })
                Device (MPCA)
                {
                    Name (_ADR, 0x00010000)
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x04
                    })
                }

                Device (MPCB)
                {
                    Name (_ADR, 0x00020000)
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x03
                    })
                    Method (_PS0, 0, NotSerialized)
                    {
                        \_SB.CRCT (0x0100, Zero)
                    }

                    Method (_PS1, 0, NotSerialized)
                    {
                        \_SB.CRCT (0x0100, One)
                    }

                    Method (_PS2, 0, NotSerialized)
                    {
                        \_SB.CRCT (0x0100, One)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        \_SB.CRCT (0x0100, One)
                    }
                }

                Device (CDB0)
                {
                    Name (_ADR, 0x00050000)
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x03
                    })
                    OperationRegion (CBC0, PCI_Config, 0x00, 0x0100)
                    Field (CBC0, DWordAcc, NoLock, Preserve)
                    {
                        Offset (0x44), 
                        C0B1,   32
                    }

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

                Device (SDC0)
                {
                    Name (_ADR, 0x00050001)
                    Method (_PS0, 0, NotSerialized)
                    {
                        SDCP ()
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }

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

                    Device (SDS0)
                    {
                        Name (_ADR, 0x00)
                        Method (_STA, 0, NotSerialized)
                        {
                            SDCK ()
                            Return (0x0F)
                        }
                    }
                }

                Method (SDCK, 0, NotSerialized)
                {
                    Store (One, Local0)
                    Store (\_SB.PSRV (0xCC, Zero, Zero, Zero, One), Local1)
                    If (LEqual (Local1, 0x02))
                    {
                        Store (Zero, Local0)
                    }

                    If (Local1)
                    {
                        \_SB.CRCT (0x0200, Local0)
                    }
                }

                Method (SDCP, 0, NotSerialized)
                {
                    Store (One, Local0)
                    Store (\_SB.PSRV (0xCC, One, Zero, Zero, One), Local1)
                    If (LEqual (Local1, 0x02))
                    {
                        Store (Zero, Local0)
                    }

                    If (Local1)
                    {
                        \_SB.CRCT (0x0200, Local0)
                    }
                }

                Device (OHC0)
                {
                    Name (_ADR, 0x00030000)
                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        \_SB.PSRV (0xCB, 0x01, 0x00, 0x00, 0x00)
                    }
                }

                Device (OHC1)
                {
                    Name (_ADR, 0x00030001)
                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        \_SB.PSRV (0xCB, 0x02, 0x00, 0x00, 0x00)
                    }
                }

                Device (EHC0)
                {
                    Name (_ADR, 0x00030002)
                }
            }

            Device (IDEC)
            {
                Name (_ADR, 0x001F0001)
                OperationRegion (IDEC, PCI_Config, 0x00, 0x58)
                Field (IDEC, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x04), 
                    CMD,    16, 
                    Offset (0x20), 
                    BAR,    32, 
                    Offset (0x40), 
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                    Offset (0x48), 
                    SYNC,   4, 
                    Offset (0x4A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                    Offset (0x4B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                    Offset (0x54), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4
                }

                Name (SVFL, 0x00)
                Name (SVCM, Ones)
                Name (SVBA, Buffer (0x04) {})
                Name (SVT0, Ones)
                Name (SVT1, Ones)
                Name (SVWP, Ones)
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, SVFL)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    If (SVFL)
                    {
                        Store (^SVCM, ^CMD)
                        Store (^SVBA, ^BAR)
                        And (^SVT0, 0x8044, Local0)
                        And (^PRIT, 0x7FBB, Local1)
                        Or (Local0, Local1, ^PRIT)
                        And (^SVT1, 0x8044, Local0)
                        And (^SECT, 0x7FBB, Local1)
                        Or (Local0, Local1, ^SECT)
                        Store (^SVWP, ^ICR2)
                    }
                }

                Method (SVS4, 0, NotSerialized)
                {
                    Store (^CMD, ^SVCM)
                    Store (^BAR, ^SVBA)
                    Store (^PRIT, ^SVT0)
                    Store (^SECT, ^SVT1)
                    Store (^ICR2, ^SVWP)
                    Store (0x01, SVFL)
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Name (NCM0, 0x03)
                    Name (NCM1, 0x03)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (PBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (PBUF, 0x00, PIO0)
                        CreateDWordField (PBUF, 0x04, DMA0)
                        CreateDWordField (PBUF, 0x08, PIO1)
                        CreateDWordField (PBUF, 0x0C, DMA1)
                        CreateDWordField (PBUF, 0x10, FLAG)
                        Store (GETP (PRIT), PIO0)
                        Store (GDMA (And (SYNC, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0, And (ICR1, 0x01)), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

                        If (And (PRIT, 0x4000))
                        {
                            If (LEqual (And (PRIT, 0x90), 0x80))
                            {
                                Store (0x0384, PIO1)
                            }
                            Else
                            {
                                Store (GETT (PSIT), PIO1)
                            }
                        }
                        Else
                        {
                            Store (0xFFFFFFFF, PIO1)
                        }

                        Store (GDMA (And (SYNC, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1, And (ICR1, 0x02)), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SYNC, 0x01), And (SYNC, 0x02), PRIT), FLAG)
                        Return (PBUF)
                    }

                    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 (0x04, ICR2)
                        If (LAnd (LEqual (SizeOf (Arg1), 0x0200), PIO0))
                        {
                            And (PRIT, 0x40F0, PRIT)
                            And (SYNC, 0x0E, SYNC)
                            Store (0x00, SDT0)
                            And (ICR0, 0x0E, ICR0)
                            And (ICR1, 0x0E, ICR1)
                            And (ICR3, 0x0E, ICR3)
                            And (ICR5, 0x0E, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (PRIT, 0x8004, PRIT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (PRIT, 0x02, PRIT)
                            }

                            Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x01, SYNC)
                                Store (SDMA (DMA0), SDT0)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x01, ICR0)
                                }

                                If (And (W930, 0x2000))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                }
                            }

                            Store (0x03, NCM0)
                            If (LNot (LLess (SizeOf (Arg1), 0x0102)))
                            {
                                If (And (DerefOf (Index (Arg1, 0x0100)), One))
                                {
                                    Or (NCM0, 0x04, NCM0)
                                }
                            }

                            Store (\_SB.PSRV (0xC9, 0x00, 0x00, 0x00, 0x03), Local3)
                            If (Local3)
                            {
                                Or (NCM0, 0x08, NCM0)
                            }
                        }

                        If (LAnd (LEqual (SizeOf (Arg2), 0x0200), PIO1))
                        {
                            And (PRIT, 0x3F0F, PRIT)
                            Store (0x00, PSIT)
                            And (SYNC, 0x0D, SYNC)
                            Store (0x00, SDT1)
                            And (ICR0, 0x0D, ICR0)
                            And (ICR1, 0x0D, ICR1)
                            And (ICR3, 0x0D, ICR3)
                            And (ICR5, 0x0D, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (PRIT, 0x8040, PRIT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (PRIT, 0x20, PRIT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (PRIT, 0x4000, PRIT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (PRIT, 0x80, PRIT)
                                }
                                Else
                                {
                                    Or (PRIT, 0x10, PRIT)
                                    Store (SETT (PIO1, W531, W641), PSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x02, SYNC)
                                Store (SDMA (DMA1), SDT1)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x02, ICR0)
                                }

                                If (And (W931, 0x2000))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                }
                            }

                            Store (0x03, NCM1)
                            If (LNot (LLess (SizeOf (Arg2), 0x0102)))
                            {
                                If (And (DerefOf (Index (Arg2, 0x0100)), One))
                                {
                                    Or (NCM1, 0x04, NCM1)
                                }
                            }
                        }
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB0, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            Name (FLK0, Buffer (0x07)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5
                            })
                            Name (SMX0, Buffer (0x0E)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xF8, 0x00, 
                                0x00, 0x00, 0x00, 0x00, 0xE0, 0xF9
                            })
                            CreateByteField (PIB0, 0x01, PMD0)
                            CreateByteField (PIB0, 0x08, DMD0)
                            CreateDWordField (SMX0, 0x09, MXA0)
                            If (And (PRIT, 0x02))
                            {
                                If (LEqual (And (PRIT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                If (And (ICR1, 0x01))
                                {
                                    If (And (ICR0, 0x01))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x01))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            If (And (NCM0, 0x08))
                            {
                                Store (\_SB.PSRV (0xC9, 0x00, 0x00, 0x00, 0x03), Local3)
                                If (Local3)
                                {
                                    Or (Local3, 0xE0000000, Local3)
                                    Store (Local3, MXA0)
                                    Concatenate (PIB0, SMX0, Local4)
                                }
                                Else
                                {
                                    Store (PIB0, Local4)
                                }
                            }
                            Else
                            {
                                Store (PIB0, Local4)
                            }

                            If (And (NCM0, 0x04))
                            {
                                Concatenate (Local4, FLK0, Local0)
                            }
                            Else
                            {
                                Store (Local4, Local0)
                            }

                            Return (Local0)
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            Name (FLK1, Buffer (0x07)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xF5
                            })
                            CreateByteField (PIB1, 0x01, PMD1)
                            CreateByteField (PIB1, 0x08, DMD1)
                            If (And (PRIT, 0x20))
                            {
                                If (LEqual (And (PRIT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (PSIT, 0x03), ShiftRight (And (PSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SYNC, 0x02))
                            {
                                Store (Or (SDT1, 0x40), DMD1)
                                If (And (ICR1, 0x02))
                                {
                                    If (And (ICR0, 0x02))
                                    {
                                        Add (DMD1, 0x02, DMD1)
                                    }

                                    If (And (ICR3, 0x02))
                                    {
                                        Store (0x45, DMD1)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            If (And (NCM1, 0x04))
                            {
                                Concatenate (PIB1, FLK1, Local0)
                            }
                            Else
                            {
                                Store (PIB1, Local0)
                            }

                            Return (Local0)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (SBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (SBUF, 0x00, PIO0)
                        CreateDWordField (SBUF, 0x04, DMA0)
                        CreateDWordField (SBUF, 0x08, PIO1)
                        CreateDWordField (SBUF, 0x0C, DMA1)
                        CreateDWordField (SBUF, 0x10, FLAG)
                        Store (GETP (SECT), PIO0)
                        Store (GDMA (And (SYNC, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2, And (ICR1, 0x04)), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

                        If (And (SECT, 0x4000))
                        {
                            If (LEqual (And (SECT, 0x90), 0x80))
                            {
                                Store (0x0384, PIO1)
                            }
                            Else
                            {
                                Store (GETT (SSIT), PIO1)
                            }
                        }
                        Else
                        {
                            Store (0xFFFFFFFF, PIO1)
                        }

                        Store (GDMA (And (SYNC, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3, And (ICR1, 0x08)), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SYNC, 0x04), And (SYNC, 0x08), SECT), FLAG)
                        Return (SBUF)
                    }

                    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 (0x04, ICR2)
                        If (LAnd (LEqual (SizeOf (Arg1), 0x0200), PIO0))
                        {
                            And (SECT, 0x40F0, SECT)
                            And (SYNC, 0x0B, SYNC)
                            Store (0x00, SDT2)
                            And (ICR0, 0x0B, ICR0)
                            And (ICR1, 0x0B, ICR1)
                            And (ICR3, 0x0B, ICR3)
                            And (ICR5, 0x0B, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (SECT, 0x8004, SECT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (SECT, 0x02, SECT)
                            }

                            Or (SECT, SETP (PIO0, W530, W640), SECT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x04, SYNC)
                                Store (SDMA (DMA0), SDT2)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x04, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x04, ICR0)
                                }

                                If (And (W930, 0x2000))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                }
                            }
                        }

                        If (LAnd (LEqual (SizeOf (Arg2), 0x0200), PIO1))
                        {
                            And (SECT, 0x3F0F, SECT)
                            Store (0x00, SSIT)
                            And (SYNC, 0x07, SYNC)
                            Store (0x00, SDT3)
                            And (ICR0, 0x07, ICR0)
                            And (ICR1, 0x07, ICR1)
                            And (ICR3, 0x07, ICR3)
                            And (ICR5, 0x07, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (SECT, 0x8040, SECT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (SECT, 0x20, SECT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (SECT, 0x4000, SECT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (SECT, 0x80, SECT)
                                }
                                Else
                                {
                                    Or (SECT, 0x10, SECT)
                                    Store (SETT (PIO1, W531, W641), SSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x08, SYNC)
                                Store (SDMA (DMA1), SDT3)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x08, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x08, ICR0)
                                }

                                If (And (W931, 0x2000))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                }
                            }
                        }
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (SIB0, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            CreateByteField (SIB0, 0x01, PMD0)
                            CreateByteField (SIB0, 0x08, DMD0)
                            If (And (SECT, 0x02))
                            {
                                If (LEqual (And (SECT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (SECT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (SECT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x04))
                            {
                                Store (Or (SDT2, 0x40), DMD0)
                                If (And (ICR1, 0x04))
                                {
                                    If (And (ICR0, 0x04))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x04))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            Return (SIB0)
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (SIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (SIB1, 0x01, PMD1)
                            CreateByteField (SIB1, 0x08, DMD1)
                            If (And (SECT, 0x20))
                            {
                                If (LEqual (And (SECT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (SSIT, 0x03), ShiftRight (And (SSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SYNC, 0x08))
                            {
                                Store (Or (SDT3, 0x40), DMD1)
                                If (And (ICR1, 0x08))
                                {
                                    If (And (ICR0, 0x08))
                                    {
                                        Add (DMD1, 0x02, DMD1)
                                    }

                                    If (And (ICR3, 0x08))
                                    {
                                        Store (0x45, DMD1)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (SIB1)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }
                }

                Method (GETP, 1, NotSerialized)
                {
                    If (LEqual (And (Arg0, 0x09), 0x00))
                    {
                        Return (0xFFFFFFFF)
                    }

                    If (LEqual (And (Arg0, 0x09), 0x08))
                    {
                        Return (0x0384)
                    }

                    ShiftRight (And (Arg0, 0x0300), 0x08, Local0)
                    ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)
                    Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))))
                }

                Method (GDMA, 5, NotSerialized)
                {
                    If (Arg0)
                    {
                        If (LAnd (Arg1, Arg4))
                        {
                            Return (0x14)
                        }

                        If (LAnd (Arg2, Arg4))
                        {
                            Return (Multiply (Subtract (0x04, Arg3), 0x0F))
                        }

                        Return (Multiply (Subtract (0x04, Arg3), 0x1E))
                    }

                    Return (0xFFFFFFFF)
                }

                Method (GETD, 4, NotSerialized)
                {
                    If (Arg0)
                    {
                        If (Arg1)
                        {
                            Return (0x17)
                        }

                        If (Arg2)
                        {
                            Return (Multiply (Subtract (0x04, Arg3), 0x0F))
                        }

                        Return (Multiply (Subtract (0x04, Arg3), 0x1E))
                    }

                    Return (0xFFFFFFFF)
                }

                Method (GETT, 1, NotSerialized)
                {
                    Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02), 0x03), And (Arg0, 0x03)))))
                }

                Method (GETF, 3, NotSerialized)
                {
                    Name (TMPF, 0x00)
                    If (Arg0)
                    {
                        Or (TMPF, 0x01, TMPF)
                    }

                    If (And (Arg2, 0x02))
                    {
                        Or (TMPF, 0x02, TMPF)
                    }

                    If (Arg1)
                    {
                        Or (TMPF, 0x04, TMPF)
                    }

                    If (And (Arg2, 0x20))
                    {
                        Or (TMPF, 0x08, TMPF)
                    }

                    If (And (Arg2, 0x4000))
                    {
                        Or (TMPF, 0x10, TMPF)
                    }

                    Return (TMPF)
                }

                Method (SETP, 3, NotSerialized)
                {
                    If (LGreater (Arg0, 0xF0))
                    {
                        Return (0x08)
                    }
                    Else
                    {
                        If (And (Arg1, 0x02))
                        {
                            If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                            {
                                Return (0x2301)
                            }

                            If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                            {
                                Return (0x2101)
                            }
                        }

                        Return (0x1001)
                    }
                }

                Method (SDMA, 1, NotSerialized)
                {
                    If (LNot (LGreater (Arg0, 0x14)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x1E)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x2D)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x3C)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x5A)))
                    {
                        Return (0x01)
                    }

                    Return (0x00)
                }

                Method (SETD, 1, NotSerialized)
                {
                    If (LNot (LGreater (Arg0, 0x17)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x1E)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x2D)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x3C)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x5A)))
                    {
                        Return (0x01)
                    }

                    Return (0x00)
                }

                Method (SETT, 3, NotSerialized)
                {
                    If (And (Arg1, 0x02))
                    {
                        If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                        {
                            Return (0x0B)
                        }

                        If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                        {
                            Return (0x09)
                        }
                    }

                    Return (0x04)
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)
                Method (_PS0, 0, NotSerialized)
                {
                    PSRV (0xB4, \CKOS (), 0x00, 0x00, 0x00)
                    PSRV (0xBA, 0x00, 0x00, 0x00, 0x00)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    PSRV (0xB4, \CKOS (), 0x00, 0x00, 0x00)
                    PSRV (0xBA, 0x03, 0x00, 0x00, 0x00)
                }
            }

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

            Device (AUDI)
            {
                Name (_ADR, 0x001F0005)
            }

            Device (SMDM)
            {
                Name (_ADR, 0x001F0006)
                Name (MPSW, 0x00)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    Store (ShiftLeft (0x00, 0x18), Local0)
                    Or (Local0, And (_ADR, 0x00FF0000), Local0)
                    Or (Local0, ShiftLeft (And (_ADR, 0xFF), 0x08), Local0)
                    Or (Local0, Arg0, Local0)
                    Store (Local0, MPSW)
                }
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Name (_UID, 0x00)
            Name (_PRW, Package (0x02)
            {
                0x1B, 
                0x05
            })
            Method (_STA, 0, NotSerialized)
            {
                Return (0x0F)
            }
        }

        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Name (_UID, 0x00)
            Method (_PSR, 0, NotSerialized)
            {
                Return (\_SB.ECPF (0x0100, 0x00, 0x00))
            }

            Name (_PCL, Package (0x01)
            {
                \_SB
            })
        }

        Device (BATA)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x00)
            Name (A_PU, 0xFF)
            Method (_BIF, 0, Serialized)
            {
                Name (BIFR, Package (0x0D)
                {
                    0x00, 
                    0x00, 
                    0x00, 
                    0x00, 
                    0x00, 
                    0x00, 
                    0x00, 
                    0x00, 
                    0x00, 
                    Buffer (0x10) {}, 
                    Buffer (0x10) {}, 
                    Buffer (0x10) {}, 
                    Buffer (0x10) {}
                })
                Store (\_SB.ECPF (0x0111, 0x00, 0x00), A_PU)
                Store (A_PU, Index (BIFR, 0x00))
                If (A_PU)
                {
                    Store (0x01, Local1)
                    While (LNot (LGreater (Local1, 0x08)))
                    {
                        Store (\_SB.ECPF (0x0111, 0x00, Local1), Index (BIFR, Local1))
                        Increment (Local1)
                    }
                }
                Else
                {
                    Store (0x01, Local1)
                    While (LNot (LGreater (Local1, 0x08)))
                    {
                        Store (\_SB.ECPF (0x0111, 0x00, Local1), Local2)
                        If (LAnd (LNot (LEqual (Local2, 0xFFFFFFFF)), LAnd (LNot (LEqual (Local1, 0x03)), LNot (LEqual (Local1, 0x04)))))
                        {
                            Multiply (Local2, 0x0A, Local2)
                        }

                        Store (Local2, Index (BIFR, Local1))
                        Increment (Local1)
                    }
                }

                Store (\_SB.ECPF (0x0111, 0x00, 0x09), Index (BIFR, 0x09))
                Store (\_SB.ECPF (0x0111, 0x00, 0x0A), Index (BIFR, 0x0A))
                Store (\_SB.ECPF (0x0111, 0x00, 0x0B), Index (BIFR, 0x0B))
                Store ("Panasonic", Index (BIFR, 0x0C))
                Return (BIFR)
            }

            Method (_BST, 0, Serialized)
            {
                Name (BSTR, Package (0x04)
                {
                    0x00, 
                    0x00, 
                    0x00, 
                    0x00
                })
                Store (\_SB.ECPF (0x0110, 0x00, 0x00), Index (BSTR, 0x00))
                If (LGreater (A_PU, 0x01))
                {
                    Store (\_SB.ECPF (0x0111, 0x00, 0x00), A_PU)
                }

                If (A_PU)
                {
                    Store (\_SB.ECPF (0x0110, 0x00, 0x01), Index (BSTR, 0x01))
                    Store (\_SB.ECPF (0x0110, 0x00, 0x02), Index (BSTR, 0x02))
                }
                Else
                {
                    Store (Multiply (\_SB.ECPF (0x0110, 0x00, 0x01), 0x0A), Index (BSTR, 0x01))
                    Store (Multiply (\_SB.ECPF (0x0110, 0x00, 0x02), 0x0A), Index (BSTR, 0x02))
                }

                Store (\_SB.ECPF (0x0110, 0x00, 0x03), Index (BSTR, 0x03))
                Return (BSTR)
            }

            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (_STA, 0, Serialized)
            {
                If (LEqual (\_SB.ECPF (0x0101, 0x00, 0x00), 0x01))
                {
                    Return (0x1F)
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Method (_BTP, 1, NotSerialized)
            {
                If (LGreater (A_PU, 0x01))
                {
                    Store (\_SB.ECPF (0x0111, 0x00, 0x00), A_PU)
                }

                If (A_PU)
                {
                    Store (Arg0, Local1)
                }
                Else
                {
                    Store (Divide (Arg0, 0x0A, ), Local1)
                }

                If (LNot (LLess (Local1, 0x00010000)))
                {
                    Store (Zero, Local0)
                }
                Else
                {
                    Store (Local1, Local0)
                }

                \_SB.ECPF (0x0112, 0x00, Local0)
            }
        }

        Device (HKEY)
        {
            Name (_HID, EisaId ("MAT0019"))
            Name (SIFR, Package (0x09)
            {
                0x01, 
                0x00, 
                0xFF, 
                0x14, 
                0xFF, 
                0xFF, 
                0x14, 
                0x7F, 
                0x00
            })
            Name (HDAT, Buffer (0x20) {})
            Name (HINP, Zero)
            Name (HOUP, Zero)
            Mutex (HDMX, 0x00)
            Method (_STA, 0, NotSerialized)
            {
                Return (0x0F)
            }

            Method (_INI, 0, NotSerialized)
            {
                HRES ()
            }

            Method (HRES, 0, Serialized)
            {
                Acquire (HDMX, 0xFFFF)
                Store (\_SB.PSRV (0xC2, 0x00, 0x00, 0x00, 0x03), Local0)
                Store (And (ShiftRight (Local0, 0x08), 0xFF), Index (SIFR, 0x07))
                Store (And (Local0, 0xFF), Index (SIFR, 0x04))
                Store (And (\_SB.PSRV (0xC5, 0x00, 0x00, 0x00, 0x01), 0x01), Index (SIFR, 0x08))
                Release (HDMX)
            }

            Method (HSAV, 0, Serialized)
            {
                Acquire (HDMX, 0xFFFF)
                Store (DerefOf (Index (SIFR, 0x04)), Local0)
                Add (ShiftLeft (DerefOf (Index (SIFR, 0x07)), 0x08), Local0, Local0)
                Add (Local0, 0x00010000, Local0)
                \_SB.PSRV (0xC2, Local0, 0x00, 0x00, 0x03)
                Store (And (DerefOf (Index (SIFR, 0x08)), 0x01), Local0)
                Add (Local0, 0x02, Local0)
                \_SB.PSRV (0xC5, Local0, 0x00, 0x00, 0x01)
                Release (HDMX)
            }

            Method (HIND, 1, Serialized)
            {
                Acquire (HDMX, 0xFFFF)
                Store (Arg0, Index (HDAT, HINP))
                Increment (HINP)
                Divide (HINP, 0x20, HINP)
                If (LEqual (HINP, HOUP))
                {
                    Increment (HOUP)
                    Divide (HOUP, 0x20, HOUP)
                }

                Release (HDMX)
            }

            Method (HINF, 0, Serialized)
            {
                Acquire (HDMX, 0xFFFF)
                If (LEqual (HINP, HOUP))
                {
                    Store (Zero, Local0)
                }
                Else
                {
                    Store (DerefOf (Index (HDAT, HOUP)), Local0)
                    Increment (HOUP)
                    Divide (HOUP, 0x20, HOUP)
                }

                Store (LNot (LEqual (HINP, HOUP)), Local1)
                Release (HDMX)
                If (Local1)
                {
                    Notify (\_SB.HKEY, 0x80)
                }

                Return (Local0)
            }

            Method (SQTY, 0, NotSerialized)
            {
                Return (0x09)
            }

            Method (SINF, 0, NotSerialized)
            {
                Return (SIFR)
            }

            Method (SSET, 2, Serialized)
            {
                If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x07)))
                {
                    Store (Arg1, Index (SIFR, Arg0))
                    \_SB.ECPF (0x0205, \_SB.BCNV (Arg1), 0x00)
                }

                If (LEqual (Arg0, 0x08))
                {
                    Store (Arg1, Index (SIFR, Arg0))
                    \_SB.ECPF (0x0209, Arg1, 0x00)
                }

                If (LEqual (Arg0, 0x80))
                {
                    If (LEqual (Arg1, 0x01))
                    {
                        Store (0xE201, Local0)
                    }
                    Else
                    {
                        Store (0xE200, Local0)
                    }

                    \_SB.ECPF (0x0208, Arg1, 0x00)
                }
            }

            Method (HACT, 0, NotSerialized)
            {
                Notify (PWRB, 0x80)
            }
        }

        Method (CHGD, 0, NotSerialized)
        {
            If (\_SB.PSRV (0xB9, 0x22, 0x00, 0x00, 0x01))
            {
                If (LEqual (\CKOS (), 0x82))
                {
                    Notify (\_SB.PCI0, 0x00)
                }
                Else
                {
                    Notify (\_SB.PCI0.GRFX, 0x00)
                }

                Sleep (0x03E8)
                Store (\_SB.PSRV (0xB9, 0x07, 0x00, 0x00, 0x03), \_SB.PCI0.GRFX.NSTE)
                Notify (\_SB.PCI0.GRFX, 0x80)
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Name (_UID, 0x00)
            Method (_LID, 0, NotSerialized)
            {
                Return (\_SB.ECPF (0x0200, 0x00, 0x00))
            }

            Name (_PRW, Package (0x02)
            {
                0x1B, 
                0x04
            })
            Method (_PSW, 1, NotSerialized)
            {
                \_SB.ECPF (0x0207, Arg0, 0x00)
            }
        }
    }

    Scope (\_SB)
    {
        Method (CSTS, 1, NotSerialized)
        {
            \_SB.PSRV (0xC0, Arg0, 0x00, 0x00, 0x00)
        }
    }

    Scope (_SB)
    {
        Method (BCNV, 1, NotSerialized)
        {
            Return (DerefOf (Index (^BTBL, Arg0)))
        }

        Name (BTBL, Buffer (0x0100)
        {
            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
            0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 
            0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 
            0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1F, 0x20, 0x21, 
            0x22, 0x23, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2A, 
            0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 
            0x33, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 
            0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 
            0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 
            0x4C, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 
            0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 
            0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 
            0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 
            0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x71, 0x72, 0x73, 
            0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 
            0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 
            0x84, 0x85, 0x86, 0x87, 0x87, 0x88, 0x89, 0x8A, 
            0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 
            0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 
            0x9A, 0x9B, 0x9C, 0x9D, 0x9D, 0x9E, 0x9F, 0xA0, 
            0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 
            0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 
            0xB1, 0xB2, 0xB3, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 
            0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 
            0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 
            0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 
            0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD7, 0xD8, 
            0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 
            0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 
            0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 
            0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 
            0xF9, 0xFA, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
        })
    }
}