How can I fix these problems of the asl of my computer?

huangxiangkui at gmail.com huangxiangkui at gmail.com
Wed Feb 8 07:42:03 PST 2006


I am only a student in China.And because of some problem by our
country,I counldn't connect the mail list web of freebsd and freebsd
main site.So please answer me clear.

My Computer is HP Pavilion ze2205au.

There is some error of UPRS on my computer.

I use commond  "acpidump -t -d" get below.

================================
/*
  RSD PTR: OEM=HP, ACPI_Rev=1.0x (0)
	RSDT=0x0def8ad8, cksum=107
 */
/*
  RSDT: Length=52, Revision=1, Checksum=48,
	OEMID=HP, OEM Table ID=3091, OEM Revision=0x20041209,
	Creator ID= LTP, Creator Revision=0x0
	Entries={ 0x0defee2a, 0x0defee9e, 0x0defef74, 0x0defefc4 }
 */
/*
  FACP: Length=116, Revision=1, Checksum=124,
	OEMID=HP, OEM Table ID=3091, OEM Revision=0x20041209,
	Creator ID=PTL, Creator Revision=0x5f
 	FACS=0xdefffc0, DSDT=0xdef8b0c
	INT_MODEL=PIC
	Preferred_PM_Profile=Unspecified (0)
	SCI_INT=9
	SMI_CMD=0xb0, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
	PSTATE_CNT=0x0
	PM1a_EVT_BLK=0x8000-0x8003
	PM1b_EVT_BLK=0x8104-0x8107
	PM1a_CNT_BLK=0x8004-0x8005
	PM2_CNT_BLK=0x8100-0x8100
	PM_TMR_BLK=0x8008-0x800b
	GPE0_BLK=0x8020-0x8027
	P_LVL2_LAT=18 us, P_LVL3_LAT=1001 us
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=3
	DAY_ALRM=13, MON_ALRM=0, CENTURY=0
	IAPC_BOOT_ARCH=
	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4,TMR_VAL_EXT}
 */
/*
  FACS:	Length=64, HwSig=0x00000000, Firm_Wake_Vec=0x00000000
	Global_Lock=
	Flags=
	Version=0
 */
/*
  DSDT: Length=25374, Revision=1, Checksum=215,
	OEMID=HP, OEM Table ID=3091, OEM Revision=0x20041209,
	Creator ID=MSFT, Creator Revision=0x100000e
 */
/*
  SSDT: Length=214, Revision=1, Checksum=141,
	OEMID=PTLTD, OEM Table ID=POWERNOW, OEM Revision=0x20041209,
	Creator ID= LTP, Creator Revision=0x1
 */
/*
  APIC: Length=80, Revision=1, Checksum=104,
	OEMID=PTLTD, OEM Table ID=	 3091, OEM Revision=0x20041209,
	Creator ID= LTP, Creator Revision=0x0
	Local APIC ADDR=0xfee00000
	Flags={PC-AT}

	Type=Local APIC
	ACPI CPU=0
	Flags={ENABLED}
	APIC ID=0

	Type=IO APIC
	APIC ID=1
	INT BASE=0
	ADDR=0x00000000fec00000

	Type=INT Override
	BUS=0
	IRQ=9
	INTR=21
	Flags={Polarity=active-lo, Trigger=level}

	Type=Local NMI
	ACPI CPU=0
	LINT Pin=1
	Flags={Polarity=active-hi, Trigger=edge}
 */
/*
  MCFG: Length=60, Revision=1, Checksum=50,
	OEMID=PTLTD, OEM Table ID=  MCFG, OEM Revision=0x20041209,
	Creator ID= LTP, Creator Revision=0x0

	Base Address= 0x00000000e0000000
	Segment Group= 0x0000
	Start Bus= 0
	End Bus= 0
 */
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20041119
 *
 * Disassembly of /tmp/acpidump.37hD9i, Mon Feb  6 15:13:12 2006
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "HP    ", "3091    ", 537137673)
{
    Name (Z000, 0x01)
    Name (Z001, 0x02)
    Name (Z002, 0x04)
    Name (Z003, 0x08)
    Name (Z004, 0x00)
    Name (Z005, 0x0F)
    Name (Z006, 0x0D)
    Name (Z007, 0x0B)
    Name (Z008, 0x09)
    Method (VTOB, 1, NotSerialized)
    {
        Store (0x01, Local0)
        ShiftLeft (Local0, Arg0, Local0)
        Return (Local0)
    }

    Method (BTOV, 1, NotSerialized)
    {
        ShiftRight (Arg0, 0x01, Local0)
        Store (0x00, Local1)
        While (Local0)
        {
            Increment (Local1)
            ShiftRight (Local0, 0x01, Local0)
        }

        Return (Local1)
    }

    Method (MKWD, 2, NotSerialized)
    {
        If (And (Arg1, 0x80))
        {
            Store (0xFFFF0000, Local0)
        }
        Else
        {
            Store (Zero, Local0)
        }

        Or (Local0, Arg0, Local0)
        Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
        Return (Local0)
    }

    Method (POSW, 1, NotSerialized)
    {
        If (And (Arg0, 0x8000))
        {
            If (LEqual (Arg0, 0xFFFF))
            {
                Return (0xFFFFFFFF)
            }
            Else
            {
                Not (Arg0, Local0)
                Increment (Local0)
                And (Local0, 0xFFFF, Local0)
                Return (Local0)
            }
        }
        Else
        {
            Return (Arg0)
        }
    }

    Method (GBFE, 3, NotSerialized)
    {
        CreateByteField (Arg0, Arg1, TIDX)
        Store (TIDX, Arg2)
    }

    Method (PBFE, 3, NotSerialized)
    {
        CreateByteField (Arg0, Arg1, TIDX)
        Store (Arg2, TIDX)
    }

    Method (ITOS, 1, NotSerialized)
    {
        Store (Buffer (0x09)
            {
                0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00
            }, Local0)
        Store (Buffer (0x11)
            {
                "0123456789ABCDEF"
            }, Local7)
        Store (0x08, Local1)
        Store (0x00, Local2)
        Store (0x00, Local3)
        While (Local1)
        {
            Decrement (Local1)
            And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
            If (Local4)
            {
                Store (Ones, Local3)
            }

            If (Local3)
            {
                GBFE (Local7, Local4, RefOf (Local5))
                PBFE (Local0, Local2, Local5)
                Increment (Local2)
            }
        }

        Return (Local0)
    }

    Name (WIRE, 0x00)
    Scope (\_PR)
    {
        Processor (CPU0, 0x00, 0x00008010, 0x06) {}
    }

    Name (_S0, Package (0x04)
    {
        0x00,
        0x00,
        0x00,
        0x00
    })
    Name (_S3, Package (0x04)
    {
        0x03,
        0x03,
        0x00,
        0x00
    })
    Name (_S4, Package (0x04)
    {
        0x04,
        0x04,
        0x00,
        0x00
    })
    Name (_S5, Package (0x04)
    {
        0x05,
        0x05,
        0x00,
        0x00
    })
    OperationRegion (\DEBG, SystemIO, 0x80, 0x01)
    Field (\DEBG, ByteAcc, NoLock, Preserve)
    {
        DBGP,   8
    }

    OperationRegion (\PMIO, SystemIO, 0x0CD6, 0x02)
    Field (\PMIO, ByteAcc, NoLock, Preserve)
    {
        PIDX,   8,
        PDAT,   8
    }

    OperationRegion (GPE0, SystemIO, 0x8024, 0x04)
    Field (GPE0, ByteAcc, NoLock, Preserve)
    {
            ,   4,
        PMEE,   1,
            ,   4,
        A97E,   1
    }

    OperationRegion (\P01, SystemIO, 0x8001, 0x01)
    Field (\P01, ByteAcc, NoLock, Preserve)
    {
        PST1,   8
    }

    Name (HTTX, 0x00)
    Method (_PTS, 1, NotSerialized)
    {
        Store (0x01, PMEE)
        Store (0x60, PIDX)
        Sleep (0x0A)
        Store (PDAT, Local0)
        And (Local0, 0x7F, Local0)
        Store (Local0, PDAT)
        Sleep (0x0A)
        Store (\_SB.PCI0.SMB.GPOW, Local1)
        Store (Local1, \_SB.WILS)
        Store (0x13, \_SB.PCI0.SMB.INCM)
        Sleep (0x0A)
        Store (0x40, \_SB.PCI0.SMB.DACM)
        Sleep (0x0A)
        Store (0xF7, \_SB.PCI0.SMB.PTGM)
        Sleep (0x0A)
        Store (0x80, \_SB.PCI0.SMB.DACM)
        Sleep (0x0A)
        Store (\_SB.PCI0.SMB.PTGM, Local1)
        Sleep (0x0A)
        And (Local1, 0x08, Local1)
        If (LEqual (Local1, 0x08))
        {
            Store (0x01, Local1)
            Store (Local1, \_SB.BLTS)
        }
        Else
        {
            Store (0x00, Local1)
            Store (Local1, \_SB.BLTS)
        }

        If (LEqual (Arg0, 0x05))
        {
            Store (One, \_SB.PCI0.SMB.SLPS)
            Store (0x88, \_SB.PCI0.LPC0.BCMD)
            Store (Zero, \_SB.PCI0.LPC0.SMIC)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (\_SB.PCI0.SMB.RVID, Local1)
            If (LNot (LLess (Local1, 0x10)))
            {
                Store (Zero, \_SB.PCI0.SMB.RSTU)
            }

            Store (One, \_SB.PCI0.SMB.SLPS)
            Store (0x87, \_SB.PCI0.LPC0.BCMD)
            Store (Zero, \_SB.PCI0.LPC0.SMIC)
        }

        Store (\_SB.PCI0.SMB.RVID, Local1)
        If (LNot (LLess (Local1, 0x80)))
        {
            Store (Zero, \_SB.PCI0.SMB.RS3U)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (One, \_SB.PCI0.SMB.SLPS)
        }
    }

    Method (_WAK, 1, NotSerialized)
    {
        Store (0x00, PMEE)
        Store (\_SB.WILS, Local0)
        Store (Local0, \_SB.PCI0.SMB.GPOW)
        Store (0x13, \_SB.PCI0.SMB.INCM)
        Sleep (0x0A)
        Store (0x40, \_SB.PCI0.SMB.DACM)
        Sleep (0x0A)
        Store (0xF7, \_SB.PCI0.SMB.PTGM)
        Sleep (0x0A)
        Store (0x80, \_SB.PCI0.SMB.DACM)
        Sleep (0x0A)
        Store (\_SB.PCI0.SMB.PTGM, Local1)
        Sleep (0x0A)
        If (\_SB.BLTS)
        {
            Or (Local1, 0x08, Local1)
            Store (Local1, \_SB.PCI0.SMB.PTGM)
        }
        Else
        {
            And (Local1, 0xF7, Local1)
            Store (Local1, \_SB.PCI0.SMB.PTGM)
        }

        Sleep (0x0A)
        Store (0x81, \_SB.PCI0.LPC0.BCMD)
        Store (Zero, \_SB.PCI0.LPC0.SMIC)
        Store (0x30, DBGP)
        If (LEqual (Arg0, 0x03))
        {
            Store (0x61, PIDX)
            Store (PDAT, Local0)
            And (Local0, 0x80, Local0)
            If (LEqual (Local0, 0x00))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0x80, \_SB.PCI0.LPC0.BCMD)
            Store (0x00, \_SB.PCI0.LPC0.SMIC)
            Notify (\_SB.PWRB, 0x02)
        }
    }

    Scope (\_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x01))
            {
                Store ("===== SST Working =====", Debug)
            }

            If (LEqual (Arg0, 0x02))
            {
                Store ("===== SST Waking =====", Debug)
            }

            If (LEqual (Arg0, 0x03))
            {
                Store ("===== SST Sleeping =====", Debug)
            }

            If (LEqual (Arg0, 0x04))
            {
                Store ("===== SST Sleeping S4 =====", Debug)
            }
        }
    }

    Scope (\_TZ)
    {
        Name (TPAS, 0x5D)
        Name (TPC, 0x69)
        ThermalZone (THRM)
        {
            Method (_CRT, 0, Serialized)
            {
                Return (Add (0x0AAC, Multiply (TPC, 0x0A)))
            }

            Method (_SCP, 1, Serialized)
            {
                Store (0x00, CTYP)
            }

            Method (_TMP, 0, Serialized)
            {
                If (ECON)
                {
                    Store (\_SB.PCI0.LPC0.EC0.RTMP, Local0)
                    Store ("Current temp is: ", Debug)
                    Store (Local0, Debug)
                    Store (Local0, \_SB.CM25)
                    Return (Add (0x0AAC, Multiply (Local0, 0x0A)))
                }
                Else
                {
                    Store ("Get EC Temp failed!!", Debug)
                    Return (0x0BB8)
                }
            }

            Method (_PSL, 0, Serialized)
            {
                Return (Package (0x01)
                {
                    \_PR.CPU0
                })
            }

            Method (_PSV, 0, Serialized)
            {
                Return (Add (0x0AAC, Multiply (TPAS, 0x0A)))
            }

            Method (_TC1, 0, Serialized)
            {
                Return (0x02)
            }

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

            Method (_TSP, 0, Serialized)
            {
                Return (0x64)
            }
        }
    }

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

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

            Return (^OSTB)
        }

        Method (OSHT, 0, NotSerialized)
        {
            \_SB.OSTP ()
            Store (0x48, \_SB.PCI0.LPC0.BCMD)
            Store (Zero, \_SB.PCI0.LPC0.SMIC)
        }

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

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

                Increment (Local2)
            }

            Return (One)
        }
    }

    Name (FWSO, "FWSO")
    Name (_PSC, 0x00)
    Method (_PS0, 0, NotSerialized)
    {
        Store (_PSC, Local0)
        Store (0x00, _PSC)
        If (LEqual (Local0, 0x03))
        {
            Store (0x01, \_SB.PCI0.LPC0.INF)
            While (\_SB.PCI0.LPC0.INF)
            {
                Store (0x20, \_SB.PCI0.LPC0.BCMD)
                Store (Zero, \_SB.PCI0.LPC0.SMIC)
                If (LAnd (LEqual (\_SB.PCI0.LPC0.INF, 0x01), LNot
(LLess (\_SB.OSTB, 0x04))))
                {
                    Sleep (0x01F4)
                }
            }
        }
    }

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

    Name (\GPIC, 0x00)
    Method (\_PIC, 1, NotSerialized)
    {
        Store (Arg0, GPIC)
        If (Arg0)
        {
            \_SB.PCI0.LPC0.DSPI ()
        }
    }

    Name (ECON, 0x00)
    Name (CTYP, 0x00)
    Scope (\_SB)
    {
        Name (WIRE, 0x00)
        Name (WILS, 0x00)
        Name (BLTS, 0x00)
        Name (GPOB, 0x00)
        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
        }

        Device (SLPB)
        {
            Name (_HID, EisaId ("PNP0C0E"))
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Name (LSTS, 0x00)
            Method (_LID, 0, NotSerialized)
            {
                If (ECON)
                {
                    If (\_SB.PCI0.LPC0.EC0.LIDS)
                    {
                        Store (Zero, LSTS)
                    }
                    Else
                    {
                        Store (One, LSTS)
                    }
                }
                Else
                {
                    Store (One, LSTS)
                }

                Return (LSTS)
            }
        }

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

        IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
        {
            Offset (0xA0),
            DISD,   3,
            OVRL,   1,
            DCKS,   1,
            ACST,   1,
            POPF,   1,
            FL07,   1,
            FL10,   1,
            FL11,   1,
            FL12,   1,
            FL13,   1,
            FL14,   1,
            FL15,   1,
            FL16,   1,
            FL17,   1,
            FL20,   2,
            FL21,   2,
            FL22,   2,
            FL23,   2,
            CM23,   8,
            CM24,   8,
            CM25,   8,
            CM26,   8,
            CM27,   8,
            CM28,   8,
            CM29,   8,
            CM2A,   8,
            CM2B,   8,
            CM2C,   8,
            CM2D,   8,
            CM2E,   8,
            CM2F,   8,
            Offset (0xB1),
            HPBD,   8,
            BTWL,   2,
            BTLS,   1,
            BWLS,   1,
            WWLS,   1,
            Offset (0xB3),
            WLSU,   1,
            BTSU,   1,
            PWDC,   3,
            POTL,   1
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_UID, 0x01)
            Name (_BBN, 0x00)
            Method (_INI, 0, NotSerialized)
            {
                \_SB.OSTP ()
            }

            OperationRegion (K8ST, SystemMemory, 0x0DEFFF04, 0x000000B8)
            Field (K8ST, AnyAcc, Lock, Preserve)
            {
                C0_0,   16,
                C2_0,   16,
                C4_0,   16,
                C6_0,   16,
                C8_0,   16,
                CA_0,   16,
                CC_0,   16,
                CE_0,   16,
                D0_0,   16,
                D2_0,   16,
                D4_0,   16,
                D6_0,   16,
                D8_0,   16,
                DA_0,   16,
                DC_0,   16,
                DE_0,   16,
                E0_0,   16,
                E2_0,   16,
                E4_0,   16,
                E6_0,   16,
                E8_0,   16,
                EA_0,   16,
                EC_0,   16,
                EE_0,   16,
                F0_0,   16,
                F2_0,   16,
                F4_0,   16,
                F6_0,   16,
                F8_0,   16,
                FA_0,   16,
                FC_0,   16,
                FE_0,   16,
                TOML,   32,
                TOMH,   32
            }

            Name (RSRC, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, SubDecode,
                    0x0000,
                    0x0000,
                    0x00FF,
                    0x0000,
                    0x0100, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000A0000,
                    0x000BFFFF,
                    0x00000000,
                    0x00020000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000C0000,
                    0x000C1FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000C2000,
                    0x000C3FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000C4000,
                    0x000C5FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000C6000,
                    0x000C7FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000C8000,
                    0x000C9FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000CA000,
                    0x000CBFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000CC000,
                    0x000CDFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000CE000,
                    0x000CFFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000D0000,
                    0x000D1FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000D2000,
                    0x000D3FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000D4000,
                    0x000D5FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000D6000,
                    0x000D7FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000D8000,
                    0x000D9FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000DA000,
                    0x000DBFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000DC000,
                    0x000DDFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000DE000,
                    0x000DFFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000E0000,
                    0x000E1FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000E2000,
                    0x000E3FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000E4000,
                    0x000E5FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000E6000,
                    0x000E7FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000E8000,
                    0x000E9FFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000EA000,
                    0x000EBFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000EC000,
                    0x000EDFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x000EE000,
                    0x000EFFFF,
                    0x00000000,
                    0x00002000, 0x00)
                DWordMemory (ResourceProducer, SubDecode, MinFixed,
MaxFixed, NonCacheable, ReadWrite,
                    0x00000000,
                    0x00000000,
                    0xFFFFFFFF,
                    0x00000000,
                    0x00000000, 0x00)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed,
PosDecode, EntireRange,
                    0x0000,
                    0x0000,
                    0x0CF7,
                    0x0000,
                    0x0CF8, 0x00)
                WordIO (ResourceProducer, MinFixed, MaxFixed,
PosDecode, EntireRange,
                    0x0000,
                    0x0D00,
                    0xFFFF,
                    0x0000,
                    0xF300, 0x00)
            })
            Method (_CRS, 0, Serialized)
            {
                CreateBitField (RSRC, 0x0188, C0RW)
                CreateDWordField (RSRC, 0x42, C0LN)
                Store (One, C0RW)
                Store (0x2000, C0LN)
                If (And (C0_0, 0x1818))
                {
                    Store (0x00, C0LN)
                }

                CreateBitField (RSRC, 0x0260, C2RW)
                CreateDWordField (RSRC, 0x5D, C2LN)
                Store (One, C2RW)
                Store (0x2000, C2LN)
                If (And (C2_0, 0x1818))
                {
                    Store (0x00, C2LN)
                }

                CreateBitField (RSRC, 0x0338, C4RW)
                CreateDWordField (RSRC, 0x78, C4LN)
                Store (One, C4RW)
                Store (0x2000, C4LN)
                If (And (C4_0, 0x1818))
                {
                    Store (0x00, C4LN)
                }

                CreateBitField (RSRC, 0x0410, C6RW)
                CreateDWordField (RSRC, 0x93, C6LN)
                Store (One, C6RW)
                Store (0x2000, C6LN)
                If (And (C6_0, 0x1818))
                {
                    Store (0x00, C6LN)
                }

                CreateBitField (RSRC, 0x04E8, C8RW)
                CreateDWordField (RSRC, 0xAE, C8LN)
                Store (One, C8RW)
                Store (0x2000, C8LN)
                If (And (C8_0, 0x1818))
                {
                    Store (0x00, C8LN)
                }

                CreateBitField (RSRC, 0x05C0, CARW)
                CreateDWordField (RSRC, 0xC9, CALN)
                Store (One, CARW)
                Store (0x2000, CALN)
                If (And (CA_0, 0x1818))
                {
                    Store (0x00, CALN)
                }

                CreateBitField (RSRC, 0x0698, CCRW)
                CreateDWordField (RSRC, 0xE4, CCLN)
                Store (One, CCRW)
                Store (0x2000, CCLN)
                If (And (CC_0, 0x1818))
                {
                    Store (0x00, CCLN)
                }

                CreateBitField (RSRC, 0x0770, CERW)
                CreateDWordField (RSRC, 0xFF, CELN)
                Store (One, CERW)
                Store (0x2000, CELN)
                If (And (CE_0, 0x1818))
                {
                    Store (0x00, CELN)
                }

                CreateBitField (RSRC, 0x0848, D0RW)
                CreateDWordField (RSRC, 0x011A, D0LN)
                Store (One, D0RW)
                Store (0x2000, D0LN)
                If (And (D0_0, 0x1818))
                {
                    Store (0x00, D0LN)
                }

                CreateBitField (RSRC, 0x0920, D2RW)
                CreateDWordField (RSRC, 0x0135, D2LN)
                Store (One, D2RW)
                Store (0x2000, D2LN)
                If (And (D2_0, 0x1818))
                {
                    Store (0x00, D2LN)
                }

                CreateBitField (RSRC, 0x09F8, D4RW)
                CreateDWordField (RSRC, 0x0150, D4LN)
                Store (One, D4RW)
                Store (0x2000, D4LN)
                If (And (D4_0, 0x1818))
                {
                    Store (0x00, D4LN)
                }

                CreateBitField (RSRC, 0x0AD0, D6RW)
                CreateDWordField (RSRC, 0x016B, D6LN)
                Store (One, D6RW)
                Store (0x2000, D6LN)
                If (And (D6_0, 0x1818))
                {
                    Store (0x00, D6LN)
                }

                CreateBitField (RSRC, 0x0BA8, D8RW)
                CreateDWordField (RSRC, 0x0186, D8LN)
                Store (One, D8RW)
                Store (0x2000, D8LN)
                If (And (D8_0, 0x1818))
                {
                    Store (0x00, D8LN)
                }

                CreateBitField (RSRC, 0x0C80, DARW)
                CreateDWordField (RSRC, 0x01A1, DALN)
                Store (One, DARW)
                Store (0x2000, DALN)
                If (And (DA_0, 0x1818))
                {
                    Store (0x00, DALN)
                }

                CreateBitField (RSRC, 0x0D58, DCRW)
                CreateDWordField (RSRC, 0x01BC, DCLN)
                Store (One, DCRW)
                Store (0x2000, DCLN)
                If (And (DC_0, 0x1818))
                {
                    Store (0x00, DCLN)
                }

                CreateBitField (RSRC, 0x0E30, DERW)
                CreateDWordField (RSRC, 0x01D7, DELN)
                Store (One, DERW)
                Store (0x2000, DELN)
                If (And (DE_0, 0x1818))
                {
                    Store (0x00, DELN)
                }

                CreateBitField (RSRC, 0x0F08, E0RW)
                CreateDWordField (RSRC, 0x01F2, E0LN)
                Store (One, E0RW)
                Store (0x2000, E0LN)
                If (And (E0_0, 0x1818))
                {
                    Store (0x00, E0LN)
                }

                CreateBitField (RSRC, 0x0FE0, E2RW)
                CreateDWordField (RSRC, 0x020D, E2LN)
                Store (One, E2RW)
                Store (0x2000, E2LN)
                If (And (E2_0, 0x1818))
                {
                    Store (0x00, E2LN)
                }

                CreateBitField (RSRC, 0x10B8, E4RW)
                CreateDWordField (RSRC, 0x0228, E4LN)
                Store (One, E4RW)
                Store (0x2000, E4LN)
                If (And (E4_0, 0x1818))
                {
                    Store (0x00, E4LN)
                }

                CreateBitField (RSRC, 0x1190, E6RW)
                CreateDWordField (RSRC, 0x0243, E6LN)
                Store (One, E6RW)
                Store (0x2000, E6LN)
                If (And (E6_0, 0x1818))
                {
                    Store (0x00, E6LN)
                }

                CreateBitField (RSRC, 0x1268, E8RW)
                CreateDWordField (RSRC, 0x025E, E8LN)
                Store (One, E8RW)
                Store (0x2000, E8LN)
                If (And (E8_0, 0x1818))
                {
                    Store (0x00, E8LN)
                }

                CreateBitField (RSRC, 0x1340, EARW)
                CreateDWordField (RSRC, 0x0279, EALN)
                Store (One, EARW)
                Store (0x2000, EALN)
                If (And (EA_0, 0x1818))
                {
                    Store (0x00, EALN)
                }

                CreateBitField (RSRC, 0x1418, ECRW)
                CreateDWordField (RSRC, 0x0294, ECLN)
                Store (One, ECRW)
                Store (0x2000, ECLN)
                If (And (EC_0, 0x1818))
                {
                    Store (0x00, ECLN)
                }

                CreateBitField (RSRC, 0x14F0, EERW)
                CreateDWordField (RSRC, 0x02AF, EELN)
                Store (One, EERW)
                Store (0x2000, EELN)
                If (And (EE_0, 0x1818))
                {
                    Store (0x00, EELN)
                }

                CreateDWordField (RSRC, 0x02BE, BTMN)
                CreateDWordField (RSRC, 0x02CA, BTLN)
                Store (TOML, BTMN)
                Add (Not (BTMN), 0x01, BTLN)
                Return (RSRC)
            }

            Device (MEMR)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (MEM1, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite, 0xE0000000, 0x10000000)
                    Memory32Fixed (ReadWrite, 0x00000000, 0x00000000)
                    Memory32Fixed (ReadWrite, 0x00000000, 0x00000000)
                })
                Method (_CRS, 0, NotSerialized)
                {
                    CreateDWordField (MEM1, 0x10, MB01)
                    CreateDWordField (MEM1, 0x14, ML01)
                    CreateDWordField (MEM1, 0x1C, MB02)
                    CreateDWordField (MEM1, 0x20, ML02)
                    If (GPIC)
                    {
                        Store (0xFEC00000, MB01)
                        Store (0xFEE00000, MB02)
                        Store (0x1000, ML01)
                        Store (0x1000, ML02)
                    }

                    Return (MEM1)
                }
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (GPIC)
                {
                    Return (Package (0x05)
                    {
                        Package (0x04)
                        {
                            0x0013FFFF,
                            0x00,
                            0x00,
                            0x13
                        },

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

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

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

                        Package (0x04)
                        {
                            0x0014FFFF,
                            0x03,
                            0x00,
                            0x13
                        }
                    })
                }
                Else
                {
                    Return (Package (0x07)
                    {
                        Package (0x04)
                        {
                            0x0011FFFF,
                            0x00,
                            \_SB.PCI0.LPC0.LNKH,
                            0x00
                        },

                        Package (0x04)
                        {
                            0x0012FFFF,
                            0x00,
                            \_SB.PCI0.LPC0.LNKG,
                            0x00
                        },

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

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

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

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

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

            OperationRegion (BAR1, PCI_Config, 0x14, 0x04)
            Field (BAR1, ByteAcc, NoLock, Preserve)
            {
                Z009,   32
            }

            Device (OHC1)
            {
                Name (_ADR, 0x00130000)
            }

            Device (OHC2)
            {
                Name (_ADR, 0x00130001)
            }

            Device (EHCI)
            {
                Name (_ADR, 0x00130002)
            }

            Device (SMB)
            {
                Name (_ADR, 0x00140000)
                OperationRegion (Z00A, PCI_Config, 0x08, 0x01)
                Field (Z00A, ByteAcc, NoLock, Preserve)
                {
                    RVID,   8
                }

                OperationRegion (CMIO, SystemIO, 0x0C50, 0x03)
                Field (CMIO, ByteAcc, NoLock, Preserve)
                {
                    INCM,   8,
                    DACM,   8,
                    PTGM,   8
                }

                OperationRegion (RGA8, PCI_Config, 0xA8, 0x01)
                Field (RGA8, ByteAcc, NoLock, Preserve)
                {
                        ,   2,
                    GPOW,   1
                }

                OperationRegion (PMIO, SystemIO, 0x0CD6, 0x02)
                Field (PMIO, ByteAcc, NoLock, Preserve)
                {
                    INPM,   8,
                    DAPM,   8
                }

                IndexField (INPM, DAPM, ByteAcc, NoLock, Preserve)
                {
                        ,   1,
                    TM1E,   1,
                    TM2E,   1,
                    Offset (0x01),
                        ,   1,
                    TM1S,   1,
                    TM2S,   1,
                    Offset (0x04),
                        ,   7,
                    SLPS,   1,
                    Offset (0x1C),
                        ,   3,
                    MKME,   1,
                    PI3E,   1,
                    PI2E,   1,
                    PI1E,   1,
                    PI0E,   1,
                        ,   3,
                    MKMS,   1,
                    PI3S,   1,
                    PI2S,   1,
                    PI1S,   1,
                    PI0S,   1,
                    Offset (0x36),
                        ,   6,
                    GVT6,   1,
                    Offset (0x37),
                        ,   4,
                    GPX1,   1,
                        ,   1,
                    GPX3,   1,
                    Offset (0x38),
                        ,   1,
                    GPX4,   1,
                    GPX5,   1,
                        ,   1,
                    GPX6,   1,
                    Offset (0x55),
                    SPRE,   1,
                    Offset (0x65),
                        ,   4,
                    RS3U,   1,
                    RSTU,   1,
                    Offset (0x68),
                        ,   3,
                    TPDE,   1,
                        ,   1
                }

                Method (TRMD, 0, NotSerialized)
                {
                    Store (Zero, SPRE)
                    Store (Zero, TPDE)
                }

                Method (HTCD, 0, NotSerialized)
                {
                    Store (Zero, PI2E)
                    Store (Zero, TM2E)
                    Store (PI2S, PI2S)
                    Store (TM2S, TM2S)
                }
            }

            Device (IDE)
            {
                Name (_ADR, 0x00140001)
                Name (UDMT, Package (0x08)
                {
                    0x78,
                    0x5A,
                    0x3C,
                    0x2D,
                    0x1E,
                    0x14,
                    0x0F,
                    0x00
                })
                Name (PIOT, Package (0x06)
                {
                    0x0258,
                    0x0186,
                    0x010E,
                    0xB4,
                    0x78,
                    0x00
                })
                Name (PITR, Package (0x06)
                {
                    0x99,
                    0x47,
                    0x34,
                    0x22,
                    0x20,
                    0x99
                })
                Name (MDMT, Package (0x04)
                {
                    0x01E0,
                    0x96,
                    0x78,
                    0x00
                })
                Name (MDTR, Package (0x04)
                {
                    0x77,
                    0x21,
                    0x20,
                    0xFF
                })
                OperationRegion (IDE, PCI_Config, 0x40, 0x20)
                Field (IDE, WordAcc, NoLock, Preserve)
                {
                    PPIT,   16,
                    SPIT,   16,
                    PMDT,   16,
                    SMDT,   16,
                    PPIC,   8,
                    SPIC,   8,
                    PPIM,   8,
                    SPIM,   8,
                    Offset (0x14),
                    PUDC,   2,
                    SUDC,   2,
                    Offset (0x16),
                    PUDM,   8,
                    SUDM,   8
                }

                Method (ATPI, 1, NotSerialized)
                {
                    Store (Arg0, Local0)
                    And (Local0, 0xFF, Local0)
                    Or (Local0, 0x41544900, Local0)
                    Store (Local0, \_SB.PCI0.LPC0.INFO)
                    Store (0x84, \_SB.PCI0.LPC0.BCMD)
                    Store (Zero, \_SB.PCI0.LPC0.SMIC)
                }

                Method (GETT, 1, NotSerialized)
                {
                    Store (And (Arg0, 0x0F), Local0)
                    Store (ShiftRight (Arg0, 0x04), Local1)
                    Return (Multiply (0x1E, Add (Add (Local0, 0x01),
Add (Local1, 0x01))))
                }

                Method (GTM, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x00, PIT1)
                    CreateByteField (Arg0, 0x01, PIT0)
                    CreateByteField (Arg0, 0x02, MDT1)
                    CreateByteField (Arg0, 0x03, MDT0)
                    CreateByteField (Arg0, 0x04, PICX)
                    CreateByteField (Arg0, 0x05, UDCX)
                    CreateByteField (Arg0, 0x06, UDMX)
                    Name (BUF, Buffer (0x14)
                    {
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0x00, 0x00, 0x00, 0x00
                    })
                    CreateDWordField (BUF, 0x00, PIO0)
                    CreateDWordField (BUF, 0x04, DMA0)
                    CreateDWordField (BUF, 0x08, PIO1)
                    CreateDWordField (BUF, 0x0C, DMA1)
                    CreateDWordField (BUF, 0x10, FLAG)
                    If (And (PICX, 0x01))
                    {
                        Return (BUF)
                    }

                    Store (GETT (PIT0), PIO0)
                    Store (GETT (PIT1), PIO1)
                    If (And (UDCX, 0x01))
                    {
                        Or (FLAG, 0x01, FLAG)
                        Store (DerefOf (Index (^UDMT, And (UDMX, 0x0F))), DMA0)
                    }
                    Else
                    {
                        Store (GETT (MDT0), DMA0)
                    }

                    If (And (UDCX, 0x02))
                    {
                        Or (FLAG, 0x04, FLAG)
                        Store (DerefOf (Index (^UDMT, ShiftRight
(UDMX, 0x04))), DMA1)
                    }
                    Else
                    {
                        Store (GETT (MDT1), DMA1)
                    }

                    Or (FLAG, 0x1A, FLAG)
                    Return (BUF)
                }

                Method (STM, 3, NotSerialized)
                {
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Name (BUF, Buffer (0x07)
                    {
                        0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                    })
                    CreateByteField (BUF, 0x00, PIT1)
                    CreateByteField (BUF, 0x01, PIT0)
                    CreateByteField (BUF, 0x02, MDT1)
                    CreateByteField (BUF, 0x03, MDT0)
                    CreateByteField (BUF, 0x04, PIMX)
                    CreateByteField (BUF, 0x05, UDCX)
                    CreateByteField (BUF, 0x06, UDMX)
                    Store (Match (^PIOT, MLE, PIO0, MTR, 0x00, 0x00), Local0)
                    Divide (Local0, 0x05, Local0)
                    Store (Match (^PIOT, MLE, PIO1, MTR, 0x00, 0x00), Local1)
                    Divide (Local1, 0x05, Local1)
                    Store (Or (ShiftLeft (Local1, 0x04), Local0), PIMX)
                    Store (DerefOf (Index (^PITR, Local0)), PIT0)
                    Store (DerefOf (Index (^PITR, Local1)), PIT1)
                    If (And (FLAG, 0x01))
                    {
                        Store (Match (^UDMT, MLE, DMA0, MTR, 0x00,
0x00), Local0)
                        Divide (Local0, 0x07, Local0)
                        Or (UDMX, Local0, UDMX)
                        Or (UDCX, 0x01, UDCX)
                    }
                    Else
                    {
                        If (LNot (LEqual (DMA0, 0xFFFFFFFF)))
                        {
                            Store (Match (^MDMT, MLE, DMA0, MTR, 0x00,
0x00), Local0)
                            Store (DerefOf (Index (^MDTR, Local0)), MDT0)
                        }
                    }

                    If (And (FLAG, 0x04))
                    {
                        Store (Match (^UDMT, MLE, DMA1, MTR, 0x00,
0x00), Local0)
                        Divide (Local0, 0x07, Local0)
                        Or (UDMX, ShiftLeft (Local0, 0x04), UDMX)
                        Or (UDCX, 0x02, UDCX)
                    }
                    Else
                    {
                        If (LNot (LEqual (DMA1, 0xFFFFFFFF)))
                        {
                            Store (Match (^MDMT, MLE, DMA1, MTR, 0x00,
0x00), Local0)
                            Store (DerefOf (Index (^MDTR, Local0)), MDT1)
                        }
                    }

                    Return (BUF)
                }

                Method (GTF, 2, NotSerialized)
                {
                    CreateByteField (Arg1, 0x00, MDT1)
                    CreateByteField (Arg1, 0x01, MDT0)
                    CreateByteField (Arg1, 0x02, PIMX)
                    CreateByteField (Arg1, 0x03, UDCX)
                    CreateByteField (Arg1, 0x04, UDMX)
                    If (LEqual (Arg0, 0xA0))
                    {
                        Store (And (PIMX, 0x0F), Local0)
                        Store (MDT0, Local1)
                        And (UDCX, 0x01, Local2)
                        Store (And (UDMX, 0x0F), Local3)
                    }
                    Else
                    {
                        Store (ShiftRight (PIMX, 0x04), Local0)
                        Store (MDT1, Local1)
                        And (UDCX, 0x02, Local2)
                        Store (ShiftRight (UDMX, 0x04), Local3)
                    }

                    Name (BUF, Buffer (0x0E)
                    {
                        0x03, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF, 0x03,
                        0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF
                    })
                    CreateByteField (BUF, 0x01, PMOD)
                    CreateByteField (BUF, 0x08, DMOD)
                    CreateByteField (BUF, 0x05, CMDA)
                    CreateByteField (BUF, 0x0C, CMDB)
                    Store (Arg0, CMDA)
                    Store (Arg0, CMDB)
                    Or (Local0, 0x08, PMOD)
                    If (Local2)
                    {
                        Or (Local3, 0x40, DMOD)
                    }
                    Else
                    {
                        Store (Match (^MDMT, MLE, GETT (Local1), MTR,
0x00, 0x00), Local4)
                        If (LLess (Local4, 0x03))
                        {
                            Or (0x20, Local4, DMOD)
                        }
                    }

                    Return (BUF)
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIC)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (^^PPIT, VPIT)
                        Store (^^PMDT, VMDT)
                        Store (^^PPIC, VPIC)
                        Store (^^PUDC, VUDC)
                        Store (^^PUDM, VUDM)
                        Return (GTM (BUF))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIM)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (STM (Arg0, Arg1, Arg2), BUF)
                        Store (VPIT, ^^PPIT)
                        Store (VMDT, ^^PMDT)
                        Store (VPIM, ^^PPIM)
                        Store (VUDC, ^^PUDC)
                        Store (VUDM, ^^PUDM)
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, 0x00, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (^^^PMDT, VMDT)
                            Store (^^^PPIM, VPIM)
                            Store (^^^PUDC, VUDC)
                            Store (^^^PUDM, VUDM)
                            Return (GTF (0xA0, BUF))
                        }
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        And (PPIC, 0x01, Local0)
                        If (LAnd (Local0, 0x01))
                        {
                            Return (Z006)
                        }
                        Else
                        {
                            Return (Z005)
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIC)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (^^SPIT, VPIT)
                        Store (^^SMDT, VMDT)
                        Store (^^SPIC, VPIC)
                        Store (^^SUDC, VUDC)
                        Store (^^SUDM, VUDM)
                        Return (GTM (BUF))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Name (BUF, Buffer (0x07)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        })
                        CreateWordField (BUF, 0x00, VPIT)
                        CreateWordField (BUF, 0x02, VMDT)
                        CreateByteField (BUF, 0x04, VPIM)
                        CreateByteField (BUF, 0x05, VUDC)
                        CreateByteField (BUF, 0x06, VUDM)
                        Store (STM (Arg0, Arg1, Arg2), BUF)
                        Store (VPIT, ^^SPIT)
                        Store (VMDT, ^^SMDT)
                        Store (VPIM, ^^SPIM)
                        Store (VUDC, ^^SUDC)
                        Store (VUDM, ^^SUDM)
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (BUF, Buffer (0x05)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00
                            })
                            CreateWordField (BUF, 0x00, VMDT)
                            CreateByteField (BUF, 0x02, VPIM)
                            CreateByteField (BUF, 0x03, VUDC)
                            CreateByteField (BUF, 0x04, VUDM)
                            Store (^^^SMDT, VMDT)
                            Store (^^^SPIM, VPIM)
                            Store (^^^SUDC, VUDC)
                            Store (^^^SUDM, VUDM)
                            Return (GTF (0xA0, BUF))
                        }
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        And (SPIC, 0x01, Local0)
                        If (LAnd (Local0, 0x01))
                        {
                            Return (Z006)
                        }
                        Else
                        {
                            Return (Z005)
                        }
                    }
                }
            }

            Device (LPC0)
            {
                Name (_ADR, 0x00140003)
                Mutex (PSMX, 0x00)
                OperationRegion (PIRQ, SystemIO, 0x0C00, 0x02)
                Field (PIRQ, ByteAcc, NoLock, Preserve)
                {
                    PIID,   8,
                    PIDA,   8
                }

                IndexField (PIID, PIDA, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   8,
                    PIRB,   8,
                    PIRC,   8,
                    PIRD,   8,
                    PIRS,   8,
                    Offset (0x06),
                    PIRU,   8,
                    Offset (0x09),
                    PIRE,   8,
                    PIRF,   8,
                    PIRG,   8,
                    PIRH,   8
                }

                Name (IPRS, ResourceTemplate ()
                {
                    IRQ (Level, ActiveLow, Shared) {10,11}
                })
                Method (DSPI, 0, NotSerialized)
                {
                    Store (0x00, PIRA)
                    Store (0x00, PIRB)
                    Store (0x00, PIRC)
                    Store (0x00, PIRD)
                    Store (0x00, PIRS)
                    Store (0x00, PIRU)
                    Store (0x00, PIRE)
                    Store (0x00, PIRF)
                    Store (0x00, PIRG)
                    Store (0x00, PIRH)
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRA)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRA, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRB)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRB, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRC)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRC, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRD)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRD)
                        Store (0x00, PIRU)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRD, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRE)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRE, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRF)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRF, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRG)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRG, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRH)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRH, IRQ0)
                        Return (Local0)
                    }

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

                Device (LNKU)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRU)
                        {
                            Return (Z007)
                        }
                        Else
                        {
                            Return (Z008)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (UPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRU)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (UPRS, Local0)
                        CreateWordField (Local0, 0x01, IRQ0)
                        ShiftLeft (0x01, PIRU, IRQ0)
                        Return (Local0)
                    }

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

                OperationRegion (LPCR, PCI_Config, 0x44, 0x02)
                Field (LPCR, ByteAcc, NoLock, Preserve)
                {
                    CMA0,   1,
                    CMA1,   1,
                    CMA2,   1,
                    CMA3,   1,
                    CMA4,   1,
                    CMA5,   1,
                    CMA6,   1,
                    CMA7,   1,
                    CMB0,   1,
                    CMB1,   1,
                    CMB2,   1,
                    CMB3,   1,
                    CMB4,   1,
                    CMB5,   1,
                    CMB6,   1,
                    CMB7,   1
                }

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

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x0F)
                        IRQ (Edge, ActiveHigh, Exclusive) {13}
                    })
                }

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

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

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

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

                Device (KBC0)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQ (Edge, ActiveHigh, Exclusive) {1}
                    })
                    Name (_PRW, Package (0x02)
                    {
                        0x03,
                        0x03
                    })
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (ECON)
                        {
                            Store (Arg0, \_SB.PCI0.LPC0.EC0.PSKB)
                        }
                    }
                }

                Device (MSE0)
                {
                    Method (_HID, 0, NotSerialized)
                    {
                        If (HPBD)
                        {
                            Return ("*SYN011C")
                        }
                        Else
                        {
                            Return ("*SYN011B")
                        }
                    }

                    Name (_CID, Package (0x03)
                    {
                        0x00012E4F,
                        0x02002E4F,
                        0x130FD041
                    })
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive) {12}
                    })
                    Name (_PRW, Package (0x02)
                    {
                        0x03,
                        0x03
                    })
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (ECON)
                        {
                            Store (Arg0, \_SB.PCI0.LPC0.EC0.PSTP)
                        }
                    }
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
                        IO (Decode16, 0x0072, 0x0072, 0x01, 0x02)
                        IO (Decode16, 0x1080, 0x1080, 0x01, 0x01)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x02)
                        IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
                        IO (Decode16, 0x0220, 0x0220, 0x01, 0x10)
                        IO (Decode16, 0x040B, 0x040B, 0x01, 0x01)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IO (Decode16, 0x04D6, 0x04D6, 0x01, 0x01)
                        IO (Decode16, 0x0530, 0x0530, 0x08, 0x08)
                        IO (Decode16, 0x0C00, 0x0C00, 0x01, 0x02)
                        IO (Decode16, 0x0C14, 0x0C14, 0x01, 0x01)
                        IO (Decode16, 0x0C50, 0x0C50, 0x01, 0x03)
                        IO (Decode16, 0x0C6C, 0x0C6C, 0x01, 0x01)
                        IO (Decode16, 0x0C6F, 0x0C6F, 0x01, 0x01)
                        IO (Decode16, 0x0CD4, 0x0CD4, 0x01, 0x02)
                        IO (Decode16, 0x0CD6, 0x0CD6, 0x01, 0x02)
                        IO (Decode16, 0x0CD8, 0x0CD8, 0x01, 0x08)
                        IO (Decode16, 0x8000, 0x8000, 0x01, 0x60)
                        WordIO (ResourceProducer, MinFixed, MaxFixed,
PosDecode, EntireRange,
                            0x0000,
                            0x8100,
                            0x81FF,
                            0x0000,
                            0x0100)
                        WordIO (ResourceProducer, MinFixed, MaxFixed,
PosDecode, EntireRange,
                            0x0000,
                            0x8200,
                            0x82FF,
                            0x0000,
                            0x0100)
                        IO (Decode16, 0x0F40, 0x0F40, 0x01, 0x08)
                        IO (Decode16, 0x087F, 0x087F, 0x01, 0x01)
                    })
                }

                Device (MEM)
                {
                    Name (_HID, EisaId ("PNP0C01"))
                    Name (MSRC, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly, 0x000E0000, 0x00020000)
                        Memory32Fixed (ReadOnly, 0xFFF80000, 0x00080000)
                        Memory32Fixed (ReadWrite, 0x00000000, 0x00000000)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        If (LNot (LLess (TPOS, 0x04)))
                        {
                            CreateDWordField (MSRC, 0x1C, BARX)
                            CreateDWordField (MSRC, 0x20, GALN)
                            Store (0x1000, GALN)
                            Store (\_SB.PCI0.Z009, Local0)
                            And (Local0, 0xFFFFFFF0, BARX)
                        }

                        Return (MSRC)
                    }

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

                OperationRegion (SMI0, SystemIO, 0x00000F40, 0x00000002)
                Field (SMI0, AnyAcc, NoLock, Preserve)
                {
                    SMIC,   8
                }

                OperationRegion (SMI1, SystemMemory, 0x0DEFFD74, 0x00000120)
                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    BCMD,   8,
                    DID,    32,
                    INFO,   1024
                }

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

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_UID, 0x01)
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BFFR, ResourceTemplate ()
                        {
                            IO (Decode16, 0x0062, 0x0062, 0x00, 0x01)
                            IO (Decode16, 0x0066, 0x0066, 0x00, 0x01)
                        })
                        Return (BFFR)
                    }

                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x04),
                        CMCM,   8,
                        CMD1,   8,
                        CMD2,   8,
                        CMD3,   8,
                        Offset (0x18),
                        SMPR,   8,
                        SMST,   8,
                        SMAD,   8,
                        SMCM,   8,
                        SMD0,   256,
                        BCNT,   8,
                        SMAA,   8,
                        BATD,   16,
                        SW2S,   1,
                        Offset (0x41),
                            ,   4,
                        CFAN,   1,
                        PFN2,   1,
                        WOLF,   1,
                        PFLG,   1,
                        Offset (0x43),
                        TMSS,   2,
                            ,   2,
                        BANK,   4,
                        Offset (0x45),
                        VFAN,   1,
                        Offset (0x46),
                        RL01,   1,
                        RD01,   1,
                        RF01,   1,
                        RP01,   1,
                        RB01,   1,
                        RC01,   1,
                            ,   1,
                        R701,   1,
                        R801,   1,
                        RM01,   1,
                        RI01,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        RA01,   1,
                        RR01,   1,
                        RL10,   1,
                        RD10,   1,
                        RF10,   1,
                        RP10,   1,
                        RB10,   1,
                        RC10,   1,
                            ,   1,
                        R710,   1,
                        R810,   1,
                        RM10,   1,
                        RI10,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        RA10,   1,
                        RR10,   1,
                        WL01,   1,
                        WD01,   1,
                        WF01,   1,
                        WP01,   1,
                        WB01,   1,
                        WC01,   1,
                            ,   1,
                        W701,   1,
                        W801,   1,
                        WM01,   1,
                        WI01,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        WA01,   1,
                        WR01,   1,
                        WL10,   1,
                        WD10,   1,
                        WF10,   1,
                        WP10,   1,
                        WB10,   1,
                        WC10,   1,
                            ,   1,
                        W710,   1,
                        W810,   1,
                        WM10,   1,
                        WI10,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        WA10,   1,
                        WR10,   1,
                        LIDE,   1,
                        BAYE,   1,
                        EFDE,   1,
                        PRDE,   1,
                        BRBE,   1,
                        CRTE,   1,
                            ,   1,
                        W7BE,   1,
                        W8BE,   1,
                        PMEE,   1,
                        INTE,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        DB2E,   1,
                        DB3E,   1,
                        Offset (0x52),
                        LIDS,   1,
                        BAYS,   1,
                        EFDS,   1,
                        PRDS,   1,
                        BRBS,   1,
                        CRTS,   1,
                            ,   1,
                        W7BS,   1,
                        W8BS,   1,
                        DPEM,   1,
                        DINT,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        DB2S,   1,
                        DB3S,   1,
                        SCIM,   8,
                        Offset (0x57),
                        RG57,   8,
                        RTMP,   8,
                        RG59,   8,
                        RG5A,   8,
                        RG5B,   8,
                        FSPD,   16,
                        Offset (0x5F),
                        CFN2,   1,
                        SFN2,   1,
                        Offset (0x71),
                        MBTS,   1,
                        MBTF,   1,
                        Offset (0x72),
                        MBTC,   1,
                            ,   2,
                        MBNH,   1,
                        Offset (0x77),
                        BA1C,   8,
                        Offset (0x7E),
                        BATP,   8,
                        Offset (0x81),
                        SBTS,   1,
                        SBTF,   1,
                        Offset (0x82),
                        SBTC,   1,
                        Offset (0x87),
                        BA2C,   8,
                        ABVG,   16,
                        Offset (0xC1),
                        MCUR,   16,
                        MBRM,   16,
                        MBVG,   16,
                        MBST,   8,
                        ACUR,   16,
                        ABRM,   16,
                        Offset (0xCF),
                        DLYC,   8,
                        EBPL,   1,
                        Offset (0xD2),
                            ,   6,
                        APWR,   1,
                        DLYE,   1,
                        Offset (0xD6),
                        DBPL,   8,
                        Offset (0xDA),
                        EPRW,   8,
                        PSKB,   1,
                        PSTP,   1,
                        PSBA,   1,
                        Offset (0xDF),
                        ECBW,   1,
                        Offset (0xE7),
                        GQKS,   7
                    }

                    Name (BATO, 0x00)
                    Name (BATN, 0x00)
                    Name (BATF, 0xC0)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, ECON)
                        }
                    }

                    Method (BPOL, 1, NotSerialized)
                    {
                        Store (Arg0, DBPL)
                        Store (0x01, EBPL)
                    }

                    Name (_GPE, 0x18)
                    Method (_Q09, 0, NotSerialized)
                    {
                        Store ("_Q09 : Delay Timer Handler", Debug)
                        If (LEqual (SizeOf (\_OS), 0x14))
                        {
                            Notify (\_SB.PCI0.LPC0.BAT1, 0x80)
                            Notify (\_SB.PCI0.LPC0.BAT1, 0x00)
                            Notify (\_SB.PCI0.LPC0.ACAD, 0x00)
                        }

                        If (LEqual (SizeOf (\_OS), 0x14))
                        {
                            BPOL (0x3C)
                        }
                    }

                    Method (_Q0D, 0, NotSerialized)
                    {
                        Acquire (\_SB.PCI0.LPC0.PSMX, 0xFFFF)
                        Store (0x8A, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.INFO)
                        Store (Zero, \_SB.PCI0.LPC0.SMIC)
                        Release (\_SB.PCI0.LPC0.PSMX)
                        Store (\_SB.PCI0.LPC0.INF, Local1)
                        And (Local1, 0x07, Local1)
                        If (LEqual (Local1, 0x01))
                        {
                            Store (0x01, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local1, 0x02))
                        {
                            Store (0x00, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local1, 0x03))
                        {
                            Store (0x01, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local1, 0x04))
                        {
                            Store (0x00, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local1, 0x05))
                        {
                            Store (0x01, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        Notify (\_SB.PCI0.AGP.VGA, 0x80)
                    }

                    Method (_Q0E, 0, NotSerialized)
                    {
                        Notify (\_SB.SLPB, 0x80)
                    }

                    Method (_Q10, 0, NotSerialized)
                    {
                        Store (0x8B, \_SB.PCI0.LPC0.BCMD)
                        Store (Zero, \_SB.PCI0.LPC0.SMIC)
                    }

                    Method (_Q11, 0, NotSerialized)
                    {
                        Store (0x8C, \_SB.PCI0.LPC0.BCMD)
                        Store (Zero, \_SB.PCI0.LPC0.SMIC)
                    }

                    Method (_Q15, 0, NotSerialized)
                    {
                        If (LOr (\_SB.BTSU, \_SB.WLSU))
                        {
                            If (\_SB.BTLS)
                            {
                                Store (0x00, \_SB.BTLS)
                                Store (0x00, \_SB.PCI0.SMB.GPOW)
                                Store (0x00, \_SB.GPOB)
                            }
                            Else
                            {
                                Store (0x01, \_SB.BTLS)
                                If (\_SB.WLSU)
                                {
                                    If (\_SB.WIRE)
                                    {
                                        If (\_SB.WWLS)
                                        {
                                            Store (0x01, \_SB.PCI0.SMB.GPOW)
                                        }
                                    }
                                    Else
                                    {
                                        Store (0x01, \_SB.PCI0.SMB.GPOW)
                                    }
                                }

                                If (\_SB.BTSU)
                                {
                                    If (\_SB.WIRE)
                                    {
                                        If (\_SB.BWLS)
                                        {
                                            Store (0x01, \_SB.GPOB)
                                        }
                                    }
                                    Else
                                    {
                                        Store (0x01, \_SB.GPOB)
                                    }
                                }
                            }
                        }
                        Else
                        {
                            Store (0x00, \_SB.BTLS)
                            Store (0x00, \_SB.PCI0.SMB.GPOW)
                            Store (0x00, \_SB.GPOB)
                        }

                        Store (0x13, \_SB.PCI0.SMB.INCM)
                        Sleep (0x0A)
                        Store (0x40, \_SB.PCI0.SMB.DACM)
                        Sleep (0x0A)
                        Store (0xF7, \_SB.PCI0.SMB.PTGM)
                        Sleep (0x0A)
                        Store (0x80, \_SB.PCI0.SMB.DACM)
                        Sleep (0x0A)
                        Store (\_SB.PCI0.SMB.PTGM, Local1)
                        Sleep (0x0A)
                        If (\_SB.GPOB)
                        {
                            Or (Local1, 0x08, Local1)
                            Store (Local1, \_SB.PCI0.SMB.PTGM)
                        }
                        Else
                        {
                            And (Local1, 0xF7, Local1)
                            Store (Local1, \_SB.PCI0.SMB.PTGM)
                        }

                        Sleep (0x0A)
                        Store (0x05, \_SB.WMID.Z00B)
                        Store (0x00, \_SB.WMID.Z00C)
                        Notify (\_SB.WMID, 0x80)
                    }

                    Method (_Q20, 0, NotSerialized)
                    {
                        If (And (SMST, 0x40))
                        {
                            Store (SMAA, Local0)
                            If (LEqual (Local0, 0x14))
                            {
                                SELE ()
                                If (And (0x40, BATF))
                                {
                                    Notify (\_SB.PCI0.LPC0.BAT1, 0x81)
                                }

                                If (And (0x02, BATF))
                                {
                                    Notify (\_SB.PCI0.LPC0.ACAD, 0x00)
                                }

                                Notify (\_SB.PCI0.LPC0.BAT1, 0x80)
                                Store (BATD, BATO)
                                BPOL (0x14)
                                And (SMST, 0xBF, SMST)
                            }
                        }
                    }

                    Method (SELE, 0, NotSerialized)
                    {
                        Store (BATD, BATN)
                        Store (0x00, BATF)
                        If (And (0xC0, BATN))
                        {
                            Or (BATF, 0x01, BATF)
                        }

                        If (And (0x0300, BATN))
                        {
                            Or (BATF, 0x04, BATF)
                        }

                        And (BATN, 0x01, Local0)
                        And (BATO, 0x01, Local1)
                        If (Local0)
                        {
                            Or (BATF, 0x0100, BATF)
                        }
                        Else
                        {
                            And (BATF, 0xFEFF, BATF)
                        }

                        If (Not (LEqual (Local0, Local1)))
                        {
                            Or (BATF, 0x40, BATF)
                        }

                        And (BATN, 0x02, Local0)
                        And (BATO, 0x02, Local1)
                        If (Local0)
                        {
                            Or (BATF, 0x0200, BATF)
                        }
                        Else
                        {
                            And (BATF, 0xFDFF, BATF)
                        }

                        If (Not (LEqual (Local0, Local1)))
                        {
                            Or (BATF, 0x80, BATF)
                        }

                        And (BATN, 0xC0, Local0)
                        And (BATO, 0xC0, Local1)
                        If (Not (LEqual (Local0, Local1)))
                        {
                            Or (BATF, 0x02, BATF)
                        }

                        If (And (0x01, BATF))
                        {
                            If (And (0x04, BATF))
                            {
                                Or (BATF, 0x10, BATF)
                            }
                        }
                    }

                    Method (_Q80, 0, NotSerialized)
                    {
                        Store ("_Q80 : Temperature Up", Debug)
                        Notify (\_TZ.THRM, 0x80)
                    }

                    Method (_Q81, 0, NotSerialized)
                    {
                        Store ("_Q81 : Temperature Down", Debug)
                        Notify (\_TZ.THRM, 0x80)
                    }

                    Method (_Q8A, 0, NotSerialized)
                    {
                        If (LIDE)
                        {
                            Store ("_Q8A : LID Switch Event", Debug)
                            Store (0x01, LIDE)
                            Notify (\_SB.LID, 0x80)
                            Sleep (0x0FA0)
                        }
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        SMW0,   16
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        SMB0,   8
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD0,   64
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD1,   128
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD2,   192
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD3,   256
                    }

                    Mutex (MUT0, 0x00)
                    Method (SMRD, 4, NotSerialized)
                    {
                        If (LNot (ECON))
                        {
                            Return (0xFF)
                        }

                        If (LNot (LEqual (Arg0, 0x07)))
                        {
                            If (LNot (LEqual (Arg0, 0x09)))
                            {
                                If (LNot (LEqual (Arg0, 0x0B)))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        Acquire (MUT0, 0xFFFF)
                        Store (0x04, Local0)
                        While (LGreater (Local0, 0x01))
                        {
                            And (SMST, 0x40, SMST)
                            Store (Arg2, SMCM)
                            Store (Arg1, SMAD)
                            Store (Arg0, SMPR)
                            Store (0x00, Local3)
                            While (LNot (And (SMST, 0xBF, Local1)))
                            {
                                Sleep (0x02)
                                Increment (Local3)
                                If (LEqual (Local3, 0x32))
                                {
                                    And (SMST, 0x40, SMST)
                                    Store (Arg2, SMCM)
                                    Store (Arg1, SMAD)
                                    Store (Arg0, SMPR)
                                    Store (0x00, Local3)
                                }
                            }

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

                        If (Local0)
                        {
                            Store (And (Local1, 0x1F), Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x07))
                            {
                                Store (SMB0, Arg3)
                            }

                            If (LEqual (Arg0, 0x09))
                            {
                                Store (SMW0, Arg3)
                            }

                            If (LEqual (Arg0, 0x0B))
                            {
                                Store (BCNT, Local3)
                                ShiftRight (0x0100, 0x03, Local2)
                                If (LGreater (Local3, Local2))
                                {
                                    Store (Local2, Local3)
                                }

                                If (LLess (Local3, 0x09))
                                {
                                    Store (FLD0, Local2)
                                }
                                Else
                                {
                                    If (LLess (Local3, 0x11))
                                    {
                                        Store (FLD1, Local2)
                                    }
                                    Else
                                    {
                                        If (LLess (Local3, 0x19))
                                        {
                                            Store (FLD2, Local2)
                                        }
                                        Else
                                        {
                                            Store (FLD3, Local2)
                                        }
                                    }
                                }

                                Increment (Local3)
                                Store (Buffer (Local3) {}, Local4)
                                Decrement (Local3)
                                Store (Zero, Local5)
                                While (LGreater (Local3, Local5))
                                {
                                    GBFE (Local2, Local5, RefOf (Local6))
                                    PBFE (Local4, Local5, Local6)
                                    Increment (Local5)
                                }

                                PBFE (Local4, Local5, 0x00)
                                Store (Local4, Arg3)
                            }
                        }

                        Release (MUT0)
                        Return (Local0)
                    }

                    Method (SMWR, 4, NotSerialized)
                    {
                        If (LNot (ECON))
                        {
                            Return (0xFF)
                        }

                        If (LNot (LEqual (Arg0, 0x06)))
                        {
                            If (LNot (LEqual (Arg0, 0x08)))
                            {
                                If (LNot (LEqual (Arg0, 0x0A)))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        Acquire (MUT0, 0xFFFF)
                        Store (0x04, Local0)
                        While (LGreater (Local0, 0x01))
                        {
                            If (LEqual (Arg0, 0x06))
                            {
                                Store (Arg3, SMB0)
                            }

                            If (LEqual (Arg0, 0x08))
                            {
                                Store (Arg3, SMW0)
                            }

                            If (LEqual (Arg0, 0x0A))
                            {
                                Store (Arg3, SMD0)
                            }

                            And (SMST, 0x40, SMST)
                            Store (Arg2, SMCM)
                            Store (Arg1, SMAD)
                            Store (Arg0, SMPR)
                            Store (0x00, Local3)
                            While (LNot (And (SMST, 0xBF, Local1)))
                            {
                                Sleep (0x02)
                                Increment (Local3)
                                If (LEqual (Local3, 0x32))
                                {
                                    And (SMST, 0x40, SMST)
                                    Store (Arg2, SMCM)
                                    Store (Arg1, SMAD)
                                    Store (Arg0, SMPR)
                                    Store (0x00, Local3)
                                }
                            }

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

                        If (Local0)
                        {
                            Store (And (Local1, 0x1F), Local0)
                        }

                        Release (MUT0)
                        Return (Local0)
                    }
                }

                Device (ACAD)
                {
                    Name (_HID, "ACPI0003")
                    Name (_PCL, Package (0x01)
                    {
                        \_SB
                    })
                    Name (ACWT, 0x00)
                    Method (_PSR, 0, NotSerialized)
                    {
                        Store (\_SB.ACST, ACWT)
                        If (ECON)
                        {
                            Store (\_SB.PCI0.LPC0.EC0.SW2S, \_SB.ACST)
                        }

                        If (LNot (LEqual (ACWT, \_SB.ACST)))
                        {
                            Store (0x80, \_SB.PCI0.LPC0.BCMD)
                            Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        }

                        Store (\_SB.PCI0.LPC0.EC0.BATP, DBGP)
                        If (LAnd (LEqual (\_SB.PCI0.LPC0.EC0.BATP,
0x34), LEqual (\_SB.POTL, 0x01)))
                        {
                            Store (0x00, \_PR.CPU0._PPC)
                            Notify (\_PR.CPU0, 0x80)
                        }
                        Else
                        {
                            If (LEqual (\_SB.ACST, 0x01))
                            {
                                Store (0x00, \_PR.CPU0._PPC)
                                Notify (\_PR.CPU0, 0x80)
                            }
                            Else
                            {
                                If (LEqual (\_SB.PWDC, 0x06))
                                {
                                    Store (0x02, \_PR.CPU0._PPC)
                                    Notify (\_PR.CPU0, 0x80)
                                }

                                If (LEqual (\_SB.PWDC, 0x05))
                                {
                                    Store (0x01, \_PR.CPU0._PPC)
                                    Notify (\_PR.CPU0, 0x80)
                                }
                            }
                        }

                        Return (\_SB.ACST)
                    }
                }

                Method (VTOB, 1, NotSerialized)
                {
                    Store (0x01, Local0)
                    ShiftLeft (Local0, Arg0, Local0)
                    Return (Local0)
                }

                Method (BTOV, 1, NotSerialized)
                {
                    ShiftRight (Arg0, 0x01, Local0)
                    Store (0x00, Local1)
                    While (Local0)
                    {
                        Increment (Local1)
                        ShiftRight (Local0, 0x01, Local0)
                    }

                    Return (Local1)
                }

                Method (MKWD, 2, NotSerialized)
                {
                    If (And (Arg1, 0x80))
                    {
                        Store (0xFFFF0000, Local0)
                    }
                    Else
                    {
                        Store (Zero, Local0)
                    }

                    Or (Local0, Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                    Return (Local0)
                }

                Method (POSW, 1, NotSerialized)
                {
                    If (And (Arg0, 0x8000))
                    {
                        If (LEqual (Arg0, 0xFFFF))
                        {
                            Return (0xFFFFFFFF)
                        }
                        Else
                        {
                            Not (Arg0, Local0)
                            Increment (Local0)
                            And (Local0, 0xFFFF, Local0)
                            Return (Local0)
                        }
                    }
                    Else
                    {
                        Return (Arg0)
                    }
                }

                Method (GBFE, 3, NotSerialized)
                {
                    CreateByteField (Arg0, Arg1, TIDX)
                    Store (TIDX, Arg2)
                }

                Method (PBFE, 3, NotSerialized)
                {
                    CreateByteField (Arg0, Arg1, TIDX)
                    Store (Arg2, TIDX)
                }

                Method (ITOS, 1, NotSerialized)
                {
                    Store (Buffer (0x05)
                        {
                            0x20, 0x20, 0x20, 0x20, 0x20
                        }, Local0)
                    Store (Buffer (0x11)
                        {
                            "0123456789ABCDEF"
                        }, Local7)
                    Store (0x05, Local1)
                    Store (0x00, Local2)
                    Store (0x00, Local3)
                    While (Local1)
                    {
                        Decrement (Local1)
                        And (ShiftRight (Arg0, ShiftLeft (Local1,
0x02)), 0x0F, Local4)
                        GBFE (Local7, Local4, RefOf (Local5))
                        PBFE (Local0, Local2, Local5)
                        Increment (Local2)
                    }

                    Return (Local0)
                }

                Device (BAT1)
                {
                    Name (_HID, EisaId ("PNP0C0A"))
                    Name (_UID, 0x01)
                    Name (_PCL, Package (0x01)
                    {
                        \_SB
                    })
                    Name (PBIF, Package (0x0D)
                    {
                        0x01,
                        0xFFFFFFFF,
                        0xFFFFFFFF,
                        0x01,
                        0xFFFFFFFF,
                        0xFA,
                        0x96,
                        0x0A,
                        0x19,
                        "BAT1",
                        " ",
                        " ",
                        " "
                    })
                    Name (PBST, Package (0x04)
                    {
                        0x00,
                        0xFFFFFFFF,
                        0xFFFFFFFF,
                        0x2710
                    })
                    Name (BAST, 0x00)
                    Name (B1ST, 0x0F)
                    Name (B1WT, 0x00)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (ECON)
                        {
                            If (\_SB.PCI0.LPC0.EC0.MBTS)
                            {
                                Store (0x1F, B1ST)
                                Store (\_SB.PCI0.LPC0.EC0.BA1C, \_SB.CM26)
                            }
                            Else
                            {
                                Store (0x0F, B1ST)
                                Store (0xFF, \_SB.CM26)
                            }
                        }
                        Else
                        {
                            Store (0x0F, B1ST)
                        }

                        Return (B1ST)
                    }

                    Method (_BIF, 0, NotSerialized)
                    {
                        If (ECON)
                        {
                            If (\_SB.PCI0.LPC0.EC0.MBTS)
                            {
                                UPBI ()
                            }
                            Else
                            {
                                IVBI ()
                            }
                        }
                        Else
                        {
                            IVBI ()
                        }

                        Return (PBIF)
                    }

                    Method (_BST, 0, NotSerialized)
                    {
                        If (ECON)
                        {
                            If (\_SB.PCI0.LPC0.EC0.MBTS)
                            {
                                UPBS ()
                            }
                            Else
                            {
                                IVBS ()
                            }
                        }
                        Else
                        {
                            IVBS ()
                        }

                        Return (PBST)
                    }

                    Method (UPBI, 0, NotSerialized)
                    {
                        If (LNot (\_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16,
0x10, RefOf (Local5))))
                        {
                            If (LAnd (Local5, LNot (And (Local5, 0x8000))))
                            {
                                ShiftRight (Local5, 0x05, Local5)
                                ShiftLeft (Local5, 0x05, Local5)
                                Store (Local5, Index (PBIF, 0x02))
                                Divide (Local5, 0x64, , Local2)
                                Add (Local2, 0x01, Local2)
                                Multiply (Local2, 0x05, Local4)
                                Add (Local4, 0x02, Index (PBIF, 0x05))
                                Multiply (Local2, 0x03, Local4)
                                Add (Local4, 0x02, Index (PBIF, 0x06))
                            }
                        }

                        If (\_SB.PCI0.LPC0.EC0.MBNH)
                        {
                            Store (0x2328, Index (PBIF, 0x01))
                            Store (0x1C20, Index (PBIF, 0x04))
                            Store ("OANI$", Index (PBIF, 0x09))
                            Store ("NiMH", Index (PBIF, 0x0B))
                        }
                        Else
                        {
                            Store (0x1770, Index (PBIF, 0x01))
                            Store (0x39D0, Index (PBIF, 0x04))
                            Sleep (0x32)
                            If (LEqual (\_SB.PCI0.LPC0.EC0.BATP, 0x34))
                            {
                                Store ("JM-12", Index (PBIF, 0x09))
                            }
                            Else
                            {
                                If (LEqual (\_SB.PCI0.LPC0.EC0.BATP, 0x32))
                                {
                                    Store ("JM-6", Index (PBIF, 0x09))
                                }
                                Else
                                {
                                    Store ("JM-6", Index (PBIF, 0x09))
                                }
                            }

                            Store ("LION", Index (PBIF, 0x0B))
                        }

                        UPUM ()
                        Store (0x01, Index (PBIF, 0x00))
                    }

                    Method (UPUM, 0, NotSerialized)
                    {
                        Store (Buffer (0x0A)
                            {
                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                0x00, 0x00
                            }, Local0)
                        Store (Buffer (0x05)
                            {
                                0x36, 0x35, 0x35, 0x33, 0x35
                            }, Local6)
                        Store (Buffer (0x05)
                            {
                                0x31, 0x32, 0x33, 0x32, 0x31
                            }, Local7)
                        If (LNot (\_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16,
0x1B, RefOf (Local5))))
                        {
                            Store (ITOS (ToBCD (Local5)), Local7)
                        }

                        If (LNot (\_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16,
0x1C, RefOf (Local5))))
                        {
                            Store (ITOS (ToBCD (Local5)), Local6)
                        }

                        Store (0x05, Local1)
                        Store (0x00, Local2)
                        Store (0x00, Local3)
                        While (Local1)
                        {
                            Decrement (Local1)
                            GBFE (Local6, Local2, RefOf (Local5))
                            PBFE (Local0, Local3, Local5)
                            Increment (Local2)
                            Increment (Local3)
                        }

                        Store (0x00, Local2)
                        Store (0x05, Local1)
                        While (Local1)
                        {
                            Decrement (Local1)
                            GBFE (Local7, Local2, RefOf (Local5))
                            PBFE (Local0, Local3, Local5)
                            Increment (Local2)
                            Increment (Local3)
                        }

                        Store (Local0, Index (PBIF, 0x0A))
                        Store ("Hewlett-Packard", Index (PBIF, 0x0C))
                    }

                    Method (UPBS, 0, NotSerialized)
                    {
                        Store (0xFFFFFFFF, Index (PBST, 0x01))
                        Store (\_SB.PCI0.LPC0.EC0.MBRM, Local5)
                        If (LNot (And (Local5, 0x8000)))
                        {
                            ShiftRight (Local5, 0x05, Local5)
                            ShiftLeft (Local5, 0x05, Local5)
                            If (LNot (LEqual (Local5, DerefOf (Index
(PBST, 0x02)))))
                            {
                                Store (Local5, Index (PBST, 0x02))
                            }
                        }

                        Store (0xFFFFFFFF, Index (PBST, 0x03))
                        Store (\_SB.PCI0.LPC0.EC0.MBST, Index (PBST, 0x00))
                        Store (\_SB.PCI0.LPC0.EC0.BA1C, \_SB.CM26)
                    }

                    Method (IVBI, 0, NotSerialized)
                    {
                        Store (0xFFFFFFFF, Index (PBIF, 0x01))
                        Store (0xFFFFFFFF, Index (PBIF, 0x02))
                        Store (0xFFFFFFFF, Index (PBIF, 0x04))
                        Store ("Bad", Index (PBIF, 0x09))
                        Store ("      ", Index (PBIF, 0x0A))
                        Store ("Bad", Index (PBIF, 0x0B))
                        Store ("Bad", Index (PBIF, 0x0C))
                    }

                    Method (IVBS, 0, NotSerialized)
                    {
                        Store (0x00, Index (PBST, 0x00))
                        Store (0xFFFFFFFF, Index (PBST, 0x01))
                        Store (0xFFFFFFFF, Index (PBST, 0x02))
                        Store (0x2710, Index (PBST, 0x03))
                        Store (0xFF, \_SB.CM26)
                    }
                }
            }

            Device (P2P)
            {
                Name (_ADR, 0x00140004)
                Name (_PRW, Package (0x02)
                {
                    0x04,
                    0x04
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (GPIC)
                    {
                        Return (Package (0x05)
                        {
                            Package (0x04)
                            {
                                0x0002FFFF,
                                0x00,
                                0x00,
                                0x14
                            },

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

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

                            Package (0x04)
                            {
                                0x0009FFFF,
                                0x02,
                                0x00,
                                0x16
                            },

                            Package (0x04)
                            {
                                0xFFFF,
                                0x00,
                                0x00,
                                0x12
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x05)
                        {
                            Package (0x04)
                            {
                                0x0002FFFF,
                                0x00,
                                \_SB.PCI0.LPC0.LNKE,
                                0x00
                            },

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

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

                            Package (0x04)
                            {
                                0x0009FFFF,
                                0x02,
                                \_SB.PCI0.LPC0.LNKG,
                                0x00
                            },

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

            Device (AUDO)
            {
                Name (_ADR, 0x00140005)
                Name (_PRW, Package (0x02)
                {
                    0x0C,
                    0x03
                })
            }

            Device (MODM)
            {
                Name (_ADR, 0x00140006)
            }

            Device (AGP)
            {
                Name (_ADR, 0x00010000)
                Method (_PRT, 0, NotSerialized)
                {
                    If (GPIC)
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0x0005FFFF,
                                0x00,
                                0x00,
                                0x11
                            },

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

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

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

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

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

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

                Device (VGA)
                {
                    Name (_ADR, 0x00050000)
                    Name (DABL, 0x00)
                    Name (SWIT, 0x01)
                    Name (CRTA, 0x01)
                    Name (LCDA, 0x01)
                    Name (TVA, 0x00)
                    Name (TOGF, 0x00)
                    Name (_S3D, 0x03)
                    Method (_INI, 0, NotSerialized)
                    {
                        Acquire (\_SB.PCI0.LPC0.PSMX, 0xFFFF)
                        Store (0x83, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.INFO)
                        Store (Zero, \_SB.PCI0.LPC0.SMIC)
                        Release (\_SB.PCI0.LPC0.PSMX)
                        Store (\_SB.PCI0.LPC0.INF, Local0)
                        Store (Local0, DABL)
                        Store (Local0, Local1)
                        Store (Local0, Local2)
                        And (Local1, 0x01, CRTA)
                        And (Local1, 0x02, LCDA)
                        If (LGreater (Local0, 0x04))
                        {
                            And (Local0, 0x03, TOGF)
                        }
                        Else
                        {
                            Store (Local0, TOGF)
                        }
                    }

                    Method (_DOS, 1, NotSerialized)
                    {
                        Store ("VGA --_DOS Arg0", Debug)
                        Store (Arg0, SWIT)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Store ("VGA --_DOD", Debug)
                        Return (Package (0x03)
                        {
                            0x00010100,
                            0x00010110,
                            0x0200
                        })
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        Store ("VGA_PS0", Debug)
                    }

                    Method (_PS2, 0, NotSerialized)
                    {
                        Store ("VGA_PS2", Debug)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store ("VGA_PS3", Debug)
                    }

                    Device (CRT)
                    {
                        Name (_ADR, 0x0100)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store ("CRT --_DCS", Debug)
                            If (CRTA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Store ("CRT --_DGS", Debug)
                            Store (CRTA, Local0)
                            If (CRTA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("CRT --_DSS", Debug)
                            Store (Arg0, Debug)
                        }
                    }

                    Device (LCD)
                    {
                        Name (_ADR, 0x0110)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store ("LCD --_DCS", Debug)
                            If (LCDA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Store ("LCD --_DGS", Debug)
                            Store (LCDA, Local0)
                            If (LCDA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("LCD --_DSS", Debug)
                            Store (Arg0, Debug)
                        }
                    }

                    Device (TV)
                    {
                        Name (_ADR, 0x0200)
                        Method (_DCS, 0, NotSerialized)
                        {
                            Store ("TV --_DCS", Debug)
                            If (TVA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Store ("TV --_DGS", Debug)
                            Store (TVA, Local0)
                            If (TVA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("TV --_DSS", Debug)
                            Store (Arg0, Debug)
                        }
                    }
                }
            }
        }

        Device (WMID)
        {
            Name (Z00D, Package (0x07)
            {
                0x04,
                0x04,
                0x04,
                0x00,
                0x04,
                0x04,
                0x00
            })
            Mutex (WMUX, 0x00)
            Method (Z00E, 2, NotSerialized)
            {
                CreateDWordField (Arg1, 0x04, Z00F)
                CreateDWordField (Arg1, 0x08, Z00G)
                CreateDWordField (Arg1, 0x0C, Z00H)
                If (LEqual (Arg0, 0x01))
                {
                    Store (0x00, Local0)
                }

                If (LEqual (Arg0, 0x02))
                {
                    Store (0x04, Local0)
                }

                If (LEqual (Arg0, 0x03))
                {
                    Store (0x80, Local0)
                }

                If (LEqual (Arg0, 0x04))
                {
                    Store (0x0400, Local0)
                }

                If (LEqual (Arg0, 0x05))
                {
                    Store (0x1000, Local0)
                }

                Store (Buffer (Add (0x08, Local0)) {}, Local1)
                CreateDWordField (Local1, 0x00, Z00I)
                CreateDWordField (Local1, 0x04, Z00J)
                Store (0x4C494146, Z00I)
                Store (0x02, Z00J)
                Store (0x03, Z00J)
                If (LEqual (Z00F, 0x01))
                {
                    Store (0x04, Z00J)
                    If (LEqual (Z00G, 0x05))
                    {
                        Store (^Z00K (), Local2)
                        Store (0x00, Z00J)
                    }

                    If (LEqual (Z00G, 0x07))
                    {
                        If (Z00H)
                        {
                            Store (DerefOf (Index (Arg1, 0x10)), Local3)
                            Store (^Z00L (Local3), Local2)
                            Store (0x00, Z00J)
                        }
                        Else
                        {
                            Store (0x05, Z00J)
                        }
                    }

                    If (LEqual (Z00G, 0x01))
                    {
                        Store (^Z00M (), Local2)
                        Store (0x00, Z00J)
                    }
                }

                If (LEqual (Z00F, 0x02))
                {
                    Store (0x04, Z00J)
                    If (LAnd (LGreater (Z00G, 0x00), LNot (LGreater
(Z00G, 0x06))))
                    {
                        If (LLess (Z00H, DerefOf (Index (Z00D,
Subtract (Z00G, 0x01)))))
                        {
                            Store (0x05, Z00J)
                        }
                        Else
                        {
                            CreateDWordField (Arg1, 0x10, Z00N)
                            If (LEqual (Z00G, 0x05))
                            {
                                Store (^Z00O (Z00N), Local2)
                                Store (0x00, Z00J)
                            }

                            If (LEqual (Z00G, 0x01))
                            {
                                Store (^Z00P (Z00N), Local2)
                                Store (0x00, Z00J)
                            }
                        }
                    }
                }

                If (LEqual (Z00J, 0x00))
                {
                    Store (DerefOf (Index (Local2, 0x00)), Z00J)
                    If (LEqual (Z00J, 0x00))
                    {
                        If (LNot (LGreater (DerefOf (Index (Local2,
0x01)), Local0)))
                        {
                            Store (0x00, Local0)
                            While (LLess (Local0, DerefOf (Index
(Local2, 0x01))))
                            {
                                Store (DerefOf (Index (DerefOf (Index
(Local2, 0x02)), Local0)), Index (Local1, Add (Local0, 0x08)))
                                Increment (Local0)
                            }

                            Store (0x53534150, Z00I)
                        }
                        Else
                        {
                            Store (0x05, Z00J)
                        }
                    }
                }

                Return (Local1)
            }

            Name (_HID, "PNP0C14")
            Name (_UID, 0x00)
            Name (Z00B, 0x00)
            Name (Z00C, 0x00)
            Name (BUFF, Buffer (0x04)
            {
                0x00, 0x00, 0x00, 0x00
            })
            CreateByteField (BUFF, 0x00, OB0)
            CreateByteField (BUFF, 0x01, OB1)
            CreateByteField (BUFF, 0x02, OB2)
            CreateByteField (BUFF, 0x03, OB3)
            Name (_WDG, Buffer (0x50)
            {
                0x34, 0xF0, 0xB7, 0x5F, 0x63, 0x2C, 0xE9, 0x45,
                0xBE, 0x91, 0x3D, 0x44, 0xE2, 0xC7, 0x07, 0xE4,
                0x41, 0x44, 0x01, 0x02, 0x79, 0x42, 0xF2, 0x95,
                0x7B, 0x4D, 0x34, 0x43, 0x93, 0x87, 0xAC, 0xCD,
                0xC6, 0x7E, 0xF6, 0x1C, 0x80, 0x00, 0x01, 0x08,
                0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11,
                0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10,
                0x41, 0x45, 0x01, 0x00, 0xD4, 0x2B, 0x99, 0xD0,
                0x7C, 0xA4, 0xFE, 0x4E, 0xB0, 0x72, 0x32, 0x4A,
                0xEC, 0x92, 0x29, 0x6C, 0x42, 0x43, 0x01, 0x00
            })
            Method (WQBC, 1, NotSerialized)
            {
                Store (0x89, \_SB.PCI0.LPC0.BCMD)
                Store (Zero, \_SB.PCI0.LPC0.SMIC)
                Store (\_SB.PCI0.LPC0.INF, Local0)
                And (Local0, 0x07, Local0)
                If (LEqual (\_SB.LID._LID (), 0x00))
                {
                    And (Local0, 0x06, Local0)
                }

                Return (Local0)
            }

            Method (WSBC, 2, NotSerialized)
            {
                CreateByteField (Arg1, 0x00, ADA0)
                Store (ADA0, Local0)
                If (Ones)
                {
                    Store (0x8D, \_SB.PCI0.LPC0.BCMD)
                    Store (Zero, \_SB.PCI0.LPC0.SMIC)
                    Store (\_SB.PCI0.LPC0.INF, Local1)
                    And (Local1, 0x07, Local1)
                    If (LEqual (Local0, Local1))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Store (Local0, Local1)
                        If (LGreater (Local1, 0x06))
                        {
                            Store (One, Local1)
                        }

                        If (LEqual (Local1, 0x01))
                        {
                            Store ("LCD", Debug)
                            Store (0x01, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local1, 0x02))
                        {
                            Store ("CRT", Debug)
                            Store (0x00, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local1, 0x03))
                        {
                            Store ("Both", Debug)
                            Store (0x01, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local1, 0x04))
                        {
                            Store ("TV", Debug)
                            Store (0x00, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local0, 0x05))
                        {
                            Store (0x01, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x00, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        If (LEqual (Local0, 0x06))
                        {
                            Store (0x00, \_SB.PCI0.AGP.VGA.LCDA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.CRTA)
                            Store (0x01, \_SB.PCI0.AGP.VGA.TVA)
                        }

                        Notify (\_SB.PCI0.AGP.VGA, 0x80)
                        Return (0x00)
                    }
                }
                Else
                {
                    Return (0x01)
                }
            }

            Method (WMAD, 3, NotSerialized)
            {
                Return (Z00E (Arg1, Arg2))
            }

            Method (Z00K, 0, NotSerialized)
            {
                Store (0x13, \_SB.PCI0.SMB.INCM)
                Sleep (0x0A)
                Store (0x40, \_SB.PCI0.SMB.DACM)
                Sleep (0x0A)
                Store (0xF7, \_SB.PCI0.SMB.PTGM)
                Sleep (0x0A)
                Store (0x80, \_SB.PCI0.SMB.DACM)
                Sleep (0x0A)
                Store (\_SB.PCI0.SMB.PTGM, Local1)
                Sleep (0x0A)
                And (Local1, 0x08, Local1)
                If (LEqual (Local1, 0x08))
                {
                    Store (0x01, Local1)
                    Store (Local1, \_SB.GPOB)
                }
                Else
                {
                    Store (0x00, Local1)
                    Store (Local1, \_SB.GPOB)
                }

                Store (0x01, \_SB.WIRE)
                And (\_SB.BTWL, 0x03, Local0)
                Or (Local0, 0x20, OB0)
                Store (\_SB.WWLS, Local1)
                ShiftLeft (Local1, 0x01, Local1)
                Store (\_SB.BWLS, Local2)
                ShiftLeft (Local2, 0x01, Local2)
                Store (\_SB.BTLS, Local3)
                ShiftLeft (Local3, 0x03, Local3)
                Or (Local1, Local3, Local1)
                Or (Local2, Local3, Local2)
                If (\_SB.PCI0.SMB.GPOW)
                {
                    If (LNot (\_SB.WWLS))
                    {
                        Store (0x00, \_SB.PCI0.SMB.GPOW)
                    }

                    If (LNot (\_SB.BTLS))
                    {
                        Store (0x00, \_SB.PCI0.SMB.GPOW)
                    }
                }

                If (\_SB.GPOB)
                {
                    If (LNot (\_SB.BWLS))
                    {
                        Store (0x00, \_SB.GPOB)
                        Store (\_SB.PCI0.SMB.PTGM, Local4)
                        And (Local4, 0xF7, Local4)
                        Store (Local4, \_SB.PCI0.SMB.PTGM)
                    }

                    If (LNot (\_SB.BTLS))
                    {
                        Store (0x00, \_SB.GPOB)
                        Store (\_SB.PCI0.SMB.PTGM, Local4)
                        And (Local4, 0xF7, Local4)
                        Store (Local4, \_SB.PCI0.SMB.PTGM)
                    }
                }

                Or (\_SB.PCI0.SMB.GPOW, Local1, Local1)
                Or (\_SB.GPOB, Local2, Local2)
                Store (0x00, OB2)
                Store (0x00, OB1)
                If (\_SB.WLSU)
                {
                    Or (Local1, 0x04, Local1)
                }

                If (\_SB.BTSU)
                {
                    Or (Local2, 0x04, Local2)
                }

                If (\_SB.PCI0.SMB.GPOW)
                {
                    Or (Local1, 0x10, Local1)
                }
                Else
                {
                    And (Local1, 0xEF, Local1)
                }

                If (And (\_SB.BTWL, 0x01))
                {
                    Store (Local1, OB1)
                }

                If (And (\_SB.BTWL, 0x02))
                {
                    Store (Local2, OB2)
                }

                Store (0x00, OB3)
                Store (Package (0x03)
                    {
                        0x00,
                        0x04,
                        Buffer (0x04)
                        {
                            0x01, 0x02, 0x03, 0x04
                        }
                    }, Local0)
                Store (OB0, Index (DerefOf (Index (Local0, 0x02)), 0x00))
                Store (OB1, Index (DerefOf (Index (Local0, 0x02)), 0x01))
                Store (OB2, Index (DerefOf (Index (Local0, 0x02)), 0x02))
                Store (OB3, Index (DerefOf (Index (Local0, 0x02)), 0x03))
                Return (Local0)
            }

            Method (Z00O, 1, NotSerialized)
            {
                Store (0x13, \_SB.PCI0.SMB.INCM)
                Sleep (0x0A)
                Store (0x40, \_SB.PCI0.SMB.DACM)
                Sleep (0x0A)
                Store (0xF7, \_SB.PCI0.SMB.PTGM)
                Sleep (0x0A)
                Store (0x80, \_SB.PCI0.SMB.DACM)
                Sleep (0x0A)
                Store (\_SB.PCI0.SMB.PTGM, Local1)
                Sleep (0x0A)
                And (Local1, 0x08, Local1)
                If (LEqual (Local1, 0x08))
                {
                    Store (0x01, Local1)
                    Store (Local1, \_SB.GPOB)
                }
                Else
                {
                    Store (0x00, Local1)
                    Store (Local1, \_SB.GPOB)
                }

                If (And (\_SB.BTWL, 0x03))
                {
                    If (And (Arg0, 0x0800))
                    {
                        If (And (Arg0, 0x08))
                        {
                            Store (0x01, \_SB.WWLS)
                            Store (0x01, \_SB.BWLS)
                            If (\_SB.WLSU)
                            {
                                If (\_SB.BTLS)
                                {
                                    Store (0x01, \_SB.PCI0.SMB.GPOW)
                                }
                            }
                            Else
                            {
                                Store (0x00, \_SB.PCI0.SMB.GPOW)
                            }

                            If (\_SB.BTSU)
                            {
                                If (\_SB.BTLS)
                                {
                                    Store (0x01, \_SB.GPOB)
                                    Store (\_SB.PCI0.SMB.PTGM, Local4)
                                    Or (Local4, 0x08, Local4)
                                    Store (Local4, \_SB.PCI0.SMB.PTGM)
                                }
                            }
                            Else
                            {
                                Store (0x00, \_SB.GPOB)
                                Store (\_SB.PCI0.SMB.PTGM, Local4)
                                And (Local4, 0xF7, Local4)
                                Store (Local4, \_SB.PCI0.SMB.PTGM)
                            }
                        }
                        Else
                        {
                            Store (0x00, \_SB.WWLS)
                            Store (0x00, \_SB.PCI0.SMB.GPOW)
                            Store (0x00, \_SB.BWLS)
                            Store (0x00, \_SB.GPOB)
                            Store (\_SB.PCI0.SMB.PTGM, Local4)
                            And (Local4, 0xF7, Local4)
                            Store (Local4, \_SB.PCI0.SMB.PTGM)
                        }
                    }

                    If (And (Arg0, 0x0100))
                    {
                        If (And (Arg0, 0x01))
                        {
                            Store (0x01, \_SB.WWLS)
                            If (\_SB.WLSU)
                            {
                                If (\_SB.BTLS)
                                {
                                    Store (0x01, \_SB.PCI0.SMB.GPOW)
                                }
                            }
                            Else
                            {
                                Store (0x00, \_SB.PCI0.SMB.GPOW)
                            }
                        }
                        Else
                        {
                            Store (0x00, \_SB.WWLS)
                            Store (0x00, \_SB.PCI0.SMB.GPOW)
                        }
                    }

                    If (And (Arg0, 0x0200))
                    {
                        If (And (Arg0, 0x02))
                        {
                            Store (0x01, \_SB.BWLS)
                            If (\_SB.BTSU)
                            {
                                If (\_SB.BTLS)
                                {
                                    Store (0x01, \_SB.GPOB)
                                    Store (\_SB.PCI0.SMB.PTGM, Local4)
                                    Or (Local4, 0x08, Local4)
                                    Store (Local4, \_SB.PCI0.SMB.PTGM)
                                }
                            }
                            Else
                            {
                                Store (0x00, \_SB.GPOB)
                                Store (\_SB.PCI0.SMB.PTGM, Local4)
                                And (Local4, 0xF7, Local4)
                                Store (Local4, \_SB.PCI0.SMB.PTGM)
                            }
                        }
                        Else
                        {
                            Store (0x00, \_SB.BWLS)
                            Store (0x00, \_SB.GPOB)
                            Store (\_SB.PCI0.SMB.PTGM, Local4)
                            And (Local4, 0xF7, Local4)
                            Store (Local4, \_SB.PCI0.SMB.PTGM)
                        }
                    }

                    Return (Package (0x02)
                    {
                        0x00,
                        0x00
                    })
                }
                Else
                {
                    Return (Package (0x02)
                    {
                        0x0D,
                        0x00
                    })
                }
            }

            Method (Z00L, 1, NotSerialized)
            {
                Acquire (\_SB.PCI0.LPC0.EC0.MUT0, 0xFFFF)
                If (LNot (ECON))
                {
                    Store (Package (0x02)
                        {
                            0x0D,
                            0x00
                        }, Local0)
                    Sleep (0x96)
                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                    Return (Local0)
                }

                If (Arg0)
                {
                    Store (Package (0x02)
                        {
                            0x06,
                            0x00
                        }, Local0)
                    Sleep (0x96)
                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                    Return (Local0)
                }

                If (\_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x14, 0x01, RefOf (Local0)))
                {
                    Store (Package (0x02)
                        {
                            0x06,
                            0x00
                        }, Local0)
                    Sleep (0x96)
                    Release (\_SB.PCI0.LPC0.EC0.MUT0)
                    Return (Local0)
                }

                Store (Package (0x03)
                    {
                        0x00,
                        0x80,
                        Buffer (0x80) {}
                    }, Local0)
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x18, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x01))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x00))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x10, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x03))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x02))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x0F, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x05))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x04))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x0C, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x07))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x06))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x17, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x09))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x08))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x08, RefOf (Local1))
                Subtract (Local1, 0x0AAA, Local1)
                Divide (Local1, 0x0A, Local2, Local1)
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x0B))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x0A))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x09, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x0D))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x0C))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x0A, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x0F))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x0E))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x19, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x11))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x10))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x16, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x13))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x12))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x3F, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x15))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x14))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x3E, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x17))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x16))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x3D, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x19))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x18))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x3C, RefOf (Local1))
                Divide (Local1, 0x0100, Local2, Index (DerefOf (Index
(Local0, 0x02)), 0x1B))
                Store (Local2, Index (DerefOf (Index (Local0, 0x02)), 0x1A))
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x1C, RefOf (Local1))
                Store (ITOS (ToBCD (Local1)), Local3)
                Store (0x1C, Local2)
                Store (0x00, Local4)
                Store (SizeOf (Local3), Local1)
                While (Local1)
                {
                    GBFE (Local3, Local4, RefOf (Local5))
                    PBFE (DerefOf (Index (Local0, 0x02)), Local2, Local5)
                    Decrement (Local1)
                    Increment (Local2)
                    Increment (Local4)
                }

                Store (0x00, Index (DerefOf (Index (Local0, 0x02)), Local2))
                Store (0x2C, Local2)
                Store (0x00, Local4)
                Store (0x0F, Local1)
                Store (Buffer (0x10)
                    {
                        "Hewlett-Packard"
                    }, Local3)
                While (Local1)
                {
                    GBFE (Local3, Local4, RefOf (Local5))
                    PBFE (DerefOf (Index (Local0, 0x02)), Local2, Local5)
                    Decrement (Local1)
                    Increment (Local2)
                    Increment (Local4)
                }

                Store (0x00, Index (DerefOf (Index (Local0, 0x02)), Local2))
                Sleep (0x96)
                Release (\_SB.PCI0.LPC0.EC0.MUT0)
                Return (Local0)
            }

            Method (Z00M, 0, NotSerialized)
            {
                Store (WQBC (0x00), OB0)
                Store (0x00, OB1)
                Store (0x00, OB2)
                Store (0x00, OB3)
                Store (Package (0x03)
                    {
                        0x00,
                        0x04,
                        Buffer (0x04)
                        {
                            0x01, 0x02, 0x03, 0x04
                        }
                    }, Local0)
                Store (OB0, Index (DerefOf (Index (Local0, 0x02)), 0x00))
                Store (OB1, Index (DerefOf (Index (Local0, 0x02)), 0x01))
                Store (OB2, Index (DerefOf (Index (Local0, 0x02)), 0x02))
                Store (OB3, Index (DerefOf (Index (Local0, 0x02)), 0x03))
                Return (Local0)
            }

            Method (Z00P, 1, NotSerialized)
            {
                And (Arg0, 0x07, Local0)
                Store (Local0, Local1)
                If (And (Local0, 0x01))
                {
                    Store (0x01, \_SB.PCI0.AGP.VGA.LCDA)
                }
                Else
                {
                    Store (0x00, \_SB.PCI0.AGP.VGA.LCDA)
                }

                If (And (Local0, 0x02))
                {
                    Store (0x01, \_SB.PCI0.AGP.VGA.CRTA)
                }
                Else
                {
                    Store (0x00, \_SB.PCI0.AGP.VGA.CRTA)
                }

                If (And (Local0, 0x04))
                {
                    Store (0x01, \_SB.PCI0.AGP.VGA.TVA)
                }
                Else
                {
                    Store (0x00, \_SB.PCI0.AGP.VGA.TVA)
                }

                Notify (\_SB.PCI0.AGP.VGA, 0x80)
                Return (Package (0x02)
                {
                    0x00,
                    0x00
                })
            }

            Method (_WED, 1, NotSerialized)
            {
                Concatenate (Z00B, Z00C, Local0)
                Return (Local0)
            }

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

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

        Method (_L04, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.P2P, 0x02)
            Store (0xA1, DEBG)
            Notify (\_SB.SLPB, 0x02)
        }
    }

    Scope (\_PR.CPU0)
    {
        Name (_PCT, Package (0x02)
        {
            ResourceTemplate ()
            {
                Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
            },

            ResourceTemplate ()
            {
                Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
            }
        })
        Name (_PSS, Package (0x03)
        {
            Package (0x06)
            {
                0x00000708,
                0x000061A8,
                0x00000064,
                0x00000009,
                0xE0202A8A,
                0x0000028A
            },

            Package (0x06)
            {
                0x00000640,
                0x000050DC,
                0x00000064,
                0x00000009,
                0xE0202B08,
                0x00000308
            },

            Package (0x06)
            {
                0x00000320,
                0x00002198,
                0x00000064,
                0x00000009,
                0xE0202CC0,
                0x000004C0
            }
        })
        Name (_PPC, 0x00)
    }
}

=================================================

And I save before by name "ze2205au.asl"

I use the commond of "iasl ze2205au.asl" get below.

=================================================
Intel ACPI Component Architecture
ASL Optimizing Compiler / AML Disassembler version 20041119 [Nov  3 2005]
Copyright (C) 2000 - 2004 Intel Corporation
Supports ACPI Specification Revision 2.0c

FreeBSD.asl   337:     Method (_WAK, 1, NotSerialized)
Warning  2026 -                   ^ Reserved method must return a value (_WAK)

FreeBSD.asl  2242:                         Return (UPRS)
Error    1022 -                 Object does not exist ^  (UPRS)

FreeBSD.asl  2252:                         Store (UPRS, Local0)
Error    1022 -                Object does not exist ^  (UPRS)

FreeBSD.asl  4137:             Name (_WDG, Buffer (0x50)
Warning  2033 -   Unknown reserved name ^  (_WDG)

FreeBSD.asl  4698:             Method (_WED, 1, NotSerialized)
Warning  2033 -     Unknown reserved name ^  (_WED)

ASL Input:  FreeBSD.asl - 5054 lines, 180986 bytes, 2398 keywords
Compilation complete. 2 Errors, 3 Warnings, 0 Remarks, 820 Optimizations
=======================================================
I fix the first Warning by add "Return(Package(0x02){0x00,0x00}) at
the end of Method _WAK.

And I use the command "iasl ze2205.asl" again get below.

=======================================================

Intel ACPI Component Architecture
ASL Optimizing Compiler / AML Disassembler version 20041119 [Nov  3 2005]
Copyright (C) 2000 - 2004 Intel Corporation
Supports ACPI Specification Revision 2.0c

ze2205au.asl  2243:                         Return (UPRS)
Error    1022 -                  Object does not exist ^  (UPRS)

ze2205au.asl  2253:                         Store (UPRS, Local0)
Error    1022 -                 Object does not exist ^  (UPRS)

ze2205au.asl  4138:             Name (_WDG, Buffer (0x50)
Warning  2033 -    Unknown reserved name ^  (_WDG)

ze2205au.asl  4699:             Method (_WED, 1, NotSerialized)
Warning  2033 -      Unknown reserved name ^  (_WED)

ASL Input:  ze2205au.asl - 5055 lines, 181025 bytes, 2399 keywords
Compilation complete. 2 Errors, 2 Warnings, 0 Remarks, 822 Optimizations

=========================================================

And my problem is how can I fix the two Error? And the Warnings?

I search the way to fix this ACPI by Google.But it doesn't work.I
counldn't find out how to fix the errors.

I hope you can HELP me to fix this error.I do feel you will help
me,because you are kind,and prowerful.

Wait you.

Nirvana.


More information about the freebsd-acpi mailing list