From owner-acpi-jp@jp.freebsd.org  Fri Nov 23 01:23:05 2001
Received: (from daemon@localhost)
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) id BAA12175;
	Fri, 23 Nov 2001 01:23:05 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from router.hackerheaven.org (qn-213-73-194-201.quicknet.nl [213.73.194.201])
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) with ESMTP id BAA12170
	for <acpi-jp@jp.freebsd.org>; Fri, 23 Nov 2001 01:22:57 +0900 (JST)
	(envelope-from coolvibe@hackerheaven.dyndns.org)
Received: by router.hackerheaven.org (Postfix, from userid 1000)
	id B51EA1CAA; Thu, 22 Nov 2001 17:22:39 +0100 (CET)
Date: Thu, 22 Nov 2001 17:22:39 +0100
From: Emiel Kollof <coolvibe@hackerheaven.org>
To: acpi-jp@jp.freebsd.org
Message-ID: <20011122172239.A17101@laptop.hackerheaven.org>
Mime-Version: 1.0
Content-Type: multipart/mixed; boundary="4Ckj6UjgE2iN1+kY"
Content-Disposition: inline
User-Agent: Mutt/1.3.23i
X-Mailer: Mutt 1.3.23i (2001-10-09)
X-Editor: Vim http://www.vim.org/
X-Info: http://www.hackerheaven.org/
X-Info2: http://www.cmdline.org/
X-Info3: http://www.coolvibe.org/
Reply-To: acpi-jp@jp.freebsd.org
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+010328
X-Sequence: acpi-jp 1482
Subject: [acpi-jp 1482] Weird hang on boot with Compaq Presario 17XL380 (acpidump included)
Errors-To: owner-acpi-jp@jp.freebsd.org
Sender: owner-acpi-jp@jp.freebsd.org
X-Originator: coolvibe@hackerheaven.org


--4Ckj6UjgE2iN1+kY
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Hi gang,

I'm running CURRENT on my Compaq Presario 17XL380 and it hangs on the
acpi_cpu line when booting a freshly built kernel. I still got it to
boot by booting an old kernel and disabling ACPI.

Is there anything flaky with this laptop's ACPI implementation? I
attached what I got from acpidump on this e-mail. Any ideas that would
help me to get ACPI going?

Thanks a lot,
Emiel
-- 
"I went into a general store, and they wouldn't sell me anything
specific".
		-- Steven Wright

--4Ckj6UjgE2iN1+kY
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment; filename="cpqpre17xl380.asl"
Content-Transfer-Encoding: quoted-printable

/*
RSD PTR: Checksum=3D69, OEMID=3DPTLTD, RsdtAddress=3D0x07ffc12d
 */
/*
RSDT: Length=3D44, Revision=3D1, Checksum=3D29,
	OEMID=3DPTLTD, OEM Table ID=3D  RSDT, OEM Revision=3D0x6040000,
	Creator ID=3D LTP, Creator Revision=3D0x0
 */
/*
	Entries=3D{ 0x07ffc159, 0x07fffbd9 }
 */
/*
	DSDT=3D0x7ffc1cd
	INT_MODEL=3DPIC
	SCI_INT=3D9
	SMI_CMD=3D0xb2, ACPI_ENABLE=3D0xf0, ACPI_DISABLE=3D0xf1, S4BIOS_REQ=3D0xf2
	PM1a_EVT_BLK=3D0x1000-0x1003
	PM1a_CNT_BLK=3D0x1004-0x1005
	PM2_TMR_BLK=3D0x1008-0x100b
	PM2_GPE0_BLK=3D0x100c-0x100f
	P_LVL2_LAT=3D10ms, P_LVL3_LAT=3D20ms
	FLUSH_SIZE=3D0, FLUSH_STRIDE=3D0
	DUTY_OFFSET=3D1, DUTY_WIDTH=3D3
	DAY_ALRM=3D13, MON_ALRM=3D0, CENTURY=3D50
	Flags=3D{WBINVD,PWR_BUTTON,SLP_BUTTON}
 */
/*
DSDT: Length=3D14860, Revision=3D1, Checksum=3D121,
	OEMID=3DPTLTD, OEM Table ID=3D  DSDT, OEM Revision=3D0x6040000,
	Creator ID=3DMSFT, Creator Revision=3D0x100000b
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "PTLTD",		//OEMID
    "  DSDT",		//TABLE ID
    0x6040000		//OEM Revision
)

{
Mutex(MUT0, 0)
Name(PBIF, Package(0xd) {
    0x0,
    Ones,
    Ones,
    0x1,
    Ones,
    0x0320,
    0x0320,
    0x64,
    0x64,
    "BAT1",
    "123",
    "LION",
    "COMPAQ",
})
Name(CSST, 0x0)
Name(S1S4, 0x0)
Name(ECFL, Zero)
Name(MYOS, Zero)
Name(_S0_, Package(0x2) {
    0x5,
    0x5,
})
Name(_S1_, Package(0x2) {
    0x4,
    0x4,
})
Name(_S4_, Package(0x2) {
    0x0,
    0x0,
})
Name(_S5_, Package(0x2) {
    0x0,
    0x0,
})
Scope(_GPE) {
    Method(_L08) {
        Store("_GPE._L08 - USB", Debug)
        Notify(\_SB_.PCI0.USB_, 0x2)
    }
    Method(_L09) {
        Store("_GPE._L09 - GPI1#", Debug)
        Notify(\_SB_.PCI0, 0x2)
        Notify(\_SB_.PCI0, 0x0)
    }
    Method(_L0B) {
        If(LEqual(CSST, 0x0)) {
        }
        Else {
            If(LEqual(\_SB_.PCI0.H8__.CAUS, 0x46)) {
                Store("Lid Closed", Debug)
            }
            Else {
                If(LEqual(\_SB_.PCI0.H8__.CAUS, 0x47)) {
                    Store("Lid Open", Debug)
                    Notify(\_SB_.LID_, 0x2)
                }
                Else {
                    If(LEqual(\_SB_.PCI0.H8__.CAUS, 0x32)) {
                        Notify(\_SB_.CMB0, 0x80)
                    }
                    Else {
                        If(LEqual(\_SB_.PCI0.H8__.CAUS, 0x9)) {
                            Store("60 min s1 to s4", Debug)
                            Store(0x1, S1S4)
                        }
                        Notify(\_SB_.PWRB, 0x2)
                    }
                }
            }
        }
    }
}
Scope(_PR_) {
    Processor(CPU0, 0, 0x1010, 0x6) {
    }
}
OperationRegion(GPIO, SystemIO, 0x1030, 0xf)
Field(GPIO, ByteAcc, NoLock, Preserve) {
    GI00,	8,
    GI08,	8,
    GI16,	8,
    GI24,	8,
    GO00,	8,
    GO08,	8,
    GO16,	8,
    GO24,	8
}
Scope(_SB_) {
    OperationRegion(SMI1, SystemIO, 0x0000fe00, 0x2)
    Field(SMI1, AnyAcc, NoLock, Preserve) {
        SMIC,	8
    }
    OperationRegion(SMI0, SystemMemory, 0x07ffff2c, 0x90)
    Field(SMI0, AnyAcc, NoLock, Preserve) {
        BCMD,	8,
        DID_,	32,
        INF0,	8,
        INF1,	8,
        INF2,	8,
        INF3,	8
    }
    OperationRegion(NVSM, SystemMemory, 0x01000000, 0x01000000)
    Field(NVSM, AnyAcc, NoLock, Preserve) {
        Offset(0x40),
        P000,	56,
        P001,	56,
        P002,	56,
        P003,	56,
        P004,	56,
        P005,	56,
        P006,	56,
        P007,	56,
        P010,	56,
        P011,	56
    }
    Method(SSMI, 2, Serialized) {
        Acquire(MUT0, 0xffff)
        Store(Arg0, BCMD)
        Store(0x0, DID_)
        Store(Arg1, INF0)
        Store(Zero, INF1)
        Store(Zero, INF2)
        Store(Zero, INF3)
        Store(Zero, SMIC)
        Store(0xcc, BCMD)
        Release(MUT0)
        Return(INF0)
    }
    Device(AC__) {
        Name(_HID, "ACPI0003")
        Name(ACPW, Ones)
        Name(_PCL, Package(0x1) {
            \_SB_,
        })
        Name(_PRW, Package(0x2) {
            0xb,
            0x4,
        })
        Name(_STA, 0xf)
        Method(_PSR) {
            If(LEqual(\ECFL, Zero)) {
                Return(0x1)
            }
            Else {
                And(ShiftRight(\_SB_.PCI0.H8__.BATT, 0x1, ), 0x1, ACPW)
                Return(ACPW)
            }
        }
    }
    Device(CMB0) {
        Name(_HID, 0x0a0cd041)
        Name(_UID, 0x1)
        Name(BATP, Ones)
        Name(_PCL, Package(0x1) {
            \_SB_,
        })
        Name(TMPP, Package(0x3) {
            0x0,
            0x0,
            0x0,
        })
        Method(_BIF) {
            If(LEqual(\ECFL, Zero)) {
                Return(0xf)
            }
            Else {
                Store(0x0, Local0)
                Store(0x0, Local1)
                \_SB_.PCI0.H8__.SMRD(0x9, 0x16, 0x18, Index(PBIF, 0x1, ))
                \_SB_.PCI0.H8__.SMRD(0x9, 0x16, 0x10, Index(PBIF, 0x2, ))
                Store(0x1, Index(PBIF, 0x3, ))
                \_SB_.PCI0.H8__.SMRD(0x9, 0x16, 0x19, Index(PBIF, 0x4, ))
                \_SB_.PCI0.H8__.SMRD(0x9, 0x16, 0x1, Index(PBIF, 0x5, ))
                \_SB_.PCI0.H8__.SMRD(0x9, 0x16, 0x1, Index(PBIF, 0x6, ))
                \_SB_.PCI0.H8__.SMRD(0xb, 0x16, 0x21, Index(PBIF, 0x9, ))
                \_SB_.PCI0.H8__.SMRD(0x9, 0x16, 0x1c, Index(TMPP, 0x0, ))
                Store(DerefOf(Index(TMPP, 0x0, )), Local0)
                Store(ITOS(Local0), Index(PBIF, 0xa, ))
                \_SB_.PCI0.H8__.SMRD(0xb, 0x16, 0x22, Index(PBIF, 0xb, ))
                Return(PBIF)
            }
        }
        Method(_STA) {
            If(LEqual(\ECFL, Zero)) {
                Return(0xf)
            }
            Else {
                And(\_SB_.PCI0.H8__.BATT, 0x1, BATP)
                If(LEqual(BATP, Zero)) {
                    Return(0xf)
                }
                Else {
                    Return(0x1f)
                }
            }
        }
        Method(_BTP, 1) {
            If(LEqual(\ECFL, Zero)) {
                Return(0xf)
            }
            Else {
                Store("_SB.CMB0._BTP", Debug)
            }
        }
        Name(CRIT, 0x0)
        Method(_BST) {
            Name(BUFF, Package(0x4) {
            })
            If(LEqual(\ECFL, Zero)) {
                Return(0xf)
            }
            Else {
                Store(Zero, Local0)
                Acquire(MUT0, 0xffff)
                Store(\_SB_.PCI0.H8__.BATT, Local0)
                Store(And(ShiftRight(Local0, 0x3, ), 0x1, ), Local1)
                Or(And(ShiftRight(Local0, 0x1, ), 0x2, ), Local1, Local1)
                Or(And(ShiftRight(Local0, 0x3, ), 0x4, ), Local1, Local1)
                Store(Local1, Index(BUFF, 0x0, ))
                Store(ShiftLeft(\_SB_.PCI0.H8__.MAMP, 0x8, ), Local0)
                Store(Add(\_SB_.PCI0.H8__.MAM2, Local0, ), Local0)
                If(And(Local0, 0x8000, )) {
                }
                Else {
                    Not(Local0, Local0)
                    And(Increment(Local0), 0xffff, Local0)
                }
                Store(Local0, Index(BUFF, 0x1, ))
                Store(ShiftLeft(\_SB_.PCI0.H8__.MMAH, 0x8, ), Local0)
                Add(\_SB_.PCI0.H8__.MMA2, Local0, Index(BUFF, 0x2, ))
                If(LEqual(\_SB_.PCI0.H8__.ACPR, 0x0)) {
                    Store(DerefOf(Index(BUFF, 0x0, )), Local0)
                    ShiftRight(Local0, 0x2, Local0)
                    And(Local0, 0x1, Local0)
                    Store(DerefOf(Index(PBIF, 0x6, )), Local1)
                    Store(DerefOf(Index(BUFF, 0x2, )), Local2)
                    If(LAnd(LLess(CRIT, 0x6), LOr(LEqual(Local0, One), LNot=
(LLess(Local1, Local2))))) {
                        Notify(\_SB_.PWRB, 0x80)
                        Add(Local1, 0x10, Local0)
                        Store(Local0, Index(BUFF, 0x2, ))
                        Store(0x1, Index(BUFF, 0x0, ))
                        Increment(CRIT)
                    }
                }
                Else {
                    Store(0x0, CRIT)
                }
                Store(ShiftLeft(\_SB_.PCI0.H8__.MVLT, 0x8, ), Local0)
                Store(Add(\_SB_.PCI0.H8__.MVL2, Local0, ), Index(BUFF, 0x3,=
 ))
                Release(MUT0)
            }
            Return(BUFF)
        }
    }
    Device(LID_) {
        Name(_HID, 0x0d0cd041)
        Name(_STA, 0xb)
        Name(LPOL, 0x1)
        Name(_PRW, Package(0x2) {
            0xb,
            0x4,
        })
        Method(_LID) {
            Return(\_SB_.LID_.LPOL)
        }
    }
    Device(PWRB) {
        Name(_HID, 0x0c0cd041)
        Name(_STA, 0xf)
        Name(_PRW, Package(0x2) {
            0xb,
            0x5,
        })
    }
    Device(SLPB) {
        Name(_HID, 0x0e0cd041)
        Name(_STA, 0xf)
    }
    Device(PCI0) {
        Name(_BBN, 0x0)
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Name(_STA, 0xf)
        OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
        Field(REGS, DWordAcc, NoLock, Preserve) {
            Offset(0x19),
            PAM0,	8,
            PAM1,	8,
            PAM2,	8,
            PAM3,	8,
            PAM4,	8,
            PAM5,	8,
            PAM6,	8,
            DRB0,	8,
            DRB1,	8,
            DRB2,	8,
            DRB3,	8,
            DRB4,	8,
            DRB5,	8,
            DRB6,	8,
            DRB7,	8,
            ,	6,
            HEN_,	2,
            Offset(0x33),
            T_EN,	1,
            T_SZ,	2,
            Offset(0x3a),
            CRST,	1,
            AGPD,	1,
            ,	4,
            SCRE,	1
        }
        Name(_PRT, Package(0xc) {
            Package(0x4) {
                0x0007ffff,
                0x3,
                \_SB_.PCI0.EIO_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x2,
                \_SB_.PCI0.EIO_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x1,
                \_SB_.PCI0.EIO_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x0,
                \_SB_.PCI0.EIO_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x0,
                \_SB_.PCI0.EIO_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x0,
                \_SB_.PCI0.EIO_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x1,
                \_SB_.PCI0.EIO_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x2,
                \_SB_.PCI0.EIO_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x3,
                \_SB_.PCI0.EIO_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x0,
                \_SB_.PCI0.EIO_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x0,
                \_SB_.PCI0.EIO_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x0,
                \_SB_.PCI0.EIO_.LNKB,
                0x0,
            },
        })
        Name(_PRW, Package(0x2) {
            0x9,
            0x4,
        })
        Name(RSRC, Buffer(0x01d8) {0x88, 0xe, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0,=
 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x88, 0xd, 0x0, 0x1, 0xc, 0x=
3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x47, 0x1, 0x22, 0x0=
, 0x22, 0x0, 0x1, 0x1, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x88, 0xd=
, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, =
0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xf=
f, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x87, 0x18,=
 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0x3f, 0x=
c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0,=
 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xc, 0x0, 0xff, 0x7f, 0xc, 0x0, 0=
x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xc, 0x0, 0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0xc0, 0xc, 0x0, 0xff, 0xff, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0,=
 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0=
x0, 0x0, 0x0, 0xd, 0x0, 0xff, 0x3f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40=
, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x40, 0xd, 0x0, 0xff, 0x7f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x=
0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xd,=
 0x0, 0xff, 0xbf, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0=
x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0, 0xf=
f, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18=
, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0xff, 0x3f, 0=
xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0=
, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xe, 0x0, 0xff, 0x7f, 0xe, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x=
3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xe, 0x0, 0xff, 0xbf, 0xe, 0x0, 0x0, 0x0,=
 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0=
x0, 0x0, 0x0, 0x0, 0xc0, 0xe, 0x0, 0xff, 0xff, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x79, 0x0 })
        Method(_CRS, 0, Serialized) {
            Store(Zero, Local1)
            If(T_EN) {
                ShiftLeft(0x1, Add(T_SZ, 0x11, ), Local1)
            }
            CreateDWordField(RSRC, 0x01aa, BTMN)
            CreateDWordField(RSRC, 0x01ae, BTMX)
            CreateDWordField(RSRC, 0x01b6, BTLN)
            Multiply(DRB7, 0x00800000, Local0)
            If(T_EN) {
                Subtract(Local0, Local1, Local2)
                Store(Local2, BTMN)
                Subtract(Add(Local0, 0x10000000, ), BTMN, BTLN)
            }
            Else {
                Store(Local0, BTMN)
                Subtract(0xffe00000, Local0, BTLN)
                Subtract(Add(BTMN, BTLN, ), 0x1, BTMX)
            }
            CreateDWordField(RSRC, 0x01c5, ATMN)
            CreateDWordField(RSRC, 0x01c9, ATMX)
            CreateDWordField(RSRC, 0x01d1, ATLN)
            If(T_EN) {
                Add(Add(BTMN, BTLN, ), Local1, ATMN)
                Subtract(0xffe00000, ATMN, ATLN)
                Subtract(Add(ATMN, ATLN, ), 0x1, ATMX)
            }
            Else {
                Store(Zero, ATLN)
            }
            CreateBitField(RSRC, 0x0308, C0RW)
            CreateDWordField(RSRC, 0x66, C0MN)
            CreateDWordField(RSRC, 0x6a, C0MX)
            CreateDWordField(RSRC, 0x72, C0LN)
            Store(One, C0RW)
            If(LEqual(And(PAM1, 0x3, ), 0x1)) {
                Store(Zero, C0RW)
            }
            Store(Zero, C0LN)
            If(LNot(And(PAM1, 0x3, ))) {
                Store(0x4000, C0LN)
            }
            CreateBitField(RSRC, 0x03e0, C4RW)
            CreateDWordField(RSRC, 0x81, C4MN)
            CreateDWordField(RSRC, 0x85, C4MX)
            CreateDWordField(RSRC, 0x8d, C4LN)
            Store(One, C4RW)
            If(LEqual(And(PAM1, 0x30, ), 0x10)) {
                Store(Zero, C4RW)
            }
            Store(Zero, C4LN)
            If(LNot(And(PAM1, 0x30, ))) {
                Store(0x4000, C4LN)
            }
            CreateBitField(RSRC, 0x04b8, C8RW)
            CreateDWordField(RSRC, 0x9c, C8MN)
            CreateDWordField(RSRC, 0xa0, C8MX)
            CreateDWordField(RSRC, 0xa8, C8LN)
            Store(One, C8RW)
            If(LEqual(And(PAM2, 0x3, ), 0x1)) {
                Store(Zero, C8RW)
            }
            Store(Zero, C8LN)
            If(LNot(And(PAM2, 0x3, ))) {
                Store(0x4000, C8LN)
            }
            CreateBitField(RSRC, 0x0590, CCRW)
            CreateDWordField(RSRC, 0xb7, CCMN)
            CreateDWordField(RSRC, 0xbb, CCMX)
            CreateDWordField(RSRC, 0xc3, CCLN)
            Store(One, CCRW)
            If(LEqual(And(PAM2, 0x30, ), 0x10)) {
                Store(Zero, CCRW)
            }
            Store(Zero, CCLN)
            If(LNot(And(PAM2, 0x30, ))) {
                Store(0x4000, CCLN)
            }
            CreateBitField(RSRC, 0x0668, D0RW)
            CreateDWordField(RSRC, 0xd2, D0MN)
            CreateDWordField(RSRC, 0xd6, D0MX)
            CreateDWordField(RSRC, 0xde, D0LN)
            Store(One, D0RW)
            If(LEqual(And(PAM3, 0x3, ), 0x1)) {
                Store(Zero, D0RW)
            }
            Store(Zero, D0LN)
            If(LNot(And(PAM3, 0x3, ))) {
                Store(0x4000, D0LN)
            }
            CreateBitField(RSRC, 0x0740, D4RW)
            CreateDWordField(RSRC, 0xed, D4MN)
            CreateDWordField(RSRC, 0xf1, D4MX)
            CreateDWordField(RSRC, 0xf9, D4LN)
            Store(One, D4RW)
            If(LEqual(And(PAM3, 0x30, ), 0x10)) {
                Store(Zero, D4RW)
            }
            Store(Zero, D4LN)
            If(LNot(And(PAM3, 0x30, ))) {
                Store(0x4000, D4LN)
            }
            CreateBitField(RSRC, 0x0818, D8RW)
            CreateDWordField(RSRC, 0x0108, D8MN)
            CreateDWordField(RSRC, 0x010c, D8MX)
            CreateDWordField(RSRC, 0x0114, D8LN)
            Store(One, D8RW)
            If(LEqual(And(PAM4, 0x3, ), 0x1)) {
                Store(Zero, D8RW)
            }
            Store(Zero, D8LN)
            If(LNot(And(PAM4, 0x3, ))) {
                Store(0x4000, D8LN)
            }
            CreateBitField(RSRC, 0x09c8, E0RW)
            CreateDWordField(RSRC, 0x013e, E0MN)
            CreateDWordField(RSRC, 0x0142, E0MX)
            CreateDWordField(RSRC, 0x014a, E0LN)
            Store(One, E0RW)
            If(LEqual(And(PAM5, 0x3, ), 0x1)) {
                Store(Zero, E0RW)
            }
            Store(Zero, E0LN)
            If(LNot(And(PAM5, 0x3, ))) {
                Store(0x4000, E0LN)
            }
            CreateBitField(RSRC, 0x0aa0, E4RW)
            CreateDWordField(RSRC, 0x0159, E4MN)
            CreateDWordField(RSRC, 0x015d, E4MX)
            CreateDWordField(RSRC, 0x0165, E4LN)
            Store(One, E4RW)
            If(LEqual(And(PAM5, 0x30, ), 0x10)) {
                Store(Zero, E4RW)
            }
            Store(Zero, E4LN)
            If(LNot(And(PAM5, 0x30, ))) {
                Store(0x4000, E4LN)
            }
            CreateBitField(RSRC, 0x0b78, E8RW)
            CreateDWordField(RSRC, 0x0174, E8MN)
            CreateDWordField(RSRC, 0x0178, E8MX)
            CreateDWordField(RSRC, 0x0180, E8LN)
            Store(One, E8RW)
            If(LEqual(And(PAM6, 0x3, ), 0x1)) {
                Store(Zero, E8RW)
            }
            Store(Zero, E8LN)
            If(LNot(And(PAM6, 0x3, ))) {
                Store(0x4000, E8LN)
            }
            CreateBitField(RSRC, 0x0c50, ECRW)
            CreateDWordField(RSRC, 0x018f, ECMN)
            CreateDWordField(RSRC, 0x0193, ECMX)
            CreateDWordField(RSRC, 0x019b, ECLN)
            Store(One, ECRW)
            If(LEqual(And(PAM6, 0x30, ), 0x10)) {
                Store(Zero, ECRW)
            }
            Store(Zero, ECLN)
            If(LNot(And(PAM6, 0x30, ))) {
                Store(0x4000, ECLN)
            }
            Return(RSRC)
        }
        Method(_INI) {
            \_SB_.SSMI(0x84, 0x0)
            If(LEqual(SCMP(\_OS_, "Microsoft Windows NT"), Zero)) {
                Store(Ones, MYOS)
            }
            Else {
                Store(Ones, \ECFL)
            }
        }
        Device(PPB0) {
            Name(_ADR, 0x00010000)
            Name(_STA, 0xf)
            Name(_PRT, Package(0x1) {
                Package(0x4) {
                    0xffff,
                    0x0,
                    \_SB_.PCI0.EIO_.LNKB,
                    0x0,
                },
            })
        }
        Device(IDE_) {
            Name(_ADR, 0x00070001)
            Name(_STA, 0xf)
            Name(_IRC, 0x0)
            Name(_PSC, 0x0)
            OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
            Field(REGS, DWordAcc, NoLock, Preserve) {
                Z000,	16,
                Z001,	16
            }
            Method(_PS0) {
                Store(0x0, _PSC)
            }
            Method(_PS3) {
                Store(0x3, _PSC)
            }
            Device(PRIM) {
                Name(_ADR, 0x0)
            }
            Device(SECD) {
                Name(_ADR, 0x1)
                Name(_RMV, 0x0)
                Method(_STA) {
                    Store(Z002(), Local0)
                    And(Local0, 0x2, Local0)
                    If(LEqual(Zero, Local0)) {
                        Store(0x0, Z001)
                        Store(0x0, Local1)
                    }
                    Else {
                        Or(Z001, 0x8000, Z001)
                        Store(0xf, Local1)
                    }
                    Return(Local1)
                }
                Device(DVD_) {
                    Name(_ADR, 0x0)
                    Name(_RMV, 0x0)
                    Method(_STA) {
                        Store(Z002(), Local0)
                        And(Local0, 0x2, Local0)
                        If(LEqual(Zero, Local0)) {
                            Store(0x0, Z001)
                            Store(0x0, Local1)
                        }
                        Else {
                            Or(Z001, 0x8000, Z001)
                            Store(0xf, Local1)
                        }
                        Return(Local1)
                    }
                    Name(_PSC, 0x0)
                    Method(_PS0) {
                        Store(Zero, _PSC)
                    }
                    Method(_PS3) {
                        Store(0x3, _PSC)
                    }
                }
            }
        }
        Device(USB_) {
            Name(_ADR, 0x00070002)
            Name(_PRW, Package(0x2) {
                0x8,
                0x1,
            })
        }
        Device(PWR_) {
            Name(_ADR, 0x00070003)
            Name(_STA, 0xf)
            OperationRegion(GLBL, SystemIO, 0x1028, 0x4)
            Field(GLBL, DWordAcc, NoLock, Preserve) {
                Offset(0x3),
                ,	1,
                LPOL,	1
            }
            OperationRegion(GPIO, SystemIO, 0x1030, 0x8)
            Field(GPIO, ByteAcc, NoLock, Preserve) {
                GI00,	8,
                GI08,	8,
                GI16,	8,
                GI24,	8,
                GO00,	8,
                GO08,	8,
                GO16,	8,
                GO24,	8
            }
            Field(GPIO, ByteAcc, NoLock, Preserve) {
                Offset(0x7),
                ,	3,
                GP27,	1
            }
            OperationRegion(PCI_, PCI_Config, 0x50, 0x28)
            Field(PCI_, DWordAcc, NoLock, Preserve) {
                Offset(0x1),
                ,	4,
                FDCM,	1,
                ,	1,
                U1M_,	1,
                Offset(0x2),
                U2M_,	1,
                ,	1,
                LPTM,	1,
                Offset(0xc),
                MDIE,	1,
                MDIA,	2,
                SBE_,	1,
                GME_,	1,
                SBA_,	2,
                MSSE,	1,
                MSSA,	2,
                Offset(0xf),
                ,	1,
                AUDM,	1,
                ,	2,
                KBCM,	1,
                G12M,	1,
                G13M,	1,
                LPTE,	1,
                G09A,	16,
                G09L,	4,
                ,	1,
                G09M,	1,
                G09E,	1,
                Offset(0x13),
                ,	1,
                LPTA,	2,
                ,	1,
                FDCA,	1,
                FDCE,	1,
                KBCE,	1,
                GMM_,	1,
                G10A,	16,
                G10L,	4,
                ,	1,
                G10M,	1,
                G10E,	1,
                Offset(0x17),
                U1A_,	3,
                U1E_,	1,
                U2A_,	3,
                U2E_,	1,
                G12A,	16,
                G12L,	4,
                G12E,	1,
                Offset(0x20),
                G13A,	16,
                G13L,	4,
                G13E,	1
            }
            Name(LPT1, Package(0x3) {
                0x03bc,
                0x0378,
                0x0278,
            })
            Name(LPT2, Package(0x3) {
                0x03c0,
                0x0380,
                0x0280,
            })
            Name(UAP1, Package(0x8) {
                0x03f8,
                0x02f8,
                0x0220,
                0x0228,
                0x0238,
                0x02e8,
                0x0338,
                0x03e8,
            })
            Name(UAP2, Package(0x8) {
                0x0400,
                0x0300,
                0x0228,
                0x0230,
                0x0240,
                0x02f0,
                0x0340,
                0x03f0,
            })
            Method(ENAB, 2, Serialized) {
                Store("_SB.PCI0.PWR.ENAB", Debug)
                Store(Arg0, Debug)
                Store(Arg0, Local0)
                Store(SizeOf(LPT1), Local1)
                While(Local1) {
                    Decrement(Local1)
                    If(LNot(LLess(Local0, DerefOf(Index(LPT1, Local1, )))))=
 {
                        If(LNot(LGreater(Local0, DerefOf(Index(LPT2, Local1=
, ))))) {
                            Store("LPT Decode Enabled", Debug)
                            Store(Arg0, Debug)
                            Store(Local1, Debug)
                            Store(Local1, LPTA)
                            Store(One, LPTE)
                            Store(One, LPTM)
                            Return(Zero)
                        }
                    }
                }
                Store(SizeOf(UAP1), Local1)
                While(Local1) {
                    Decrement(Local1)
                    If(LNot(LLess(Local0, DerefOf(Index(UAP1, Local1, )))))=
 {
                        If(LNot(LGreater(Local0, DerefOf(Index(UAP2, Local1=
, ))))) {
                            If(LEqual(Arg0, 0x0)) {
                                Store("COMA Decode Enabled", Debug)
                                Store(Arg0, Debug)
                                Store(Local1, Debug)
                                Store(Local1, U1A_)
                                Store(One, U1E_)
                                Store(One, U1M_)
                            }
                            Else {
                                Store("COMB Decode Enabled", Debug)
                                Store(Arg0, Debug)
                                Store(Local1, Debug)
                                Store(Local1, U2A_)
                                Store(One, U2E_)
                                Store(One, U2M_)
                            }
                            Return(Zero)
                        }
                    }
                }
            }
        }
        Device(EIO_) {
            Name(_ADR, 0x00070000)
            Name(_STA, 0xf)
            OperationRegion(PIRX, PCI_Config, 0x60, 0x4)
            Field(PIRX, DWordAcc, NoLock, Preserve) {
                AccessAs(ByteAcc, 0),
                PIRA,	8,
                PIRB,	8,
                PIRC,	8,
                PIRD,	8
            }
            OperationRegion(GEN_, PCI_Config, 0xb0, 0x4)
            Field(GEN_, DWordAcc, NoLock, Preserve) {
                ISAS,	1,
                POSD,	1
            }
            Method(DECD, 4) {
                Noop
            }
            Device(LNKA) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x1)
                Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x6, 0x18, 0x79, 0x0 })
                Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                Method(_DIS) {
                    Store("LNKA_DIS", Debug)
                    Or(PIRA, 0x80, PIRA)
                }
                Method(_CRS, 0, Serialized) {
                    Store("LNKA_CRS", Debug)
                    CreateWordField(RSRC, 0x1, IRQ0)
                    Store(Zero, IRQ0)
                    If(LNot(And(PIRA, 0x80, ))) {
                        And(PIRA, 0xf, Local0)
                        ShiftLeft(0x1, Local0, IRQ0)
                    }
                    Store(RSRC, Debug)
                    Return(RSRC)
                }
                Method(_SRS, 1, Serialized) {
                    Store("LNKA_SRS", Debug)
                    Store(Arg0, Debug)
                    CreateWordField(Arg0, 0x1, IRQ0)
                    FindSetRightBit(IRQ0, Local0)
                    Decrement(Local0)
                    Or(Local0, And(PIRA, 0x70, ), PIRA)
                }
                Method(_STA) {
                    If(And(PIRA, 0x80, )) {
                        Store(0x9, Debug)
                        Return(0x9)
                    }
                    Store(0xb, Debug)
                    Return(0xb)
                }
            }
            Device(LNKB) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x2)
                Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x6, 0x18, 0x79, 0x0 })
                Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                Method(_DIS) {
                    Store("LNKA_DIS", Debug)
                    Or(PIRB, 0x80, PIRB)
                }
                Method(_CRS, 0, Serialized) {
                    Store("LNKB_CRS", Debug)
                    CreateWordField(RSRC, 0x1, IRQ0)
                    Store(Zero, IRQ0)
                    If(LNot(And(PIRB, 0x80, ))) {
                        And(PIRB, 0xf, Local0)
                        ShiftLeft(0x1, Local0, IRQ0)
                    }
                    Store(RSRC, Debug)
                    Return(RSRC)
                }
                Method(_SRS, 1, Serialized) {
                    Store("LNKB_SRS", Debug)
                    Store(Arg0, Debug)
                    CreateWordField(Arg0, 0x1, IRQ0)
                    FindSetRightBit(IRQ0, Local0)
                    Decrement(Local0)
                    Or(Local0, And(PIRB, 0x70, ), PIRB)
                }
                Method(_STA) {
                    If(And(PIRB, 0x80, )) {
                        Store(0x9, Debug)
                        Return(0x9)
                    }
                    Store(0xb, Debug)
                    Return(0xb)
                }
            }
            Device(LNKC) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x3)
                Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x6, 0x18, 0x79, 0x0 })
                Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                Method(_DIS) {
                    Noop
                    Store("LNKC_DIS", Debug)
                    Or(PIRC, 0x80, PIRC)
                }
                Method(_CRS, 0, Serialized) {
                    Store("LNKC_CRS", Debug)
                    CreateWordField(RSRC, 0x1, IRQ0)
                    Store(Zero, IRQ0)
                    If(LNot(And(PIRC, 0x80, ))) {
                        And(PIRC, 0xf, Local0)
                        ShiftLeft(0x1, Local0, IRQ0)
                    }
                    Store(RSRC, Debug)
                    Return(RSRC)
                }
                Method(_SRS, 1, Serialized) {
                    Store("LNKC_SRS", Debug)
                    Store(Arg0, Debug)
                    CreateWordField(Arg0, 0x1, IRQ0)
                    FindSetRightBit(IRQ0, Local0)
                    Decrement(Local0)
                    Or(Local0, And(PIRC, 0x70, ), PIRC)
                }
                Method(_STA) {
                    If(And(PIRC, 0x80, )) {
                        Store(0x9, Debug)
                        Return(0x9)
                    }
                    Store(0xb, Debug)
                    Return(0xb)
                }
            }
            Device(LNKD) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x4)
                Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x6, 0x18, 0x79, 0x0 })
                Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                Method(_DIS) {
                    Store("LNKD_DIS", Debug)
                    Or(PIRD, 0x80, PIRD)
                }
                Method(_CRS, 0, Serialized) {
                    Store("LNKD_CRS", Debug)
                    CreateWordField(RSRC, 0x1, IRQ0)
                    Store(Zero, IRQ0)
                    If(LNot(And(PIRD, 0x80, ))) {
                        And(PIRD, 0xf, Local0)
                        ShiftLeft(0x1, Local0, IRQ0)
                    }
                    Store(RSRC, Debug)
                    Return(RSRC)
                }
                Method(_SRS, 1, Serialized) {
                    Store("LNKD_SRS", Debug)
                    Store(Arg0, Debug)
                    CreateWordField(Arg0, 0x1, IRQ0)
                    FindSetRightBit(IRQ0, Local0)
                    Decrement(Local0)
                    Or(Local0, And(PIRD, 0x70, ), PIRD)
                }
                Method(_STA) {
                    If(And(PIRD, 0x80, )) {
                        Store(0x9, Debug)
                        Return(0x9)
                    }
                    Store(0xb, Debug)
                    Return(0xb)
                }
            }
            Device(MOTH) {
                Name(_HID, 0x050ad041)
                Name(_UID, 0x1)
                Name(_STA, 0xb)
                Device(MRSC) {
                    Name(_HID, 0x020cd041)
                    Name(_UID, 0x1)
                    Method(_CRS) {
                        Return(Buffer(0x36) {0x47, 0x1, 0xe0, 0x0, 0xe0, 0x=
0, 0x1, 0x2, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff, 0x0, 0x0, 0x8, 0x0,=
 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0x0, 0x10, 0x0, 0x10=
, 0x1, 0x40, 0x47, 0x1, 0x40, 0x10, 0x40, 0x10, 0x1, 0x10, 0x47, 0x1, 0xe0,=
 0x3, 0xe0, 0x3, 0x1, 0x2, 0x79, 0x0 })
                    }
                }
                Device(SMEM) {
                    Name(_HID, 0x010cd041)
                    Name(_UID, 0x1)
                    Method(_CRS) {
                        Return(Buffer(0x1a) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0,=
 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0=
, 0x0, 0x2, 0x0, 0x79, 0x0 })
                    }
                }
                Device(DMAC) {
                    Name(_HID, 0x0002d041)
                    Method(_CRS) {
                        Return(Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0,=
 0x1, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x1, 0xf, 0x47, 0x1, 0xc0, 0x0=
, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x1, 0x79, 0x0 })
                    }
                    Scope(\_SB_) {
                        Method(TWRI, 3) {
                            And(Arg0, Arg1, Local2)
                            Not(Arg0, Local3)
                            And(Local3, 0xff, Local3)
                            And(Arg2, Local3, Local1)
                            Or(Local1, Local2, Local2)
                            Return(Local2)
                        }
                        Method(SEAR, 3) {
                            Store(SizeOf(Arg0), Local0)
                            Name(OFFS, Buffer(0x1) {0x0 })
                            CreateByteField(OFFS, 0x0, OFST)
                            Store(Zero, OFST)
                            Store(Zero, Local7)
                            Store(Arg2, Local1)
                            Add(Local0, Local1, Local0)
                            While(LLess(Local1, Local0)) {
                                Store(BURD(Arg1, Local1, 0x1, 0x0, 0x1), Lo=
cal5)
                                If(LEqual(Local5, 0x47)) {
                                    Add(OFST, 0x6, Local6)
                                    Add(OFST, 0x2, Local2)
                                    Add(OFST, 0x4, Local4)
                                    Store(BURD(Arg0, Local6, 0x1, 0x0, 0x1)=
, Local6)
                                    Store(BURD(Arg0, Local2, 0x1, 0x0, 0x2)=
, Local3)
                                    Store(BURD(Arg0, Local4, 0x1, 0x0, 0x2)=
, Local4)
                                    Store(BURD(Arg1, Add(Local1, 0x2, ), 0x=
1, 0x0, 0x2), Local2)
                                    Store(Zero, Local7)
                                    While(LAnd(LLess(Local3, Local2), LLess=
(Local3, Local4))) {
                                        Add(Local3, Local6, Local3)
                                        Increment(Local7)
                                    }
                                    If(LNot(LEqual(Local3, Local2))) {
                                        Store(0xff, Local7)
                                    }
                                    Add(Local1, 0x8, Local1)
                                    Add(OFST, 0x8, OFST)
                                }
                                If(LEqual(Local5, 0x2a)) {
                                    Add(OFST, 0x1, Local2)
                                    Store(BURD(Arg0, Local2, 0x1, 0x0, 0x1)=
, Local6)
                                    Store(BURD(Arg1, Add(Local1, 0x1, ), 0x=
1, 0x0, 0x1), Local2)
                                    Store(FIIX(Local2, Local6), Local7)
                                    Add(Local1, 0x3, Local1)
                                    Add(OFST, 0x3, OFST)
                                }
                                If(LEqual(Local5, 0x22)) {
                                    Add(OFST, 0x1, Local2)
                                    Store(BURD(Arg0, Local2, 0x1, 0x0, 0x2)=
, Local6)
                                    Store(BURD(Arg1, Add(Local1, 0x1, ), 0x=
1, 0x0, 0x2), Local2)
                                    Store(FIIX(Local2, Local6), Local7)
                                    Add(Local1, 0x3, Local1)
                                    Add(OFST, 0x3, OFST)
                                }
                                If(LEqual(Local5, 0x85)) {
                                    Add(Local1, 0x18, Local1)
                                }
                                If(LEqual(Local7, 0xff)) {
                                    Store(Local0, Local1)
                                }
                            }
                            Return(Local7)
                        }
                        Method(FIIX, 2) {
                            Store(Arg0, Local2)
                            Store(Arg1, Local6)
                            Store(Zero, Local7)
                            Store(Local6, Local4)
                            FindSetRightBit(Local4, Local3)
                            Decrement(Local3)
                            ShiftLeft(0x1, Local3, Local4)
                            Store(MABI(Arg1), Local5)
                            While(LAnd(LNot(LEqual(Local2, Local4)), Local5=
)) {
                                Increment(Local7)
                                Store(Zero, Local4)
                                Store(GETI(Local6, Local7), Local3)
                                Decrement(Local3)
                                ShiftLeft(0x1, Local3, Local4)
                                Decrement(Local5)
                            }
                            If(LEqual(Local4, Local2)) {
                                If(Local7) {
                                    Decrement(Local7)
                                }
                            }
                            Else {
                                Store(0xff, Local7)
                            }
                            Return(Local7)
                        }
                        Method(MABI, 1) {
                            Store(Arg0, Local0)
                            Store(Zero, Local7)
                            Store(One, Local5)
                            While(LNot(LEqual(Local0, Zero))) {
                                FindSetRightBit(Local0, Local1)
                                ShiftRight(Local0, Local1, Local0)
                                Increment(Local7)
                            }
                            Return(Local7)
                        }
                        Method(GETI, 2) {
                            Store(Zero, Local3)
                            Store(Arg1, Local7)
                            While(Local7) {
                                FindSetRightBit(Arg0, Local1)
                                ShiftRight(Arg0, Local1, Arg0)
                                Add(Local3, Local1, Local3)
                                Decrement(Local7)
                            }
                            Return(Local3)
                        }
                        Method(MORE, 3) {
                            Store(SizeOf(Arg1), Local0)
                            Store(Arg2, Local1)
                            While(LLess(Local1, Local0)) {
                                Store(BURD(Arg1, Local1, 0x1, 0x0, 0x1), Lo=
cal5)
                                If(LEqual(Local5, 0x47)) {
                                    Add(Local1, 0x6, Local6)
                                    Add(Local1, 0x2, Local2)
                                    Add(Local1, 0x4, Local4)
                                    Store(BURD(Arg1, Local6, 0x1, 0x0, 0x1)=
, Local6)
                                    Multiply(Arg0, Local6, Local6)
                                    Store(BURD(Arg1, Local2, 0x1, 0x0, 0x2)=
, Local3)
                                    Add(Local3, Local6, Local3)
                                    BURD(Arg1, Local2, 0x2, Local3, 0x2)
                                    BURD(Arg1, Local4, 0x2, Local3, 0x2)
                                    Add(Local1, 0x8, Local1)
                                }
                                If(LEqual(Local5, 0x2a)) {
                                    Add(Local1, 0x1, Local2)
                                    Store(BURD(Arg1, Local2, 0x1, 0x0, 0x1)=
, Local6)
                                    Store(Arg0, Local7)
                                    Increment(Local7)
                                    Store(Zero, Local4)
                                    While(Local7) {
                                        FindSetRightBit(Local6, Local3)
                                        ShiftRight(Local6, Local3, Local6)
                                        Add(Local4, Local3, Local4)
                                        Decrement(Local7)
                                    }
                                    If(LNot(LEqual(Local4, Zero))) {
                                        Decrement(Local4)
                                        ShiftLeft(0x1, Local4, Local4)
                                        BURD(Arg1, Local2, 0x2, Local4, 0x1)
                                    }
                                    Add(Local1, 0x3, Local1)
                                }
                                If(LEqual(Local5, 0x22)) {
                                    Add(Local1, 0x1, Local2)
                                    Store(BURD(Arg1, Local2, 0x1, 0x0, 0x2)=
, Local6)
                                    Store(Arg0, Local7)
                                    Increment(Local7)
                                    Store(Zero, Local4)
                                    While(Local7) {
                                        FindSetRightBit(Local6, Local3)
                                        ShiftRight(Local6, Local3, Local6)
                                        Add(Local4, Local3, Local4)
                                        Decrement(Local7)
                                    }
                                    If(LNot(LEqual(Local4, Zero))) {
                                        Decrement(Local4)
                                        ShiftLeft(0x1, Local4, Local4)
                                        BURD(Arg1, Local2, 0x2, Local4, 0x2)
                                    }
                                    Add(Local1, 0x3, Local1)
                                }
                                If(LEqual(Local5, 0x85)) {
                                    Add(Local1, 0x18, Local1)
                                }
                            }
                        }
                        Method(BURD, 5) {
                            Store(Zero, Local1)
                            If(LEqual(Arg2, 0x2)) {
                                If(LEqual(Arg4, 0x1)) {
                                    CreateByteField(Arg0, Arg1, WRI_)
                                    Store(Arg3, WRI_)
                                }
                                If(LEqual(Arg4, 0x2)) {
                                    CreateWordField(Arg0, Arg1, WRIT)
                                    Store(Arg3, WRIT)
                                }
                            }
                            If(LEqual(Arg2, 0x1)) {
                                If(LEqual(Arg4, 0x1)) {
                                    CreateByteField(Arg0, Arg1, REA_)
                                    Store(REA_, Local1)
                                }
                                If(LEqual(Arg4, 0x2)) {
                                    CreateWordField(Arg0, Arg1, READ)
                                    Store(READ, Local1)
                                }
                            }
                            Return(Local1)
                        }
                        Method(FRTO, 5) {
                            CreateField(Arg0, Arg1, Arg4, SOUR)
                            CreateField(Arg2, Arg3, Arg4, DEST)
                            Store(SOUR, DEST)
                        }
                    }
                }
                Device(PIC_) {
                    Name(_HID, 0xd041)
                    Method(_CRS) {
                        Return(Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x=
0, 0x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x22, 0x4, 0x0, 0x7=
9, 0x0 })
                    }
                }
                Device(TIME) {
                    Name(_HID, 0x0001d041)
                    Method(_CRS) {
                        Return(Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0=
, 0x1, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
                    }
                }
                Device(RTC_) {
                    Name(_HID, 0x000bd041)
                    Method(_CRS) {
                        Return(Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0=
, 0x1, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
                    }
                }
                Device(KBC_) {
                    Name(_HID, 0x0303d041)
                    Method(_CRS) {
                        Return(Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x=
0, 0x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x22, 0x2, 0x0, 0x7=
9, 0x0 })
                    }
                    Name(_PRW, Package(0x2) {
                        0xb,
                        0x4,
                    })
                }
                Device(MOUE) {
                    Name(_HID, 0x130fd041)
                    Name(_CRS, Buffer(0x6) {0x23, 0x0, 0x10, 0x1, 0x79, 0x0=
 })
                }
                Device(FPU_) {
                    Name(_HID, 0x040cd041)
                    Method(_CRS) {
                        Return(Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0=
, 0x1, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
                    }
                }
                Device(SPKR) {
                    Name(_HID, 0x0008d041)
                    Method(_CRS) {
                        Return(Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0=
, 0x1, 0x1, 0x79, 0x0 })
                    }
                }
                Device(SIO_) {
                    Name(_HID, 0x050ad041)
                    Name(_UID, 0x2)
                    OperationRegion(SIO_, SystemIO, 0x2e, 0x2)
                    Field(SIO_, ByteAcc, NoLock, Preserve) {
                        IDX0,	8,
                        DAT0,	8
                    }
                    IndexField(IDX0, DAT0, ByteAcc, NoLock, Preserve) {
                        FER_,	8,
                        FAR_,	8,
                        PTR_,	8,
                        FCR_,	8,
                        PCR_,	8,
                        Offset(0x6),
                        PMC_,	8,
                        TUP_,	8,
                        SID_,	8,
                        ASC_,	8,
                        CS0L,	8,
                        CS0H,	8,
                        CS0C,	8,
                        CS1L,	8,
                        CS1H,	8,
                        Offset(0x10),
                        CS1C,	8,
                        Offset(0x12),
                        SCF0,	8,
                        Offset(0x18),
                        SCF1,	8,
                        Offset(0x1b),
                        PNP0,	8,
                        PNP1,	8,
                        Offset(0x40),
                        SCF2,	8,
                        PNP2,	8,
                        PBAL,	8,
                        PBAH,	8,
                        U1BL,	8,
                        U1BH,	8,
                        U2BL,	8,
                        U2BH,	8,
                        FBAL,	8,
                        FBAH,	8,
                        SBAL,	8,
                        SBAH,	8,
                        SIR1,	8,
                        SIR2,	8,
                        SIR3,	8,
                        PNP3,	8,
                        SCF3,	8,
                        CLK_,	8
                    }
                    Name(_STA, 0xb)
                    Name(_PSC, 0x0)
                    Name(SREG, Package(0x25) {
                        0x0,
                        0x1,
                        0x2,
                        0x3,
                        0x4,
                        0x6,
                        0x7,
                        0x8,
                        0x9,
                        0xa,
                        0xb,
                        0xc,
                        0xd,
                        0x10,
                        0x11,
                        0x12,
                        0x18,
                        0x1b,
                        0x1c,
                        0x40,
                        0x41,
                        0x42,
                        0x43,
                        0x44,
                        0x45,
                        0x46,
                        0x47,
                        0x48,
                        0x49,
                        0x4a,
                        0x4b,
                        0x4c,
                        0x4d,
                        0x4e,
                        0x4f,
                        0x50,
                        0x51,
                    })
                    Name(SAVE, Package(0x28) {
                    })
                    Method(READ, 2, Serialized) {
                        Store(Arg0, Debug)
                        Store(Arg0, IDX0)
                        Store(DAT0, Local2)
                        And(Local2, Arg1, Local2)
                        Return(Local2)
                    }
                    Method(WRIT, 3, Serialized) {
                        Store(Arg0, IDX0)
                        Or(And(DAT0, Arg1, ), Arg2, Local0)
                        Store(Arg0, IDX0)
                        Store(Local0, DAT0)
                    }
                    Method(_PS0) {
                        Store(0x0, _PSC)
                    }
                    Method(_PS3) {
                        Store(0x3, _PSC)
                    }
                    Device(COMA) {
                        Name(_HID, 0x0105d041)
                        Name(_UID, 0x1)
                        Name(MCD_, 0xd)
                        Name(_PSC, 0x0)
                        Name(_STA, 0xf)
                        Name(_PRW, Package(0x2) {
                            0xb,
                            0x4,
                        })
                        Method(_CRS, 0, Serialized) {
                            Name(RSRC, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x=
0, 0x0, 0x1, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                            CreateWordField(RSRC, 0x2, IO1A)
                            CreateWordField(RSRC, 0x4, IO2A)
                            CreateWordField(RSRC, 0x9, IRQA)
                            CreateByteField(RSRC, 0xc, CKSM)
                            Or(ShiftLeft(And(U1BH, 0xfc, ), 0x8, ), ShiftLe=
ft(And(U1BL, 0xfe, ), 0x2, ), IO1A)
                            Store(IO1A, IO2A)
                            Store(Zero, IRQA)
                            And(PNP1, 0xf, Local0)
                            If(Local0) {
                                ShiftLeft(0x1, Local0, IRQA)
                            }
                            Store(Zero, CKSM)
                            Return(RSRC)
                        }
                        Method(_DIS, 0, Serialized) {
                            Store(0xd, _STA)
                        }
                        Method(_PRS) {
                            Return(Buffer(0x63) {0x30, 0x47, 0x1, 0xf8, 0x3=
, 0xf8, 0x3, 0x1, 0x8, 0x22, 0x10, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0=
x2, 0x1, 0x8, 0x22, 0x8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0=
x8, 0x22, 0x10, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x22,=
 0x8, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x22, 0x8, 0x0,=
 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x22, 0x10, 0x0, 0x30, 0x=
47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x22, 0x8, 0x0, 0x30, 0x47, 0x1, 0=
xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x22, 0x10, 0x0, 0x38, 0x79, 0x0 })
                        }
                        Method(_SRS, 1, Serialized) {
                            CreateWordField(Arg0, 0x2, IO1A)
                            CreateWordField(Arg0, 0x9, IRQA)
                            And(FER_, 0xfd, FER_)
                            WRIT(0x44, 0x1, ShiftRight(IO1A, 0x2, ))
                            WRIT(0x45, 0x3, ShiftRight(IO1A, 0x8, ))
                            FindSetRightBit(IRQA, Local0)
                            If(Local0) {
                                Decrement(Local0)
                                WRIT(0x1c, 0xf0, Local0)
                            }
                            Else {
                                WRIT(0x1c, 0xf0, 0x0)
                            }
                            Or(FER_, 0x2, FER_)
                            \_SB_.PCI0.PWR_.ENAB(IO1A, 0x0)
                            Store(0xf, _STA)
                        }
                        Method(_PS0, 0, Serialized) {
                            Or(FER_, 0x2, FER_)
                            Store(0x0, _PSC)
                        }
                        Method(_PS3, 0, Serialized) {
                            Store(0x3, _PSC)
                        }
                    }
                    Device(LPT_) {
                        Name(_HID, 0x0004d041)
                        Name(_UID, 0x1)
                        Name(_PSC, 0x0)
                        Name(_STA, 0x0)
                        Name(MCD_, 0xe)
                        Method(B_PR) {
                            Return(Buffer(0x4b) {0x30, 0x47, 0x1, 0x78, 0x3=
, 0x78, 0x3, 0x1, 0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0=
x3, 0x1, 0x8, 0x22, 0x20, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, =
0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x22=
, 0x20, 0x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x3, 0x22, 0x80, 0=
x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x3, 0x22, 0x20, 0x0, 0x38,=
 0x79, 0x0 })
                        }
                        Method(B_DI, 0, Serialized) {
                            Store(0xd, _STA)
                        }
                        Name(_PRW, Package(0x2) {
                            0xb,
                            0x4,
                        })
                        Method(_CRS, 0, Serialized) {
                            Name(BASE, 0x0)
                            Or(ShiftLeft(And(PBAH, 0xfc, ), 0x8, ), ShiftLe=
ft(PBAL, 0x2, ), BASE)
                            ShiftRight(READ(0x1b, 0xf0), 0x4, Local0)
                            Name(RSCB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x=
0, 0x0, 0x1, 0x8, 0x22, 0x1, 0x0, 0x79, 0x0 })
                            CreateWordField(RSCB, 0x2, IO1B)
                            CreateWordField(RSCB, 0x4, IO2B)
                            CreateByteField(RSCB, 0x7, IO3B)
                            CreateWordField(RSCB, 0x9, IRQB)
                            CreateByteField(RSCB, 0xc, CHKB)
                            Store(BASE, IO1B)
                            Store(BASE, IO2B)
                            If(LEqual(BASE, 0x03bc)) {
                                Store(0x3, IO3B)
                            }
                            If(Local0) {
                                ShiftLeft(0x1, Local0, IRQB)
                            }
                            Store(Zero, CHKB)
                            Return(RSCB)
                        }
                        Method(B_SR, 1, Serialized) {
                            Name(XRFI, Package(0x10) {
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x7,
                                0x0,
                                0x1,
                                0x0,
                                0x2,
                                0x3,
                                0x4,
                                0x0,
                                0x0,
                                0x5,
                                0x6,
                            })
                            CreateWordField(Arg0, 0x2, IO1A)
                            CreateWordField(Arg0, 0x9, IRQA)
                            WRIT(0x42, 0x0, ShiftRight(IO1A, 0x2, ))
                            WRIT(0x43, 0x3, ShiftRight(IO1A, 0x8, ))
                            FindSetRightBit(IRQA, Local0)
                            If(Local0) {
                                Decrement(Local0)
                                WRIT(0x1b, 0xf, ShiftLeft(Local0, 0x4, ))
                                WRIT(0x1b, 0xf8, DerefOf(Index(XRFI, Local0=
, )))
                            }
                            Else {
                                WRIT(0x1b, 0x8, 0x0)
                            }
                            Or(FER_, 0x1, FER_)
                            \_SB_.PCI0.PWR_.ENAB(IO1A, 0x0)
                            Store(0xf, _STA)
                        }
                        Method(_PS0, 0, Serialized) {
                            Or(FER_, 0x1, FER_)
                            Store(0x0, _PSC)
                        }
                        Method(_PS3, 0, Serialized) {
                            Store(0x3, _PSC)
                        }
                    }
                    Device(LPTB) {
                        Name(_HID, 0x0004d041)
                        Name(_UID, 0x2)
                        Name(_PSC, 0x0)
                        Name(_STA, 0xf)
                        Name(MCD_, 0xf)
                        Method(_PRS) {
                            Return(Buffer(0x4b) {0x30, 0x47, 0x1, 0x78, 0x3=
, 0x78, 0x3, 0x1, 0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0=
x3, 0x1, 0x8, 0x22, 0x20, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, =
0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x22=
, 0x20, 0x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x3, 0x22, 0x80, 0=
x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x3, 0x22, 0x20, 0x0, 0x38,=
 0x79, 0x0 })
                        }
                        Method(_DIS, 0, Serialized) {
                            Store(0xd, _STA)
                        }
                        Name(_PRW, Package(0x2) {
                            0xb,
                            0x4,
                        })
                        Method(_CRS, 0, Serialized) {
                            Name(BASE, 0x0)
                            Or(ShiftLeft(And(PBAH, 0xfc, ), 0x8, ), ShiftLe=
ft(PBAL, 0x2, ), BASE)
                            ShiftRight(READ(0x1b, 0xf0), 0x4, Local0)
                            Name(RSCB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x=
0, 0x0, 0x1, 0x8, 0x22, 0x1, 0x0, 0x79, 0x0 })
                            CreateWordField(RSCB, 0x2, IO1B)
                            CreateWordField(RSCB, 0x4, IO2B)
                            CreateByteField(RSCB, 0x7, IO3B)
                            CreateWordField(RSCB, 0x9, IRQB)
                            CreateByteField(RSCB, 0xc, CHKB)
                            Store(BASE, IO1B)
                            Store(BASE, IO2B)
                            If(LEqual(BASE, 0x03bc)) {
                                Store(0x3, IO3B)
                            }
                            If(Local0) {
                                ShiftLeft(0x1, Local0, IRQB)
                            }
                            Store(Zero, CHKB)
                            Return(RSCB)
                        }
                        Method(_SRS, 1, Serialized) {
                            Name(XRFI, Package(0x10) {
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x7,
                                0x0,
                                0x1,
                                0x0,
                                0x2,
                                0x3,
                                0x4,
                                0x0,
                                0x0,
                                0x5,
                                0x6,
                            })
                            CreateWordField(Arg0, 0x2, IO1A)
                            CreateWordField(Arg0, 0x9, IRQA)
                            WRIT(0x42, 0x0, ShiftRight(IO1A, 0x2, ))
                            WRIT(0x43, 0x3, ShiftRight(IO1A, 0x8, ))
                            FindSetRightBit(IRQA, Local0)
                            If(Local0) {
                                Decrement(Local0)
                                WRIT(0x1b, 0xf, ShiftLeft(Local0, 0x4, ))
                                WRIT(0x1b, 0xf8, DerefOf(Index(XRFI, Local0=
, )))
                            }
                            Else {
                                WRIT(0x1b, 0x8, 0x0)
                            }
                            Or(FER_, 0x1, FER_)
                            \_SB_.PCI0.PWR_.ENAB(IO1A, 0x0)
                            Store(0xf, _STA)
                        }
                        Method(_PS0, 0, Serialized) {
                            Or(FER_, 0x1, FER_)
                            Store(0x0, _PSC)
                        }
                        Method(_PS3, 0, Serialized) {
                            Store(0x3, _PSC)
                        }
                    }
                    Device(EPP_) {
                        Name(_HID, 0x0004d041)
                        Name(_UID, 0x3)
                        Name(_PSC, 0x0)
                        Name(_STA, 0x0)
                        Name(MCD_, 0x12)
                        Method(B_PR) {
                            Return(Buffer(0x33) {0x30, 0x47, 0x1, 0x78, 0x3=
, 0x78, 0x3, 0x1, 0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0=
x3, 0x1, 0x8, 0x22, 0x20, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, =
0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x22=
, 0x20, 0x0, 0x38, 0x79, 0x0 })
                        }
                        Method(B_DI, 0, Serialized) {
                            Store(0xd, _STA)
                        }
                        Name(_PRW, Package(0x2) {
                            0xb,
                            0x4,
                        })
                        Method(_CRS, 0, Serialized) {
                            Name(BASE, 0x0)
                            Or(ShiftLeft(And(PBAH, 0xfc, ), 0x8, ), ShiftLe=
ft(PBAL, 0x2, ), BASE)
                            ShiftRight(READ(0x1b, 0xf0), 0x4, Local0)
                            Name(RSCB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x=
0, 0x0, 0x1, 0x8, 0x22, 0x1, 0x0, 0x79, 0x0 })
                            CreateWordField(RSCB, 0x2, IO1B)
                            CreateWordField(RSCB, 0x4, IO2B)
                            CreateByteField(RSCB, 0x7, IO3B)
                            CreateWordField(RSCB, 0x9, IRQB)
                            CreateByteField(RSCB, 0xc, CHKB)
                            Store(BASE, IO1B)
                            Store(BASE, IO2B)
                            If(LEqual(BASE, 0x03bc)) {
                                Store(0x3, IO3B)
                            }
                            If(Local0) {
                                ShiftLeft(0x1, Local0, IRQB)
                            }
                            Store(Zero, CHKB)
                            Return(RSCB)
                        }
                        Method(B_SR, 1, Serialized) {
                            Name(XRFI, Package(0x10) {
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x7,
                                0x0,
                                0x1,
                                0x0,
                                0x2,
                                0x3,
                                0x4,
                                0x0,
                                0x0,
                                0x5,
                                0x6,
                            })
                            CreateWordField(Arg0, 0x2, IO1A)
                            CreateWordField(Arg0, 0x9, IRQA)
                            WRIT(0x42, 0x0, ShiftRight(IO1A, 0x2, ))
                            WRIT(0x43, 0x3, ShiftRight(IO1A, 0x8, ))
                            FindSetRightBit(IRQA, Local0)
                            If(Local0) {
                                Decrement(Local0)
                                WRIT(0x1b, 0xf, ShiftLeft(Local0, 0x4, ))
                                WRIT(0x1b, 0xf8, DerefOf(Index(XRFI, Local0=
, )))
                            }
                            Else {
                                WRIT(0x1b, 0x8, 0x0)
                            }
                            Or(FER_, 0x1, FER_)
                            \_SB_.PCI0.PWR_.ENAB(IO1A, 0x0)
                            Store(0xf, _STA)
                        }
                        Method(_PS0, 0, Serialized) {
                            Or(FER_, 0x1, FER_)
                            Store(0x0, _PSC)
                        }
                        Method(_PS3, 0, Serialized) {
                            Store(0x3, _PSC)
                        }
                    }
                    Device(ECP_) {
                        Name(_HID, 0x0104d041)
                        Name(_UID, 0x1)
                        Name(_PSC, 0x0)
                        Name(_STA, 0x0)
                        Name(MCD_, 0x10)
                        Method(B_PR) {
                            Return(Buffer(0x7e) {0x30, 0x47, 0x1, 0x78, 0x3=
, 0x78, 0x3, 0x1, 0x8, 0x22, 0x80, 0x0, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x=
1, 0x8, 0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x1, 0x8, 0x22, 0x20, 0x0, 0=
x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x1, 0x8, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78,=
 0x2, 0x1, 0x8, 0x22, 0x80, 0x0, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x1, 0x8,=
 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x22, 0x20, 0x0, 0x47, 0x=
1, 0x78, 0x6, 0x78, 0x6, 0x1, 0x8, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0=
x1, 0x3, 0x22, 0x80, 0x0, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x1, 0x8, 0x30, =
0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x3, 0x22, 0x20, 0x0, 0x47, 0x1, 0xbc=
, 0x7, 0xbc, 0x7, 0x1, 0x8, 0x38, 0x2a, 0xb, 0x0, 0x79, 0x0 })
                        }
                        Method(B_DI, 0, Serialized) {
                            Store(0xd, _STA)
                        }
                        Name(_PRW, Package(0x2) {
                            0xb,
                            0x4,
                        })
                        Method(_CRS, 0, Serialized) {
                            Name(BASE, 0x0)
                            Or(ShiftLeft(And(PBAH, 0xfc, ), 0x8, ), ShiftLe=
ft(PBAL, 0x2, ), BASE)
                            ShiftRight(READ(0x1b, 0xf0), 0x4, Local0)
                            Name(RSCA, Buffer(0x18) {0x47, 0x1, 0x0, 0x0, 0=
x0, 0x0, 0x1, 0x8, 0x22, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8,=
 0x2a, 0x0, 0x0, 0x79, 0x0 })
                            CreateWordField(RSCA, 0x2, IO1A)
                            CreateWordField(RSCA, 0x4, IO2A)
                            CreateByteField(RSCA, 0x7, IO3A)
                            CreateWordField(RSCA, 0x9, IRQA)
                            CreateWordField(RSCA, 0xd, IO4A)
                            CreateWordField(RSCA, 0xf, IO5A)
                            CreateByteField(RSCA, 0x12, IO6A)
                            CreateByteField(RSCA, 0x14, DMAA)
                            CreateByteField(RSCA, 0x17, CHKA)
                            Store(BASE, IO1A)
                            Store(BASE, IO2A)
                            Add(BASE, 0x0400, IO4A)
                            Store(IO4A, IO5A)
                            If(LEqual(BASE, 0x03bc)) {
                                Store(0x3, IO3A)
                                Store(0x3, IO6A)
                            }
                            If(Local0) {
                                ShiftLeft(0x1, Local0, IRQA)
                            }
                            ShiftRight(READ(0x18, 0x38), 0x3, Local1)
                            If(Local1) {
                                Decrement(Local1)
                                ShiftLeft(0x1, Local1, DMAA)
                            }
                            Store(Zero, CHKA)
                            Return(RSCA)
                        }
                        Method(B_SR, 1, Serialized) {
                            Name(XRFI, Package(0x10) {
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x0,
                                0x7,
                                0x0,
                                0x1,
                                0x0,
                                0x2,
                                0x3,
                                0x4,
                                0x0,
                                0x0,
                                0x5,
                                0x6,
                            })
                            CreateWordField(Arg0, 0x2, IO1A)
                            CreateWordField(Arg0, 0x9, IRQA)
                            WRIT(0x42, 0x0, ShiftRight(IO1A, 0x2, ))
                            WRIT(0x43, 0x3, ShiftRight(IO1A, 0x8, ))
                            FindSetRightBit(IRQA, Local0)
                            If(Local0) {
                                Decrement(Local0)
                                WRIT(0x1b, 0xf, ShiftLeft(Local0, 0x4, ))
                                WRIT(0x1b, 0xf8, DerefOf(Index(XRFI, Local0=
, )))
                            }
                            Else {
                                WRIT(0x1b, 0x8, 0x0)
                            }
                            CreateByteField(Arg0, 0x14, DMAA)
                            FindSetRightBit(DMAA, Local0)
                            WRIT(0x18, 0xc7, ShiftLeft(Local0, 0x3, ))
                            Or(FER_, 0x1, FER_)
                            \_SB_.PCI0.PWR_.ENAB(IO1A, 0x0)
                            Store(0xf, _STA)
                        }
                        Method(_PS0, 0, Serialized) {
                            Or(FER_, 0x1, FER_)
                            Store(0x0, _PSC)
                        }
                        Method(_PS3, 0, Serialized) {
                            Store(0x3, _PSC)
                        }
                    }
                    Device(FDC_) {
                        Name(_HID, 0x0007d041)
                        Name(_UID, 0x1)
                        Name(_PSC, 0x0)
                        Name(MCD_, 0x11)
                        Name(FCFG, Buffer(0x18) {0x47, 0x1, 0xf0, 0x3, 0xf0=
, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x40, 0x0=
, 0x2a, 0x4, 0x0, 0x79, 0x0 })
                        Name(_STA, 0xf)
                        OperationRegion(FREG, SystemIO, 0x03f0, 0x8)
                        Field(FREG, ByteAcc, NoLock, Preserve) {
                            SRA_,	8,
                            SRB_,	8,
                            DOR_,	8,
                            TDR_,	8,
                            MSR_,	8,
                            FIFO,	8,
                            Offset(0x7),
                            CCR_,	8
                        }
                        Method(_PRS) {
                            Return(Buffer(0x1a) {0x30, 0x47, 0x1, 0xf0, 0x3=
, 0xf0, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x4=
0, 0x0, 0x2a, 0x4, 0x0, 0x38, 0x79, 0x0 })
                        }
                        Method(_DIS, 0, Serialized) {
                            Store(0xd, _STA)
                        }
                        Method(_CRS, 0, Serialized) {
                            Return(FCFG)
                        }
                        Method(_SRS, 1, Serialized) {
                            Store(0xf, _STA)
                        }
                        Method(_PS0, 0, Serialized) {
                            Store(0x0, _PSC)
                        }
                        Method(_PS3, 0, Serialized) {
                            Store(0x3, _PSC)
                        }
                    }
                }
            }
        }
        Device(TI94) {
            Name(_ADR, 0x000c0000)
        }
        Device(LAN0) {
            Name(_ADR, 0x000b0000)
            Method(_STA) {
                Return(0xf)
            }
        }
        Device(CRD0) {
            Name(_ADR, 0x00080000)
            Name(_STA, 0xf)
            Name(_PRW, Package(0x2) {
                0x9,
                0x4,
            })
            Device(SCK0) {
                Name(_ADR, 0x0)
                Name(_STA, 0xf)
            }
            Device(SCK1) {
                Name(_ADR, 0x1)
                Name(_STA, 0xf)
            }
            Method(_INI) {
                Or(PMEE, 0x1, PMEE)
            }
            Method(_PSC) {
                Store(PWST, Local0)
                Return(Local0)
            }
            Method(_PS0) {
                Store(0x0, PWST)
                Store(0x1, PMST)
                Sleep(0x0168)
            }
            Method(_PS2) {
                Store(0x1, PMST)
            }
            Method(_PS3) {
                Store(0x1, PMST)
            }
            OperationRegion(CCRD, PCI_Config, 0x0, 0xa7)
            Field(CCRD, DWordAcc, Lock, Preserve) {
                Offset(0x80),
                PMEE,	1,
                Offset(0xa4),
                PWST,	2,
                Offset(0xa5),
                ,	7,
                PMST,	1
            }
        }
        Device(H8__) {
            Method(_REG, 2) {
                If(LEqual(Arg0, 0x3)) {
                    Store(Arg1, ECFL)
                }
                Notify(\_SB_.AC__, 0x0)
            }
            Name(_HID, 0x090cd041)
            Method(_GLK, 1) {
                Return(One)
            }
            Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x1, =
0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x1, 0x1, 0x79, 0x0 })
            Name(_GPE, 0x0)
            Name(_PRW, Package(0x2) {
                0xb,
                0x4,
            })
            OperationRegion(ERAM, EmbeddedControl, 0x0, 0xff)
            Field(ERAM, ByteAcc, NoLock, Preserve) {
                Offset(0x4),
                CMCM,	8,
                CMD1,	8,
                CMD2,	8,
                CMD3,	8,
                Offset(0x18),
                SMPR,	8,
                SMST,	8,
                SMAD,	8,
                SMCM,	8,
                SMD0,	256,
                SMCT,	8,
                SMAA,	8,
                Offset(0x84),
                Z003,	8,
                Offset(0x88),
                Z004,	8,
                Z005,	8,
                Offset(0x91),
                BPRS,	1,
                ACPR,	1,
                BCHG,	1,
                BDCH,	1,
                LOBT,	1,
                VLBT,	1,
                Offset(0x9a),
                CAUS,	8,
                Offset(0xa9),
                TMP0,	8,
                Offset(0xb4),
                MVLT,	8,
                MVL2,	8,
                MAMP,	8,
                MAM2,	8,
                MMAH,	8,
                MMA2,	8
            }
            Field(ERAM, ByteAcc, NoLock, Preserve) {
                Offset(0x1c),
                SMW0,	16
            }
            Field(ERAM, ByteAcc, NoLock, Preserve) {
                Offset(0x1c),
                SMB0,	8
            }
            Field(ERAM, ByteAcc, NoLock, Preserve) {
                Offset(0x91),
                BATT,	8
            }
            Method(SMRD, 4) {
                If(LNot(LEqual(Arg0, 0x7))) {
                    If(LNot(LEqual(Arg0, 0x9))) {
                        If(LNot(LEqual(Arg0, 0xb))) {
                            Return(0x19)
                        }
                    }
                }
                Acquire(MUT0, 0xffff)
                Store(0xa, Local0)
                Store(Zero, SMD0)
                While(LGreater(Local0, 0x1)) {
                    And(SMST, 0x40, SMST)
                    Store(Arg1, SMAD)
                    Store(Arg2, SMCM)
                    Store(Arg0, SMPR)
                    While(LNot(And(SMST, 0xbf, Local1))) {
                        Sleep(0x2)
                    }
                    If(LEqual(Local1, 0x80)) {
                        Store(0x0, Local0)
                    }
                    Else {
                        Decrement(Local0)
                    }
                }
                If(Local0) {
                    Store(And(Local1, 0x1f, ), Local0)
                }
                Else {
                    If(LEqual(Arg0, 0x7)) {
                        Store(SMB0, Arg3)
                    }
                    If(LEqual(Arg0, 0x9)) {
                        Store(SMW0, Arg3)
                    }
                    If(LEqual(Arg0, 0xb)) {
                        Store(SMD0, Arg3)
                    }
                }
                Release(MUT0)
                Return(Local0)
            }
            Method(SMWR, 4) {
                If(LNot(LEqual(Arg0, 0x6))) {
                    If(LNot(LEqual(Arg0, 0x8))) {
                        If(LNot(LEqual(Arg0, 0xa))) {
                            Return(0x19)
                        }
                    }
                }
                Acquire(MUT0, 0xffff)
                Store(0xa, Local0)
                While(LGreater(Local0, 0x1)) {
                    If(LEqual(Arg0, 0x6)) {
                        Store(Arg3, SMB0)
                    }
                    If(LEqual(Arg0, 0x8)) {
                        Store(Arg3, SMW0)
                    }
                    If(LEqual(Arg0, 0xa)) {
                        Store(Arg3, SMD0)
                    }
                    And(SMST, 0x40, SMST)
                    Store(Arg2, SMCM)
                    Store(Arg1, SMAD)
                    Store(Arg0, SMPR)
                    While(LNot(And(SMST, 0xbf, Local1))) {
                        Sleep(0x2)
                    }
                    If(LEqual(Local1, 0x80)) {
                        Store(0x0, Local0)
                    }
                    Else {
                        Decrement(Local0)
                    }
                }
                If(Local0) {
                    Store(And(Local1, 0x1f, ), Local0)
                }
                Release(MUT0)
                Return(Local0)
            }
            Method(_Q14) {
                Store("Standby hotkey!", Debug)
                If(LEqual(CSST, 0x0)) {
                    Notify(\_SB_.SLPB, 0x80)
                }
            }
            Method(_Q25) {
                Store("Power switch!", Debug)
                If(LEqual(CSST, 0x0)) {
                    Notify(\_SB_.PWRB, 0x80)
                }
            }
            Method(_Q2F) {
                SSMI(0x8e, 0x3)
                Store(0x1, \_SB_.AC__.ACPW)
                Store(Ones, \_SB_.CMB0.BATP)
                Notify(\_SB_.AC__, 0x0)
                Notify(\_SB_.AC__, 0x80)
            }
            Method(_Q30) {
                SSMI(0x8e, 0x4)
                Store(0x0, \_SB_.AC__.ACPW)
                Store(Ones, \_SB_.CMB0.BATP)
                Notify(\_SB_.AC__, 0x1)
                Notify(\_SB_.AC__, 0x80)
            }
            Method(_Q31) {
                Notify(\_SB_.CMB0, 0x80)
            }
            Method(_Q32) {
                Notify(\_SB_.CMB0, 0x80)
            }
            Method(_Q33) {
                Notify(\_TZ_.TZ0_, 0x80)
            }
            Method(_Q34) {
                Notify(\_TZ_.TZ0_, 0x80)
                Notify(\_TZ_.TZ0_, 0x81)
            }
            Method(_Q35) {
                Notify(\_TZ_.TZ0_, 0x80)
                Notify(\_TZ_.TZ0_, 0x81)
            }
            Method(_Q36) {
                Notify(\_TZ_.TZ0_, 0x80)
                Store("Q36", Debug)
            }
            Method(_Q3B) {
                SSMI(0x8e, 0x5)
            }
            Method(_Q3D) {
                Notify(\_SB_.CMB0, 0x0)
            }
            Method(_Q3E) {
                Notify(\_SB_.CMB0, 0x1)
            }
            Method(_Q40) {
                Or(\_SB_.PCI0.IDE_.Z001, 0xc000, \_SB_.PCI0.IDE_.Z001)
                Sleep(0x01f4)
                SSMI(0x8a, 0x2)
                Sleep(0xfa)
                Notify(\_SB_.PCI0.IDE_.SECD, 0x0)
                Notify(\_SB_.PCI0, 0x0)
            }
            Method(_Q41) {
                SSMI(0x8a, 0x1)
                Sleep(0xfa)
                Notify(\_SB_.PCI0.EIO_.MOTH.SIO_.FDC_, 0x0)
                Notify(\_SB_.PCI0, 0x0)
            }
            Method(_Q43) {
                SSMI(0x8a, 0x0)
                And(0x7fff, \_SB_.PCI0.IDE_.Z001, \_SB_.PCI0.IDE_.Z001)
                Sleep(0x0250)
                Notify(\_SB_.PCI0.IDE_.SECD, 0x1)
                Notify(\_SB_.PCI0, 0x0)
            }
            Method(_Q46) {
                Store(0x0, \_SB_.LID_.LPOL)
                Notify(\_SB_.LID_, 0x80)
            }
            Method(_Q47) {
                Store(0x1, \_SB_.LID_.LPOL)
                Notify(\_SB_.LID_, 0x80)
            }
        }
    }
}
Scope(_TZ_) {
    ThermalZone(TZ0_) {
        Name(_TC1, 0x0)
        Name(_TC2, 0x1)
        Name(_TSP, 0x96)
        Name(_PSL, Package(0x1) {
            \_PR_.CPU0,
        })
        Method(_PSV) {
            Return(0x0e30)
        }
        Method(_CRT) {
            Return(0x0e94)
        }
        Method(_TMP) {
            If(LEqual(\ECFL, Zero)) {
                Return(0x0c80)
            }
            Else {
                Acquire(MUT0, 0xffff)
                Store(\_SB_.PCI0.H8__.TMP0, Local0)
                Release(MUT0)
                Multiply(Local0, 0xa, Local0)
                Add(Local0, 0x0aac, Local0)
                Store("Temp =3D ", Debug)
                Store(Local0, Debug)
                If(LLess(Local0, 0x0bae)) {
                    Return(0x0c80)
                }
                Else {
                    Return(Local0)
                }
            }
        }
    }
}
Method(Z002, 0, Serialized) {
    Acquire(MUT0, 0xffff)
    Store(0x0, Local1)
    Store(\_SB_.PCI0.H8__.Z005, Local0)
    And(Local0, 0x1, Local0)
    If(LEqual(Local0, 0x0)) {
        Store(\_SB_.PCI0.H8__.Z004, Local0)
        ShiftRight(Local0, 0x4, Local0)
        And(Local0, 0x1, Local0)
        If(LEqual(Local0, 0x1)) {
            Or(Local1, 0x1, Local1)
        }
        Else {
            Or(Local1, 0x2, Local1)
        }
    }
    Release(MUT0)
    Return(Local1)
}
Method(_PTS, 1) {
    Store(Arg0, CSST)
    Store("_PTS: entering sleep state ", Debug)
    Store(CSST, Debug)
    Store(Z002(), \MSTA)
    If(LNot(LLess(Arg0, 0x2))) {
        Store(One, \_SB_.PCI0.CRST)
    }
    Else {
        Store(Zero, \_SB_.PCI0.CRST)
        \_SB_.SSMI(0x80, 0x40)
        \_SB_.SSMI(0x8e, 0x1)
    }
    Or(\_SB_.PCI0.PWR_.GO08, 0x10, \_SB_.PCI0.PWR_.GO08)
    And(\_SB_.PCI0.PWR_.GO08, 0xdf, \_SB_.PCI0.PWR_.GO08)
    Return(0x0)
}
Name(MSTA, 0xff)
Method(_WAK, 1) {
    Or(\_SB_.PCI0.PWR_.GO08, 0x20, \_SB_.PCI0.PWR_.GO08)
    And(\_SB_.PCI0.PWR_.GO08, 0xef, \_SB_.PCI0.PWR_.GO08)
    If(LEqual(0x1, CSST)) {
        \_SB_.SSMI(0x80, 0x41)
    }
    \_SB_.SSMI(0x8e, 0x2)
    \_SB_.SSMI(0x84, 0x0)
    Store(Zero, CSST)
    Store(0x0, \_SB_.PCI0.CRST)
    Notify(\_SB_.PWRB, 0x2)
    Notify(\_SB_.AC__, 0x80)
    Notify(\_SB_.CMB0, 0x80)
    Notify(\_SB_.PCI0.CRD0, 0x0)
    If(LEqual(0x1, S1S4)) {
        Notify(\_SB_.PWRB, 0x80)
        Store(0x0, S1S4)
        Store("S1S4 PWRB Notify", Debug)
    }
    Store(Z002(), Local0)
    If(LNot(LEqual(\MSTA, Local0))) {
        And(Local0, 0x2, Local0)
        If(LEqual(Local0, 0x2)) {
            Store(0x0, Local0)
            Or(\_SB_.PCI0.IDE_.Z001, 0x8000, \_SB_.PCI0.IDE_.Z001)
        }
        Else {
            Store(0x1, Local0)
            And(\_SB_.PCI0.IDE_.Z001, 0x7fff, \_SB_.PCI0.IDE_.Z001)
        }
        Store(Z002(), Local1)
        \_SB_.SSMI(0x8a, Local1)
        Notify(\_SB_.PCI0.IDE_.SECD.DVD_, Local0)
        Notify(\_SB_.PCI0, 0x0)
    }
}
Method(ITOS, 1) {
    Store("", Local0)
    Store(0x4, Local1)
    While(Local1) {
        Decrement(Local1)
        And(ShiftRight(Arg0, ShiftLeft(Local1, 0x2, ), ), 0xf, Local4)
        Store(DerefOf(Index(CHAR, Local4, )), Local2)
        Concatenate(Local0, Local2, Local5)
        Store(Local5, Local0)
    }
    Return(Local0)
}
Name(CHAR, Package(0x10) {
    "0",
    "1",
    "2",
    "3",
    "4",
    "5",
    "6",
    "7",
    "8",
    "9",
    "A",
    "B",
    "C",
    "D",
    "E",
    "F",
})
Method(MIN_, 2) {
    If(LLess(Arg0, Arg1)) {
        Return(Arg0)
    }
    Else {
        Return(Arg1)
    }
}
Method(SLEN, 1) {
    Return(SizeOf(Arg0))
}
Method(S2BF, 1, Serialized) {
    Add(SLEN(Arg0), One, Local0)
    Name(BUFF, Buffer(Local0) { })
    Store(Arg0, BUFF)
    Return(BUFF)
}
Method(SCMP, 2) {
    Store(S2BF(Arg0), Local0)
    Store(S2BF(Arg1), Local1)
    Store(Zero, Local4)
    Store(SLEN(Arg0), Local5)
    Store(SLEN(Arg1), Local6)
    Store(MIN_(Local5, Local6), Local7)
    While(LLess(Local4, Local7)) {
        Store(DerefOf(Index(Local0, Local4, )), Local2)
        Store(DerefOf(Index(Local1, Local4, )), Local3)
        If(LGreater(Local2, Local3)) {
            Return(One)
        }
        Else {
            If(LLess(Local2, Local3)) {
                Return(Ones)
            }
        }
        Increment(Local4)
    }
    If(LLess(Local4, Local5)) {
        Return(One)
    }
    Else {
        If(LLess(Local4, Local6)) {
            Return(Ones)
        }
        Else {
            Return(Zero)
        }
    }
}

}
/*
BOOT: Length=3D39, Revision=3D1, Checksum=3D162,
	OEMID=3DPTLTD, OEM Table ID=3D$SBFTBL$, OEM Revision=3D0x6040000,
	Creator ID=3D LTP, Creator Revision=3D0x1
 */

--4Ckj6UjgE2iN1+kY--
