From owner-acpi-jp@jp.freebsd.org  Fri Nov 16 02:22:23 2001
Received: (from daemon@localhost)
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) id CAA01741;
	Fri, 16 Nov 2001 02:22:23 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from ardbeg.meer.net (ardbeg.meer.net [209.157.152.23])
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) with ESMTP id CAA01736
	for <acpi-jp@jp.freebsd.org>; Fri, 16 Nov 2001 02:22:20 +0900 (JST)
	(envelope-from gnn@neville-neil.com)
Received: from meer.meer.net (mail.meer.net [209.157.152.14])
	by ardbeg.meer.net (8.11.3/8.11.3) with ESMTP id fAFHMJc75543
	for <acpi-jp@jp.freebsd.org>; Thu, 15 Nov 2001 09:22:19 -0800 (PST)
Received: from neville-neil.com ([209.157.133.226])
	by meer.meer.net (8.9.3/8.9.3/meer) with ESMTP id JAA1538474
	for <acpi-jp@jp.freebsd.org>; Thu, 15 Nov 2001 09:21:57 -0800 (PST)
Message-Id: <200111151721.JAA1538474@meer.meer.net>
X-Mailer: exmh version 2.3.1 01/18/2001 with nmh-1.0.4
To: acpi-jp@jp.freebsd.org
Mime-Version: 1.0
Content-Type: multipart/mixed ;
	boundary="==_Exmh_7933893120"
Date: Thu, 15 Nov 2001 09:24:17 -0800
From: "George V. Neville-Neil" <gnn@neville-neil.com>
Reply-To: acpi-jp@jp.freebsd.org
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+010328
X-Sequence: acpi-jp 1470
Subject: [acpi-jp 1470] acpidump output for VAIO R505-TLK (SlimNote)
Errors-To: owner-acpi-jp@jp.freebsd.org
Sender: owner-acpi-jp@jp.freebsd.org
X-Originator: gnn@neville-neil.com

This is a multipart MIME message.

--==_Exmh_7933893120
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: quoted-printable

Here is the acpidump output from my laptop.  I got this using the tool
in ports.

I'd like to help getting ACPI running on this laptop, if only for my own =
self
interest.

Later,
George

acpidump -o vaioR505TLK.dsdt > vaioR505TLK.asl



--==_Exmh_7933893120
Content-Type: text/plain ; name="vaioR505TLK.asl"; charset=iso-8859-1
Content-Description: vaioR505TLK.asl
Content-Disposition: attachment; filename="vaioR505TLK.asl"
Content-Transfer-Encoding: quoted-printable

/*
RSD PTR: Checksum=3D24, OEMID=3DPTLTD, RsdtAddress=3D0x07cf74d7
 */
/*
RSDT: Length=3D44, Revision=3D1, Checksum=3D4,
	OEMID=3DSONY, OEM Table ID=3DU1, OEM Revision=3D0x20010626,
	Creator ID=3DPTL, Creator Revision=3D0x0
 */
/*
	Entries=3D{ 0x07cfbf64, 0x07cfbfd8 }
 */
/*
	DSDT=3D0x7cf7503
	INT_MODEL=3DPIC
	SCI_INT=3D9
	SMI_CMD=3D0xb2, ACPI_ENABLE=3D0xf0, ACPI_DISABLE=3D0xf1, S4BIOS_REQ=3D0x=
0
	PM1a_EVT_BLK=3D0x1000-0x1003
	PM1a_CNT_BLK=3D0x1004-0x1005
	PM2_CNT_BLK=3D0x1020-0x1020
	PM2_TMR_BLK=3D0x1008-0x100b
	PM2_GPE0_BLK=3D0x1028-0x102b
	PM2_GPE1_BLK=3D0x102c-0x102f, GPE1_BASE=3D16
	P_LVL2_LAT=3D10ms, P_LVL3_LAT=3D1001ms
	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,RTC_S4,DCK_CAP}
 */
/*
DSDT: Length=3D19041, Revision=3D1, Checksum=3D125,
	OEMID=3DSONY, OEM Table ID=3DU1, OEM Revision=3D0x20010626,
	Creator ID=3DPTL, Creator Revision=3D0x100000b
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "SONY",		//OEMID
    "U1",		//TABLE ID
    0x20010626		//OEM Revision
)

{
Scope(_PR_) {
    Processor(CPU0, 0, 0x1010, 0x6) {
    }
}
Name(_S0_, Package(0x2) {
    0x0,
    0x0,
})
Name(_S3_, Package(0x2) {
    0x5,
    0x5,
})
Name(_S4_, Package(0x2) {
    0x6,
    0x6,
})
Name(_S5_, Package(0x2) {
    0x7,
    0x7,
})
Method(_PTS, 1) {
    If(LEqual(Arg0, 0x3)) {
        Store(\_SB_.PCI0.LPC0.SPIC._CRS(), \_SB_.PCI0.LPC0.SPIC.SSRC)
        PHS_(0xa0)
    }
    If(LEqual(Arg0, 0x4)) {
        Store(\_SB_.PCI0.LPC0.SPIC._CRS(), \_SB_.PCI0.LPC0.SPIC.SSRC)
        PHS_(0xa2)
    }
    If(LOr(LEqual(Arg0, 0x3), LEqual(Arg0, 0x4))) {
        Store(\_SB_.DOCK.GDST(), \_SB_.DOCK.DKST)
    }
}
OperationRegion(SMI0, SystemMemory, 0x07cfcb38, 0x00000415)
Field(SMI0, AnyAcc, NoLock, Preserve) {
    BCMD,	8,
    DID_,	32,
    INFO,	4096
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INFB,	8
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INFD,	32
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    SXBF,	8320
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INF1,	8,
    INF2,	8
}
OperationRegion(SMI1, SystemIO, 0x0000fe00, 0x00000002)
Field(SMI1, AnyAcc, NoLock, Preserve) {
    SMIC,	8
}
Mutex(MPHS, 0)
Method(PHS0, 1) {
    Store(Arg0, BCMD)
    Store(Zero, SMIC)
    While(LEqual(BCMD, Arg0)) {
    }
    Store(0x0, BCMD)
}
Method(PHS_, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    PHS0(Arg0)
    Store(INFD, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PHSD, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    Store(Arg1, INFD)
    PHS0(Arg0)
    Store(INFD, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PHSW, 3, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    Store(Arg1, INF1)
    Store(Arg2, INF2)
    PHS0(Arg0)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PHSB, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    Store(Arg1, INFB)
    PHS0(Arg0)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSCS, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x0)
    Store(INFO, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSSS, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    Store(Arg1, INFO)
    PHS0(0x1)
    Release(MPHS)
}
Method(PSPS, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x2)
    Store(INFO, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSDI, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x3)
    Release(MPHS)
}
Method(PSST, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x4)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Scope(\_GPE) {
    Method(_L03) {
        Notify(\_SB_.PCI0.USB1, 0x2)
    }
    Method(_L04) {
        Notify(\_SB_.PCI0.USB2, 0x2)
    }
    Method(_L05) {
        Notify(\_SB_.PCI0.MODE, 0x2)
    }
    Method(_L0B) {
        Notify(\_SB_.PCI0.HUB_, 0x2)
    }
    Method(_L1D) {
        Notify(\_SB_.PCI0.LPC0.EC0_, 0x2)
    }
}
Scope(_SB_) {
    Device(LID_) {
        Name(_HID, 0x0d0cd041)
        Method(_LID) {
            If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                And(PHSB(0xd4, 0x82), 0x4, Local0)
            }
            Else {
                Store(\_SB_.PCI0.LPC0.EC0_.LIDS, Local0)
            }
            Return(Local0)
        }
    }
    Device(PWRB) {
        Name(_HID, 0x0c0cd041)
        Name(_PRW, Package(0x2) {
            0x1d,
            0x5,
        })
        Method(_STA) {
            Return(0xf)
        }
    }
    Device(DOCK) {
        Name(_HID, 0x150cd041)
        Name(_UID, 0x0)
        Name(_BDN, 0xffffffff)
        Name(DKST, 0x0)
        Name(DKFS, 0x0)
        Name(DCRI, 0x0)
        Event(UDCK)
        Method(GDST) {
            If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                And(PHSB(0xd4, 0x80), 0x4, Local0)
            }
            Else {
                Store(\_SB_.PCI0.LPC0.EC0_.DOKD, Local0)
            }
            If(LEqual(Zero, Local0)) {
                Return(Zero)
            }
            Else {
                Return(Ones)
            }
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.FDC_.ARM_, Zero)) {
                If(LEqual(PHS_(0xdd), One)) {
                    Store(One, \_SB_.PCI0.LPC0.FDC_.ARM_)
                }
            }
            Store(GDST(), DKFS)
            If(DKFS) {
                If(LEqual(\_SB_.PCI0.LPC0.FDC_.ARM_, Zero)) {
                    Store(One, Index(\_SB_.PCI0.LPC0.FDC_.FDIB, 0x0, ))
                    Store(One, Index(\_SB_.PCI0.LPC0.FDC_.FDES, 0x0, ))
                }
                Return(0xf)
            }
            Else {
                Store(Zero, Index(\_SB_.PCI0.LPC0.FDC_.FDIB, 0x0, ))
                Store(Zero, Index(\_SB_.PCI0.LPC0.FDC_.FDES, 0x0, ))
                Return(0x0)
            }
        }
        Method(_DCK, 1) {
            Return(DULF(Arg0))
        }
        Method(_EJ0, 1) {
            Store(Ones, \_SB_.PCI0.GCH0.DODF)
            Store(One, DCRI)
            Wait(UDCK, 0xffff)
            Reset(UDCK)
        }
        Method(DULF, 1) {
            If(LEqual(Arg0, 0x1)) {
                \_SB_.PCI0.LPC0.ENCF()
                And(\_SB_.PCI0.LPC0.CR05, 0xfd, \_SB_.PCI0.LPC0.CR05)
                \_SB_.PCI0.LPC0.EXCF()
                Store(Zero, \_SB_.PCI0.LPC0.GP20)
                Store(One, Local0)
            }
            Else {
                \_SB_.PCI0.LPC0.ENCF()
                Or(\_SB_.PCI0.LPC0.CR05, 0x2, \_SB_.PCI0.LPC0.CR05)
                \_SB_.PCI0.LPC0.EXCF()
                Store(One, \_SB_.PCI0.LPC0.GP20)
                If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                    PHSW(0xd5, 0x9f, Zero)
                }
                Else {
                    Store(Zero, \_SB_.PCI0.LPC0.EC0_.DUSE)
                }
                Store(Zero, Local0)
            }
            If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                PHSW(0xd5, 0x9e, Local0)
            }
            Else {
                Store(Local0, \_SB_.PCI0.LPC0.EC0_.ILED)
            }
            Return(One)
        }
    }
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Name(_BBN, 0x0)
        Name(_PRT, Package(0x8) {
            Package(0x4) {
                0x0001ffff,
                0x0,
                LNKA,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x1,
                LNKB,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x2,
                LNKC,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x3,
                LNKD,
                0x0,
            },
            Package(0x4) {
                0x0002ffff,
                0x0,
                LNKA,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x1,
                LNKB,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x2,
                LNKH,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x3,
                LNKD,
                0x0,
            },
        })
        OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
        Field(REGS, DWordAcc, NoLock, Preserve) {
            Offset(0x12),
            DRP0,	4,
            DRP1,	4,
            Offset(0x14),
            DRP2,	4,
            Offset(0x18),
            ,	7,
            HEN_,	1,
            PAM0,	8,
            PAM1,	8,
            PAM2,	8,
            PAM3,	8,
            PAM4,	8,
            PAM5,	8,
            PAM6,	8,
            Offset(0x30),
            ,	6,
            UMA_,	2
        }
        Name(DMST, Package(0x10) {
            0x0,
            0x20,
            0x20,
            0x30,
            0x40,
            0x40,
            0x60,
            0x80,
            0x0,
            0x80,
            0x80,
            0xc0,
            0x0100,
            0x0100,
            0x0100,
            0x0200,
        })
        Name(RSRC, Buffer(0x01b7) {0x88, 0xe, 0x0, 0x2, 0xc, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x18, 0x0, 0x0, 0x=
c, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 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, 0xc, 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, 0x0, 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, 0x0, 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, 0x0, =
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, =
0x0, 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, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, =
0x0, 0xff, 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, 0=
xff, 0x3f, 0xe, 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, 0x3, 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, 0x0, 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, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0x=
c, 0x1, 0x8, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc=
, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0,=
 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x0, 0x79, 0x0 })
        Method(_CRS, 0, Serialized) {
            Store(Zero, Local1)
            CreateDWordField(RSRC, 0x017a, BTMN)
            CreateDWordField(RSRC, 0x017e, BTMX)
            CreateDWordField(RSRC, 0x0186, BTLN)
            Store(DRP0, Local0)
            Store(DRP1, Local1)
            Store(DRP2, Local2)
            Add(DerefOf(Index(DMST, Local0, )), DerefOf(Index(DMST, Local=
1, )), Local0)
            Add(DerefOf(Index(DMST, Local2, )), Local0, Local0)
            Multiply(Local0, 0x00100000, Local0)
            Store(Local0, BTMN)
            Subtract(0xfec00000, Local0, BTLN)
            Subtract(Add(BTMN, BTLN, ), 0x1, BTMX)
            CreateBitField(RSRC, 0x0188, C0RW)
            CreateDWordField(RSRC, 0x36, C0MN)
            CreateDWordField(RSRC, 0x3a, C0MX)
            CreateDWordField(RSRC, 0x42, 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, 0x0260, C4RW)
            CreateDWordField(RSRC, 0x51, C4MN)
            CreateDWordField(RSRC, 0x55, C4MX)
            CreateDWordField(RSRC, 0x5d, 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, 0x0338, C8RW)
            CreateDWordField(RSRC, 0x6c, C8MN)
            CreateDWordField(RSRC, 0x70, C8MX)
            CreateDWordField(RSRC, 0x78, 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, 0x0410, CCRW)
            CreateDWordField(RSRC, 0x87, CCMN)
            CreateDWordField(RSRC, 0x8b, CCMX)
            CreateDWordField(RSRC, 0x93, 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, 0x04e8, D0RW)
            CreateDWordField(RSRC, 0xa2, D0MN)
            CreateDWordField(RSRC, 0xa6, D0MX)
            CreateDWordField(RSRC, 0xae, 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, 0x05c0, D4RW)
            CreateDWordField(RSRC, 0xbd, D4MN)
            CreateDWordField(RSRC, 0xc1, D4MX)
            CreateDWordField(RSRC, 0xc9, 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, 0x0698, D8RW)
            CreateDWordField(RSRC, 0xd8, D8MN)
            CreateDWordField(RSRC, 0xdc, D8MX)
            CreateDWordField(RSRC, 0xe4, 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, 0x0770, DCRW)
            CreateDWordField(RSRC, 0xf3, DCMN)
            CreateDWordField(RSRC, 0xf7, DCMX)
            CreateDWordField(RSRC, 0xff, DCLN)
            Store(One, DCRW)
            If(LEqual(And(PAM4, 0x30, ), 0x10)) {
                Store(Zero, DCRW)
            }
            Store(Zero, DCLN)
            If(LNot(And(PAM4, 0x30, ))) {
                Store(0x4000, DCLN)
            }
            CreateBitField(RSRC, 0x0848, E0RW)
            CreateDWordField(RSRC, 0x010e, E0MN)
            CreateDWordField(RSRC, 0x0112, E0MX)
            CreateDWordField(RSRC, 0x011a, 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, 0x0920, E4RW)
            CreateDWordField(RSRC, 0x0129, E4MN)
            CreateDWordField(RSRC, 0x012d, E4MX)
            CreateDWordField(RSRC, 0x0135, 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, 0x09f8, E8RW)
            CreateDWordField(RSRC, 0x0144, E8MN)
            CreateDWordField(RSRC, 0x0148, E8MX)
            CreateDWordField(RSRC, 0x0150, 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, 0x0ad0, ECRW)
            CreateDWordField(RSRC, 0x015f, ECMN)
            CreateDWordField(RSRC, 0x0163, ECMX)
            CreateDWordField(RSRC, 0x016b, 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)
        }
        Device(LVID) {
            Name(_HID, 0x020cd041)
            Name(_UID, 0x20)
            Name(RSRC, Buffer(0xe) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
            Method(_CRS, 0, Serialized) {
                CreateDWordField(RSRC, 0x4, SBAS)
                CreateDWordField(RSRC, 0x8, SLEN)
                Store(DRP0, Local0)
                Store(DRP1, Local1)
                Add(DerefOf(Index(DMST, Local0, )), DerefOf(Index(DMST, L=
ocal1, )), Local0)
                ShiftLeft(Local0, 0x14, Local0)
                If(HEN_) {
                    Subtract(Local0, 0x00100000, Local0)
                }
                If(LEqual(UMA_, 0x2)) {
                    Subtract(Local0, 0x00100000, SBAS)
                    Store(0x00180000, SLEN)
                }
                If(LEqual(UMA_, 0x3)) {
                    Subtract(Local0, 0x00100000, SBAS)
                    Store(0x00100000, SLEN)
                }
                Return(RSRC)
            }
        }
        Device(AGP_) {
            Name(_ADR, 0x00010000)
        }
        Device(GCH0) {
            Name(_ADR, 0x00020000)
            OperationRegion(VGAB, SystemMemory, 0xfffa0000, 0xc000)
            Field(VGAB, AnyAcc, Lock, Preserve) {
                BUF1,	393216
            }
            Name(BUFX, Buffer(0xc000) { })
            Name(SXBB, Buffer(0x0410) { })
            CreateWordField(SXBB, 0x0, SXFN)
            CreateWordField(SXBB, 0x2, SXSL)
            CreateWordField(SXBB, 0x20, SXBX)
            CreateWordField(SXBB, 0x28, SXCX)
            CreateWordField(SXBB, 0x2c, SXAX)
            Name(FNF7, 0x0)
            Name(FNF8, 0x0)
            Name(LDGS, 0x0)
            Name(PDOD, 0x0)
            Name(TBF7, Package(0x10) {
                0x2,
                0x2,
                0x3,
                0x1,
                0x2,
                0x2,
                0x2,
                0x2,
                0x3,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
            })
            Name(TBF8, Package(0x10) {
                0x2,
                0x8,
                0x8,
                0x8,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
            })
            Method(SXDD) {
                Store(0x32, SXFN)
                Store(0x5f64, SXAX)
                Store(0x0200, SXBX)
                Store(\_SB_.PCI0.LPC0.SNC_.CSXB(SXBB), SXBB)
                Store(And(ShiftRight(SXCX, 0x8, ), 0xf, ), Local0)
                If(LEqual(SXAX, 0x5f)) {
                    Store(" SXDD return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Else {
                    Store(" SXDD return value ", Debug)
                    Store(0x0, Debug)
                    Return(0x0)
                }
            }
            Method(SXCD) {
                Store(0x32, SXFN)
                Store(0x5f64, SXAX)
                Store(0x0100, SXBX)
                Store(\_SB_.PCI0.LPC0.SNC_.CSXB(SXBB), SXBB)
                If(LEqual(SXAX, 0x5f)) {
                    Store(And(SXCX, 0xf, ), Local0)
                    Store(" SXCD return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Else {
                    Store(" SXCD return value ", Debug)
                    Store(0x0, Debug)
                    Return(0x0)
                }
            }
            Method(SXSD, 1) {
                Store(0x32, SXFN)
                Store(0x5f64, SXAX)
                Store(0x1, SXBX)
                Store(Arg0, SXCX)
                Store(\_SB_.PCI0.LPC0.SNC_.CSXB(SXBB), SXBB)
                Return(SXAX)
            }
            Method(GDCS, 1) {
                Store(SXCD(), Local0)
                If(And(SXCX, Arg0, )) {
                    Return(0x1f)
                }
                Else {
                    Return(0x1d)
                }
                Return(0x1d)
            }
            Method(GDSS, 2) {
                Store(" _DSS Called ", Debug)
                Store(Arg0, Debug)
                If(And(Arg0, 0x40000000, )) {
                    Noop
                }
                Else {
                    Store(SXCD(), Local0)
                    If(LEqual(Local0, 0x0)) {
                        Noop
                    }
                    Else {
                        If(And(Arg1, 0x1, )) {
                            Or(Local0, Arg1, Local0)
                        }
                        Else {
                            And(Not(Arg1, ), Local0, Local0)
                        }
                        SXSD(Local0)
                    }
                }
            }
            Method(GDGS, 1) {
                If(LEqual(FNF7, FNF8)) {
                    Store(GDCS(Arg0), Local0)
                    Return(LOr(And(Local0, 0x2, ), 0x0))
                }
                Store(SXDD(), Local0)
                Store(SXCD(), Local1)
                If(LEqual(LAnd(Local1, Local0), 0x0)) {
                    Store(" Int10h failed. LCD Only ", Debug)
                    If(And(Arg0, 0x2, )) {
                        Return(0x1)
                    }
                    Else {
                        Return(0x0)
                    }
                }
                Else {
                    And(Local0, Local1, Local2)
                    If(FNF7) {
                        Store(And(Local0, DerefOf(Index(TBF7, Local2, )),=
 ), Local2)
                        Store(" Next Display value ", Debug)
                        Store(Local2, Debug)
                        Store(LOr(And(Local2, Arg0, ), 0x0), Local2)
                        Return(And(Local2, 0x1, ))
                    }
                    If(FNF8) {
                        Store(LOr(And(DerefOf(Index(TBF8, Local2, )), Arg=
0, ), 0x0), Local2)
                        Return(And(Local2, 0x1, ))
                    }
                    Return(0x0)
                }
                Return(0x0)
            }
            Method(_DOS, 1) {
                Store(And(Arg0, 0x3, ), LDGS)
                If(LEqual(Arg0, 0x0)) {
                    Store(0x0, FNF7)
                    Store(0x0, FNF8)
                }
            }
            Name(DODF, Zero)
            Method(_DOD) {
                Name(PSIZ, 0x0)
                Name(PPTR, 0x0)
                If(DODF) {
                    Return(Package(0x1) {
                        0x00010200,
                    })
                }
                Store(SXDD(), Local0)
                Store(Local0, Local1)
                Store(Local0, PDOD)
                While(Local1) {
                    If(And(Local1, 0x1, )) {
                        Increment(PSIZ)
                    }
                    ShiftRight(Local1, 0x1, Local1)
                }
                Store(" _DOD Called. PSIZE ", Debug)
                Store(PSIZ, Debug)
                If(LEqual(PSIZ, 0x1)) {
                    Name(VID1, Package(0x1) {
                        0x00010200,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID1, 0x0, ))
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID1, 0x0, ))
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID1, 0x0, ))
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID1, 0x0, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID1, Debug)
                    Return(VID1)
                }
                If(LEqual(PSIZ, 0x2)) {
                    Name(VID2, Package(0x2) {
                        0x00010100,
                        0x00010200,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID2, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID2, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID2, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID2, PPTR, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID2, Debug)
                    Return(VID2)
                }
                If(LEqual(PSIZ, 0x3)) {
                    Name(VID3, Package(0x3) {
                        0x00010100,
                        0x00010200,
                        0x00010300,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID3, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID3, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID3, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID3, PPTR, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID3, Debug)
                    Return(VID3)
                }
                If(LEqual(PSIZ, 0x4)) {
                    Name(VID4, Package(0x4) {
                        0x00010100,
                        0x00010200,
                        0x00010300,
                        0x00010400,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID4, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID4, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID4, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID4, PPTR, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID4, Debug)
                    Return(VID4)
                }
                Return(Package(0x1) {
                    0x00010200,
                })
            }
            Method(_ROM, 2) {
                Store(BUF1, BUFX)
                If(LGreater(Add(Arg0, Arg1, ), 0xc000)) {
                    Multiply(0x0, 0x8, Local0)
                    Multiply(0x1000, 0x8, Local1)
                }
                Else {
                    Multiply(Arg0, 0x8, Local0)
                    If(LGreater(Arg1, 0x1000)) {
                        Multiply(0x1000, 0x8, Local1)
                    }
                    Else {
                        Multiply(Arg1, 0x8, Local1)
                    }
                }
                CreateField(BUFX, Local0, Local1, BUFY)
                Return(BUFY)
            }
            Device(LFP_) {
                Name(_ADR, 0x0200)
                Method(_DCS) {
                    Return(GDCS(0x2))
                }
                Method(_DGS) {
                    Store(GDGS(0x2), Local0)
                    Store(" LFP _DGS return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Method(_DSS, 1) {
                    GDSS(Arg0, 0x2)
                }
            }
            Device(CRT_) {
                Name(_ADR, 0x0100)
                Method(_DCS) {
                    Return(GDCS(0x1))
                }
                Method(_DGS) {
                    Store(GDGS(0x1), Local0)
                    Store(" CRT _DGS return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Method(_DSS, 1) {
                    GDSS(Arg0, 0x1)
                }
            }
            Device(DTV_) {
                Name(_ADR, 0x0400)
                Method(_DCS) {
                    Return(GDCS(0x8))
                }
                Method(_DGS) {
                    Store(GDGS(0x8), Local0)
                    Store(" DTV _DGS return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Method(_DSS, 1) {
                    GDSS(Arg0, 0x8)
                }
            }
        }
        Device(HUB_) {
            Name(_ADR, 0x001e0000)
            Name(_PRT, Package(0x8) {
                Package(0x4) {
                    0xffff,
                    0x0,
                    LNKA,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x0,
                    LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x1,
                    LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0008ffff,
                    0x0,
                    LNKE,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x0,
                    LNKA,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x1,
                    LNKB,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x2,
                    LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x3,
                    LNKD,
                    0x0,
                },
            })
            Device(SD94) {
                Name(_ADR, 0x0)
            }
            Device(LAN_) {
                Name(_ADR, 0x00080000)
                Name(_PRW, Package(0x2) {
                    0xb,
                    0x3,
                })
            }
        }
        Device(LPC0) {
            Name(_ADR, 0x001f0000)
            OperationRegion(PIRX, PCI_Config, 0x60, 0x4)
            Field(PIRX, ByteAcc, NoLock, Preserve) {
                PIRA,	8,
                PIRB,	8,
                PIRC,	8,
                PIRD,	8
            }
            OperationRegion(PIRY, PCI_Config, 0x68, 0x4)
            Field(PIRY, ByteAcc, NoLock, Preserve) {
                PIRE,	8,
                PIRF,	8,
                PIRG,	8,
                PIRH,	8
            }
            OperationRegion(LPCR, PCI_Config, 0x0, 0xf2)
            Field(LPCR, ByteAcc, NoLock, Preserve) {
                Offset(0xc4),
                MON4,	16,
                MON5,	16
            }
            OperationRegion(GPIO, SystemIO, 0x1180, 0x2c)
            Field(GPIO, ByteAcc, NoLock, Preserve) {
                Offset(0xf),
                ,	1,
                GP25,	1
            }
            OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
            Field(REGS, DWordAcc, NoLock, Preserve) {
                PMBA,	16,
                Offset(0x18),
                GPBA,	16,
                Offset(0xb0),
                ,	5,
                FUND,	2
            }
            Device(MBRD) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x1f)
                Name(RSRC, Buffer(0xd6) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0,=
 0x1, 0x10, 0x47, 0x1, 0x24, 0x0, 0x24, 0x0, 0x1, 0x2, 0x47, 0x1, 0x28, 0=
x0, 0x28, 0x0, 0x1, 0x2, 0x47, 0x1, 0x2c, 0x0, 0x2c, 0x0, 0x1, 0x2, 0x47,=
 0x1, 0x30, 0x0, 0x30, 0x0, 0x1, 0x2, 0x47, 0x1, 0x34, 0x0, 0x34, 0x0, 0x=
1, 0x2, 0x47, 0x1, 0x38, 0x0, 0x38, 0x0, 0x1, 0x2, 0x47, 0x1, 0x3c, 0x0, =
0x3c, 0x0, 0x1, 0x2, 0x47, 0x1, 0x50, 0x0, 0x50, 0x0, 0x1, 0x4, 0x47, 0x1=
, 0x72, 0x0, 0x72, 0x0, 0x1, 0x6, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0=
x1, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0, 0x1, 0x10, 0x47, 0x1, 0xa4, 0x0, 0xa=
4, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa8, 0x0, 0xa8, 0x0, 0x1, 0x2, 0x47, 0x1, 0=
xac, 0x0, 0xac, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x6,=
 0x47, 0x1, 0xb8, 0x0, 0xb8, 0x0, 0x1, 0x2, 0x47, 0x1, 0xbc, 0x0, 0xbc, 0=
x0, 0x1, 0x2, 0x47, 0x1, 0x0, 0x10, 0x0, 0x10, 0x1, 0x80, 0x47, 0x1, 0x80=
, 0x11, 0x80, 0x11, 0x1, 0x40, 0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2,=
 0x47, 0x1, 0x4e, 0x0, 0x4e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x0, 0x6, 0x0, 0x6=
, 0x1, 0x10, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0x0, 0=
x0, 0x0, 0x0, 0x1, 0x2, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x80, 0xff, 0x0, 0=
x0, 0x80, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateWordField(RSRC, 0x92, PMMN)
                    CreateWordField(RSRC, 0x94, PMMX)
                    CreateWordField(RSRC, 0x9a, GPMN)
                    CreateWordField(RSRC, 0x9c, GPMX)
                    CreateWordField(RSRC, 0xc2, PHMN)
                    CreateWordField(RSRC, 0xc4, PHMX)
                    And(^^PMBA, 0xff80, PMMN)
                    Store(PMMN, PMMX)
                    And(^^GPBA, 0xff80, GPMN)
                    Store(GPMN, GPMX)
                    Store(^^MON4, PHMN)
                    Store(PHMN, PHMX)
                    Return(RSRC)
                }
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(DMAC) {
                Name(_HID, 0x0002d041)
                Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0=
x1, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x1, 0xf, 0x47, 0x1, 0xc0, 0x0=
, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x2, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(MATH) {
                Name(_HID, 0x040cd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, =
0x1, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(PIC_) {
                Name(_HID, 0xd041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0,=
 0x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x22, 0x4, 0x0, 0x7=
9, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(RTC_) {
                Name(_HID, 0x000bd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, =
0x1, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(SPKR) {
                Name(_HID, 0x0008d041)
                Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, =
0x1, 0x1, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(TMR_) {
                Name(_HID, 0x0001d041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, =
0x1, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(KBC_) {
                Name(_HID, 0x0303d041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0,=
 0x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x22, 0x2, 0x0, 0x7=
9, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(MOUE) {
                Name(_HID, 0x130fd041)
                Name(_CRS, Buffer(0x5) {0x22, 0x0, 0x10, 0x79, 0x0 })
            }
            Device(EC0_) {
                Name(_HID, 0x090cd041)
                Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0,=
 0x1, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x1, 0x1, 0x79, 0x0 })
                Name(_GPE, 0x1c)
                Name(ECOK, 0x0)
                Method(_REG, 2) {
                    If(LEqual(Arg0, 0x3)) {
                        Store(Arg1, ECOK)
                    }
                }
                Name(_PRW, Package(0x2) {
                    0x1d,
                    0x5,
                })
                OperationRegion(ECR_, EmbeddedControl, 0x0, 0xff)
                Field(ECR_, AnyAcc, Lock, Preserve) {
                    Offset(0x80),
                    MPBP,	1,
                    MPBD,	1,
                    DOKD,	1,
                    DFBP,	1,
                    Offset(0x81),
                    BT1A,	1,
                    BT2A,	1,
                    ACAT,	1,
                    Offset(0x82),
                    PWRB,	1,
                    JOGB,	1,
                    LIDS,	1,
                    Offset(0x83),
                    BT1P,	1,
                    BT2P,	1,
                    Offset(0x84),
                    B1ST,	8,
                    B2ST,	8,
                    Offset(0x90),
                    MASK,	8,
                    BT1S,	1,
                    BT2S,	1,
                    Offset(0x92),
                    BT1W,	1,
                    BT2W,	1,
                    Offset(0x93),
                    FAN0,	8,
                    CB0S,	1,
                    CB1S,	1,
                    Offset(0x95),
                    PHYO,	1,
                    Offset(0x96),
                    BRIT,	8,
                    CONT,	8,
                    SNDU,	1,
                    SNDD,	1,
                    Offset(0x99),
                    SMDM,	1,
                    Offset(0x9a),
                    Offset(0x9b),
                    SIRQ,	8,
                    SLOB,	8,
                    SHIB,	8,
                    ILED,	1,
                    Offset(0x9f),
                    DUSE,	1,
                    Offset(0xa0),
                    B1RC,	16,
                    B1AB,	16,
                    B1RT,	16,
                    B1VO,	16,
                    B2RC,	16,
                    B2AB,	16,
                    B2RT,	16,
                    B2VO,	16,
                    B1DC,	16,
                    B1LF,	16,
                    B1DV,	16,
                    B1DL,	16,
                    B2DC,	16,
                    B2LF,	16,
                    B2DV,	16,
                    B2DL,	16,
                    A1TP,	16,
                    A1AT,	16,
                    A1PT,	16,
                    A1CT,	16,
                    A2TP,	16,
                    A2AT,	16,
                    A2PT,	16,
                    A2CT,	16
                }
                Method(_Q50) {
                    PHS_(0xa1)
                    Notify(ACAD, 0x80)
                }
                Method(_Q51) {
                    If(BT1A) {
                        Notify(BAT1, 0x0)
                    }
                    Else {
                        Notify(BAT1, 0x1)
                    }
                    Notify(BAT1, 0x80)
                }
                Method(_Q53) {
                    Store("_Q53:Battery Selection", Debug)
                }
                Method(_Q58) {
                    Store("_Q58:ATF temperature trip point changd", Debug=
)
                    Notify(\_TZ_.ATF0, 0x81)
                }
                Method(_Q5F) {
                    Store("_Q5F:ATF temperature reaches trip point", Debu=
g)
                    Notify(\_TZ_.ATF0, 0x80)
                }
                Method(_Q60) {
                    Notify(\_SB_.PWRB, 0x80)
                }
                Method(_Q66) {
                    Notify(\_SB_.LID_, 0x80)
                }
            }
            Device(SPIC) {
                Name(_HID, 0x0160d94d)
                Name(RSRC, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x=
1, 0x20, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Name(SSRC, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x=
1, 0x20, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Name(SIRT, Package(0x4) {
                    0x6,
                    0x9,
                    0xa,
                    0xb,
                })
                Method(_CRS) {
                    CreateByteField(RSRC, 0x2, IOM1)
                    CreateByteField(RSRC, 0x3, IOM2)
                    CreateWordField(RSRC, 0x2, IO1I)
                    CreateWordField(RSRC, 0x4, IO1A)
                    CreateWordField(RSRC, 0x9, IRQV)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        Store(PHSB(0xd4, 0x9c), IOM1)
                        Store(PHSB(0xd4, 0x9d), IOM2)
                    }
                    Else {
                        Store(\_SB_.PCI0.LPC0.EC0_.SLOB, IOM1)
                        Store(\_SB_.PCI0.LPC0.EC0_.SHIB, IOM2)
                    }
                    Store(IO1I, IO1A)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        ShiftRight(PHSB(0xd4, 0x9b), 0x4, Local0)
                    }
                    Else {
                        ShiftRight(\_SB_.PCI0.LPC0.EC0_.SIRQ, 0x4, Local0=
)
                    }
                    FindSetRightBit(Local0, Local1)
                    If(Local1) {
                        Decrement(Local1)
                        Store(DerefOf(Index(SIRT, Local1, )), Local0)
                        ShiftLeft(0x1, Local0, IRQV)
                    }
                    Return(RSRC)
                }
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOA1)
                    CreateByteField(Arg0, 0x3, IOA2)
                    CreateWordField(Arg0, 0x9, IRQV)
                    FindSetRightBit(IRQV, Local0)
                    If(Local0) {
                        Decrement(Local0)
                        Store(Match(SIRT, MEQ, Local0, MTR, 0x0, 0x0), Lo=
cal1)
                        ShiftLeft(0x10, Local1, Local2)
                    }
                    Else {
                        Store(0x0, Local2)
                    }
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSW(0xd5, 0x9b, Local2)
                    }
                    Else {
                        Store(Local2, \_SB_.PCI0.LPC0.EC0_.SIRQ)
                    }
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSW(0xd5, 0x9d, IOA2)
                        PHSW(0xd5, 0x9c, IOA1)
                    }
                    Else {
                        Store(IOA2, \_SB_.PCI0.LPC0.EC0_.SHIB)
                        Store(IOA1, \_SB_.PCI0.LPC0.EC0_.SLOB)
                    }
                    Sleep(0x1)
                }
                Name(_PRS, Buffer(0x2a) {0x30, 0x47, 0x1, 0x80, 0x10, 0x8=
0, 0x10, 0x1, 0x20, 0x30, 0x47, 0x1, 0xa0, 0x10, 0xa0, 0x10, 0x1, 0x20, 0=
x30, 0x47, 0x1, 0xc0, 0x10, 0xc0, 0x10, 0x1, 0x20, 0x30, 0x47, 0x1, 0xe0,=
 0x10, 0xe0, 0x10, 0x1, 0x20, 0x38, 0x22, 0x40, 0xe, 0x79, 0x0 })
                Method(_DIS) {
                    Store(_CRS(), SSRC)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSW(0xd5, 0x9b, 0x0)
                        PHSW(0xd5, 0x9d, 0x0)
                        PHSW(0xd5, 0x9c, 0x0)
                    }
                    Else {
                        Store(0x0, \_SB_.PCI0.LPC0.EC0_.SIRQ)
                        Store(0x0, \_SB_.PCI0.LPC0.EC0_.SHIB)
                        Store(0x0, \_SB_.PCI0.LPC0.EC0_.SLOB)
                    }
                    Sleep(0x1)
                }
                Method(_STA) {
                    If(LEqual(CKOS(), 0x0)) {
                        If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                            ShiftRight(PHSB(0xd4, 0x9b), 0x4, Local0)
                        }
                        Else {
                            ShiftRight(\_SB_.PCI0.LPC0.EC0_.SIRQ, 0x4, Lo=
cal0)
                        }
                        FindSetRightBit(Local0, Local1)
                        If(Local1) {
                            Return(0xf)
                        }
                        Else {
                            Return(0xd)
                        }
                    }
                    Else {
                        Return(0xf)
                    }
                }
            }
            Device(SNC_) {
                Name(_HID, 0x0150d94d)
                Method(GPID) {
                    Return(PHSB(0xc0, 0x0))
                }
                Method(GBRT) {
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        Store(PHSD(0xd4, 0x96), Local0)
                    }
                    Else {
                        Store(\_SB_.PCI0.LPC0.EC0_.BRIT, Local0)
                    }
                    Return(PHSB(0xcf, Local0))
                }
                Method(SBRT, 1) {
                    Store(PHSB(0xcd, Arg0), Local0)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSB(0xc3, Local0)
                    }
                    Else {
                        Store(Local0, \_SB_.PCI0.LPC0.EC0_.BRIT)
                    }
                    Return(Zero)
                }
                Method(GPBR) {
                    Return(PHSB(0xc1, 0x0))
                }
                Method(SPBR, 1) {
                    PHSB(0xc2, Arg0)
                    Return(Zero)
                }
                Method(GCTR) {
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        Store(PHSD(0xd4, 0x97), Local0)
                    }
                    Else {
                        Store(\_SB_.PCI0.LPC0.EC0_.CONT, Local0)
                    }
                    Return(PHSB(0xd0, Local0))
                }
                Method(SCTR, 1) {
                    Store(PHSB(0xce, Arg0), Local0)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSB(0xc6, Local0)
                    }
                    Else {
                        Store(Local0, \_SB_.PCI0.LPC0.EC0_.CONT)
                    }
                    Return(Zero)
                }
                Method(GPCR) {
                    Return(PHSB(0xc4, 0x0))
                }
                Method(SPCR, 1) {
                    PHSB(0xc5, Arg0)
                    Return(Zero)
                }
                Method(HK_0) {
                    Notify(\_SB_.PCI0.GCH0, 0x0)
                }
                Method(HK80) {
                    Notify(\_SB_.PCI0.GCH0, 0x80)
                }
                Method(HK81) {
                    Notify(\_SB_.PCI0.GCH0, 0x81)
                }
                Method(HKF7) {
                    Store(0x1, \_SB_.PCI0.GCH0.FNF7)
                    Store(0x0, \_SB_.PCI0.GCH0.FNF8)
                    Notify(\_SB_.PCI0.GCH0, 0x80)
                }
                Method(HKF8) {
                    Store(0x0, \_SB_.PCI0.GCH0.FNF7)
                    Store(0x1, \_SB_.PCI0.GCH0.FNF8)
                    Notify(\_SB_.PCI0.GCH0, 0x80)
                }
                Method(SXF7) {
                    Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                    Store(\_SB_.PCI0.GCH0.SXCD(), Local1)
                    If(LEqual(LAnd(Local1, Local0), 0x0)) {
                        Return(0x0)
                    }
                    Else {
                        And(Local0, Local1, Local2)
                        Store(And(Local0, DerefOf(Index(\_SB_.PCI0.GCH0.T=
BF7, Local2, )), ), Local2)
                        Return(\_SB_.PCI0.GCH0.SXSD(Local2))
                    }
                }
                Method(SXF8) {
                    Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                    Store(\_SB_.PCI0.GCH0.SXCD(), Local1)
                    If(LEqual(LAnd(Local1, Local0), 0x0)) {
                        Return(0x0)
                    }
                    Else {
                        And(Local0, Local1, Local2)
                        Store(DerefOf(Index(\_SB_.PCI0.GCH0.TBF8, Local2,=
 )), Local2)
                        Return(\_SB_.PCI0.GCH0.SXSD(Local2))
                    }
                }
                Method(SLVT) {
                    Store(Zero, \_SB_.PCI0.GCH0.DODF)
                    If(LOr(LEqual(CKOS(), 0x1), LEqual(CKOS(), 0x2))) {
                        Return(SXF7())
                    }
                    Else {
                        Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                        If(LNot(LEqual(\_SB_.PCI0.GCH0.PDOD, Local0))) {
                            Store(" Call _DOD to re-enumerate ", Debug)
                            Notify(\_SB_.PCI0.GCH0, 0x0)
                            Sleep(0x01f4)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x0)) {
                            HKF7()
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x1)) {
                            SXF7()
                            Notify(\_SB_.PCI0.GCH0, 0x81)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x2)) {
                            Noop
                        }
                    }
                    Return(0x0)
                }
                Method(SLTT) {
                    If(LOr(LEqual(CKOS(), 0x1), LEqual(CKOS(), 0x2))) {
                        Return(SXF8())
                    }
                    Else {
                        Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                        If(LNot(LEqual(\_SB_.PCI0.GCH0.PDOD, Local0))) {
                            Store(" Call _DOD to re-enumerate ", Debug)
                            Notify(\_SB_.PCI0.GCH0, 0x0)
                            Sleep(0x01f4)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x0)) {
                            HKF8()
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x1)) {
                            SXF7()
                            Notify(\_SB_.PCI0.GCH0, 0x81)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x2)) {
                            Noop
                        }
                    }
                    Return(0x0)
                }
                Method(SEVF) {
                    Return(PHSB(0xc9, 0x0))
                }
                Method(GCMI, 1) {
                    Return(PHSD(0xca, Arg0))
                }
                Method(SCMI, 1) {
                    Return(PHSD(0xcb, Arg0))
                }
                Method(PWAK) {
                    Return(Zero)
                }
                Method(PWRN) {
                    Notify(\_SB_.PWRB, 0x80)
                }
                Method(CSXB, 1) {
                    Acquire(MPHS, 0xffff)
                    Store(Arg0, SXBF)
                    PHS0(0xcc)
                    Store(SXBF, Local0)
                    Release(MPHS)
                    Return(Local0)
                }
            }
        }
        Device(IDE0) {
            Name(_ADR, 0x001f0001)
            OperationRegion(IDEC, PCI_Config, 0x40, 0x18)
            Field(IDEC, DWordAcc, NoLock, Preserve) {
                PRIT,	16,
                SECT,	16,
                PSIT,	4,
                SSIT,	4,
                Offset(0x8),
                PDMA,	2,
                SDMA,	2,
                Offset(0xa),
                SDT0,	2,
                ,	2,
                SDT1,	2,
                Offset(0xb),
                SDT2,	2,
                ,	2,
                SDT3,	2,
                Offset(0x14),
                ICR0,	4,
                ICR1,	4,
                ICR2,	4,
                ICR3,	4,
                ICR4,	4,
                ICR5,	4
            }
            Method(GETP, 1) {
                If(LEqual(And(Arg0, 0x9, ), 0x0)) {
                    Return(0xffffffff)
                }
                If(LEqual(And(Arg0, 0x9, ), 0x8)) {
                    Return(0x0384)
                }
                ShiftRight(And(Arg0, 0x0300, ), 0x8, Local0)
                ShiftRight(And(Arg0, 0x3000, ), 0xc, Local1)
                Return(Multiply(0x1e, Subtract(0x9, Add(Local0, Local1, )=
, ), ))
            }
            Method(GETD, 4) {
                If(Arg0) {
                    If(Arg1) {
                        Return(0x14)
                    }
                    If(Arg2) {
                        Return(Multiply(Subtract(0x4, Arg3, ), 0xf, ))
                    }
                    Return(Multiply(Subtract(0x4, Arg3, ), 0x1e, ))
                }
                Return(0xffffffff)
            }
            Method(GETF, 2) {
                Name(TMPF, 0x0)
                If(And(Arg0, 0x1, )) {
                    Or(TMPF, 0x1, TMPF)
                }
                If(And(Arg1, 0x2, )) {
                    Or(TMPF, 0x2, TMPF)
                }
                If(And(Arg1, 0x4000, )) {
                    Or(TMPF, 0x10, TMPF)
                }
                Return(TMPF)
            }
            Method(SETP, 3) {
                If(LNot(LLess(Arg0, 0xf0))) {
                    Return(0x8)
                }
                Else {
                    If(And(Arg1, 0x2, )) {
                        If(LAnd(LNot(LGreater(Arg0, 0x78)), And(Arg2, 0x2=
, ))) {
                            Return(0x2301)
                        }
                        If(LAnd(LNot(LGreater(Arg0, 0xb4)), And(Arg2, 0x1=
, ))) {
                            Return(0x2101)
                        }
                    }
                    Return(0x1001)
                }
            }
            Method(SETD, 1) {
                If(LLess(Arg0, 0x1e)) {
                    Return(0x1)
                }
                If(LLess(Arg0, 0x2d)) {
                    Return(0x2)
                }
                If(LLess(Arg0, 0x3c)) {
                    Return(0x1)
                }
                If(LLess(Arg0, 0x5a)) {
                    Return(0x2)
                }
                If(LLess(Arg0, 0x78)) {
                    Return(0x1)
                }
                Return(0x0)
            }
            Device(PRIM) {
                Name(_ADR, 0x0)
                Method(_GTM) {
                    Name(PBUF, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })=

                    CreateDWordField(PBUF, 0x0, PIO0)
                    CreateDWordField(PBUF, 0x4, DMA0)
                    CreateDWordField(PBUF, 0x8, PIO1)
                    CreateDWordField(PBUF, 0xc, DMA1)
                    CreateDWordField(PBUF, 0x10, FLAG)
                    Store(GETP(PRIT), PIO0)
                    Store(GETD(And(PDMA, 0x1, ), And(ICR3, 0x1, ), And(IC=
R0, 0x1, ), SDT0), DMA0)
                    If(LEqual(DMA0, 0xffffffff)) {
                        Store(PIO0, DMA0)
                    }
                    Store(0xffffffff, PIO1)
                    Store(PIO1, DMA1)
                    Store(GETF(PDMA, PRIT), FLAG)
                    Return(PBUF)
                }
                Method(_STM, 3) {
                    CreateDWordField(Arg0, 0x0, PIO0)
                    CreateDWordField(Arg0, 0x4, DMA0)
                    CreateDWordField(Arg0, 0x8, PIO1)
                    CreateDWordField(Arg0, 0xc, DMA1)
                    CreateDWordField(Arg0, 0x10, FLAG)
                    Store(0x0, PRIT)
                    Store(0x0, PSIT)
                    Store(0x0, PDMA)
                    Store(0x0, SDT0)
                    Store(0x0, SDT1)
                    And(ICR0, 0xc, ICR0)
                    And(ICR1, 0xc, ICR1)
                    Store(0x4, ICR2)
                    And(ICR3, 0xc, ICR3)
                    And(ICR5, 0xc, ICR5)
                    If(LEqual(SizeOf(Arg1), 0x0200)) {
                        CreateWordField(Arg1, 0x62, W490)
                        CreateWordField(Arg1, 0x6a, W530)
                        CreateWordField(Arg1, 0x80, W640)
                        CreateWordField(Arg1, 0xb0, W880)
                        Or(PRIT, 0x8004, PRIT)
                        If(LAnd(And(FLAG, 0x2, ), And(W490, 0x0800, ))) {=

                            Or(PRIT, 0x2, PRIT)
                        }
                        Or(PRIT, SETP(PIO0, W530, W640), PRIT)
                        If(And(FLAG, 0x1, )) {
                            Or(PDMA, 0x1, PDMA)
                            Store(SETD(DMA0), SDT0)
                            If(And(W880, 0x20, )) {
                                Or(ICR5, 0x1, ICR5)
                            }
                            If(And(W880, 0x10, )) {
                                Or(ICR1, 0x1, ICR1)
                            }
                            If(LLess(DMA0, 0x1e)) {
                                Or(ICR3, 0x1, ICR3)
                            }
                            If(LLess(DMA0, 0x3c)) {
                                Or(ICR0, 0x1, ICR0)
                            }
                        }
                    }
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Name(PIB0, Buffer(0xe) {0x3, 0x0, 0x0, 0x0, 0x0, =
0xa0, 0xef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef })
                        CreateByteField(PIB0, 0x1, PMD0)
                        CreateByteField(PIB0, 0x8, DMD0)
                        If(And(PRIT, 0x2, )) {
                            If(LEqual(And(PRIT, 0x9, ), 0x8)) {
                                Store(0x8, PMD0)
                            }
                            Else {
                                Store(0xa, PMD0)
                                ShiftRight(And(PRIT, 0x0300, ), 0x8, Loca=
l0)
                                ShiftRight(And(PRIT, 0x3000, ), 0xc, Loca=
l1)
                                Add(Local0, Local1, Local2)
                                If(LEqual(0x3, Local2)) {
                                    Store(0xb, PMD0)
                                }
                                If(LEqual(0x5, Local2)) {
                                    Store(0xc, PMD0)
                                }
                            }
                        }
                        Else {
                            Store(0x1, PMD0)
                        }
                        If(And(PDMA, 0x1, )) {
                            Store(Or(SDT0, 0x40, ), DMD0)
                            If(And(ICR0, 0x1, )) {
                                Add(DMD0, 0x2, DMD0)
                            }
                            If(And(ICR3, 0x1, )) {
                                Store(0x45, DMD0)
                            }
                        }
                        Else {
                            Or(Subtract(And(PMD0, 0x7, ), 0x2, ), 0x20, D=
MD0)
                        }
                        Return(PIB0)
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                }
                Method(_PS0) {
                }
                Method(_PS3) {
                }
            }
            Device(SCND) {
                Name(_ADR, 0x1)
                Method(_GTM) {
                    Name(SBUF, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })=

                    CreateDWordField(SBUF, 0x0, PIO0)
                    CreateDWordField(SBUF, 0x4, DMA0)
                    CreateDWordField(SBUF, 0x8, PIO1)
                    CreateDWordField(SBUF, 0xc, DMA1)
                    CreateDWordField(SBUF, 0x10, FLAG)
                    Store(GETP(SECT), PIO0)
                    Store(GETD(And(SDMA, 0x1, ), And(ICR3, 0x4, ), And(IC=
R0, 0x4, ), SDT2), DMA0)
                    If(LEqual(DMA0, 0xffffffff)) {
                        Store(PIO0, DMA0)
                    }
                    Store(0xffffffff, PIO1)
                    Store(PIO1, DMA1)
                    Store(GETF(SDMA, SECT), FLAG)
                    Return(SBUF)
                }
                Method(_STM, 3) {
                    CreateDWordField(Arg0, 0x0, PIO0)
                    CreateDWordField(Arg0, 0x4, DMA0)
                    CreateDWordField(Arg0, 0x8, PIO1)
                    CreateDWordField(Arg0, 0xc, DMA1)
                    CreateDWordField(Arg0, 0x10, FLAG)
                    Store(0x0, SECT)
                    Store(0x0, SSIT)
                    Store(0x0, SDMA)
                    Store(0x0, SDT2)
                    Store(0x0, SDT3)
                    And(ICR0, 0x3, ICR0)
                    And(ICR1, 0x3, ICR1)
                    Store(0x4, ICR2)
                    And(ICR3, 0x3, ICR3)
                    And(ICR5, 0x3, ICR5)
                    If(LEqual(SizeOf(Arg1), 0x0200)) {
                        CreateWordField(Arg1, 0x62, W490)
                        CreateWordField(Arg1, 0x6a, W530)
                        CreateWordField(Arg1, 0x80, W640)
                        CreateWordField(Arg1, 0xb0, W880)
                        Or(SECT, 0x8004, SECT)
                        If(LAnd(And(FLAG, 0x2, ), And(W490, 0x0800, ))) {=

                            Or(SECT, 0x2, SECT)
                        }
                        Or(SECT, SETP(PIO0, W530, W640), SECT)
                        If(And(FLAG, 0x1, )) {
                            Or(SDMA, 0x1, SDMA)
                            Store(SETD(DMA0), SDT2)
                            If(And(W880, 0x20, )) {
                                Or(ICR5, 0x4, ICR5)
                            }
                            If(And(W880, 0x10, )) {
                                Or(ICR1, 0x4, ICR1)
                            }
                            If(LLess(DMA0, 0x1e)) {
                                Or(ICR3, 0x4, ICR3)
                            }
                            If(LLess(DMA0, 0x3c)) {
                                Or(ICR0, 0x4, ICR0)
                            }
                        }
                    }
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Name(SIB0, Buffer(0xe) {0x3, 0x0, 0x0, 0x0, 0x0, =
0xa0, 0xef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef })
                        CreateByteField(SIB0, 0x1, PMD0)
                        CreateByteField(SIB0, 0x8, DMD0)
                        If(And(SECT, 0x2, )) {
                            If(LEqual(And(SECT, 0x9, ), 0x8)) {
                                Store(0x8, PMD0)
                            }
                            Else {
                                Store(0xa, PMD0)
                                ShiftRight(And(SECT, 0x0300, ), 0x8, Loca=
l0)
                                ShiftRight(And(SECT, 0x3000, ), 0xc, Loca=
l1)
                                Add(Local0, Local1, Local2)
                                If(LEqual(0x3, Local2)) {
                                    Store(0xb, PMD0)
                                }
                                If(LEqual(0x5, Local2)) {
                                    Store(0xc, PMD0)
                                }
                            }
                        }
                        Else {
                            Store(0x1, PMD0)
                        }
                        If(And(SDMA, 0x1, )) {
                            Store(Or(SDT2, 0x40, ), DMD0)
                            If(And(ICR0, 0x4, )) {
                                Add(DMD0, 0x2, DMD0)
                            }
                            If(And(ICR3, 0x4, )) {
                                Store(0x45, DMD0)
                            }
                        }
                        Else {
                            Or(Subtract(And(PMD0, 0x7, ), 0x2, ), 0x20, D=
MD0)
                        }
                        Return(SIB0)
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                }
                Method(_PS0) {
                }
                Method(_PS3) {
                }
            }
        }
        Device(USB1) {
            Name(_ADR, 0x001f0002)
            OperationRegion(USB1, PCI_Config, 0xc4, 0x4)
            Field(USB1, DWordAcc, NoLock, Preserve) {
                RSEN,	2
            }
            Name(_PRW, Package(0x2) {
                0x3,
                0x3,
            })
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x3, RSEN)
                }
                Else {
                    Store(0x0, RSEN)
                }
            }
            Method(_PS0) {
                Store(One, ^^LPC0.GP25)
            }
            Method(_PS3) {
                If(LNot(LOr(RSEN, \_SB_.PCI0.USB2.RSEN))) {
                    Store(Zero, ^^LPC0.GP25)
                }
                Else {
                    Store(One, ^^LPC0.GP25)
                }
            }
        }
        Device(USB2) {
            Name(_ADR, 0x001f0004)
            OperationRegion(USB2, PCI_Config, 0xc4, 0x4)
            Field(USB2, DWordAcc, NoLock, Preserve) {
                RSEN,	2
            }
            Name(_PRW, Package(0x2) {
                0x4,
                0x3,
            })
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x3, RSEN)
                }
                Else {
                    Store(0x0, RSEN)
                }
            }
            Method(_PS0) {
                Store(One, ^^LPC0.GP25)
            }
            Method(_PS3) {
                If(LNot(LOr(RSEN, \_SB_.PCI0.USB1.RSEN))) {
                    Store(Zero, ^^LPC0.GP25)
                }
                Else {
                    Store(One, ^^LPC0.GP25)
                }
            }
        }
        Device(SMBC) {
            Name(_ADR, 0x001f0003)
        }
        Device(AUDI) {
            Name(_ADR, 0x001f0005)
        }
        Device(MODE) {
            Name(_ADR, 0x001f0006)
            Name(_PRW, Package(0x2) {
                0x5,
                0x3,
            })
        }
        Scope(\_SB_.PCI0.HUB_) {
            Device(CRD0) {
                Name(_ADR, 0x00020000)
                OperationRegion(CCRD, PCI_Config, 0x0, 0xe4)
                Field(CCRD, DWordAcc, NoLock, Preserve) {
                    Offset(0x4),
                    CD04,	32,
                    Offset(0x3e),
                    CD3E,	32,
                    Offset(0x44),
                    CD44,	32,
                    Offset(0xe0),
                    CDE0,	8,
                    CDE1,	8
                }
                OperationRegion(EXCA, SystemIO, 0x03e0, 0x2)
                Field(EXCA, ByteAcc, NoLock, Preserve) {
                    INDX,	8,
                    DATA,	8
                }
                IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                    Offset(0x3),
                    ,	7,
                    ERIB,	1
                }
                Method(_INI) {
                    If(LEqual(CKOS(), 0x1)) {
                        Store(Zero, CDE0)
                        Store(Zero, CD04)
                        Store(Zero, CD3E)
                        Store(Zero, CD44)
                    }
                    Else {
                        Store(0x0, CDE1)
                    }
                }
                Name(_PSC, 0x0)
                Method(PSX_, 1) {
                    Store(0x0, CDE0)
                    Store(0x03e0, CD44)
                    Store(One, ERIB)
                    Store(0x0, CD44)
                    Store(Arg0, CDE0)
                    Store(Arg0, _PSC)
                }
                Method(_PS0) {
                    Store(0x0, CDE1)
                    Store(0x0, _PSC)
                }
                Method(_PS1) {
                    PSX_(0x1)
                    Or(CDE1, 0x1, CDE1)
                }
                Method(_PS2) {
                    PSX_(0x2)
                    Or(CDE1, 0x1, CDE1)
                }
                Method(_PS3) {
                    PSX_(0x3)
                    Or(CDE1, 0x1, CDE1)
                }
                Method(_STA) {
                    Return(0xf)
                }
                Name(_PRW, Package(0x2) {
                    0xb,
                    0x3,
                })
            }
        }
        Scope(\_SB_.PCI0.LPC0) {
            Mutex(SLOK, 0)
            OperationRegion(SMC1, SystemIO, 0x2e, 0x2)
            Field(SMC1, ByteAcc, NoLock, Preserve) {
                INDX,	8,
                DATA,	8
            }
            IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                CR00,	8,
                CR01,	8,
                CR02,	8,
                Offset(0x5),
                CR05,	8,
                Offset(0x7),
                CR07,	8,
                Offset(0x23),
                CR23,	8,
                Offset(0x26),
                PPDM,	4,
                Offset(0x27),
                PPIR,	4,
                Offset(0x30),
                RRBA,	8,
                Offset(0x33),
                DIR2,	8,
                POL2,	8
            }
            OperationRegion(RRBL, SystemIO, 0x060d, 0x3)
            Field(RRBL, ByteAcc, NoLock, Preserve) {
                GP20,	1,
                ,	22,
                GP47,	1
            }
            Method(ENCF) {
                Store(0x55, INDX)
            }
            Method(EXCF) {
                Store(0xaa, INDX)
            }
            Device(COMA) {
                Name(_HID, 0x0105d041)
                Name(MCD_, 0x12)
                Name(_EJD, "_SB.DOCK")
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.COMA._STA()) {
                        Acquire(SLOK, 0xffff)
                        Store(PSCS(0x12), Local0)
                        Release(SLOK)
                        Return(Local0)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(_SRS, 1) {
                    Acquire(SLOK, 0xffff)
                    PSSS(0x12, Arg0)
                    Release(SLOK)
                }
                Method(_PRS) {
                    Acquire(SLOK, 0xffff)
                    Store(PSPS(0x12), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Method(_DIS) {
                    Acquire(SLOK, 0xffff)
                    PSDI(0x12)
                    Release(SLOK)
                }
                Method(_STA) {
                    Acquire(SLOK, 0xffff)
                    Store(PSST(0x12), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Store(0x1, GP47)
                    Sleep(0x1)
                    Or(CR02, 0x8, CR02)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    Store(0x0, GP47)
                    And(CR02, 0xf7, CR02)
                    Store(0x3, _PSC)
                    EXCF()
                }
                Name(_PRW, Package(0x2) {
                    0x8,
                    0x3,
                })
            }
            Device(LPTA) {
                Name(_HID, 0x0004d041)
                Name(_UID, 0x1)
                Name(MCD_, 0x14)
                Name(_EJD, "_SB.DOCK")
                Name(CRSB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x=
1, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.LPTA._STA()) {
                        CreateWordField(CRSB, 0x2, IO1B)
                        CreateWordField(CRSB, 0x4, IO2B)
                        CreateByteField(CRSB, 0x7, IO3B)
                        CreateWordField(CRSB, 0x9, IRQB)
                        Acquire(SLOK, 0xffff)
                        ENCF()
                        ShiftLeft(CR23, 0x2, IO1B)
                        Store(IO1B, IO2B)
                        Store(Zero, IRQB)
                        If(PPIR) {
                            ShiftLeft(0x1, PPIR, IRQB)
                        }
                        If(LEqual(IO1B, 0x03bc)) {
                            Store(0x3, IO3B)
                        }
                        EXCF()
                        Release(SLOK)
                        Return(CRSB)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(B_SR, 1) {
                    CreateWordField(Arg0, 0x2, IO1S)
                    CreateWordField(Arg0, 0x9, IRQS)
                    Acquire(SLOK, 0xffff)
                    ENCF()
                    ShiftRight(IO1S, 0x2, CR23)
                    FindSetRightBit(IRQS, Local0)
                    If(Local0) {
                        Decrement(Local0)
                    }
                    Store(Local0, PPIR)
                    EXCF()
                    Release(SLOK)
                }
                Method(B_PR) {
                    Return(PSPS(0x14))
                }
                Method(B_DI) {
                    PSDI(0x14)
                }
                Method(_STA) {
                    Return(PSST(0x14))
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Or(CR01, 0x4, CR01)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR01, 0xfb, CR01)
                    Store(0x3, _PSC)
                    EXCF()
                }
            }
            Device(LPTB) {
                Name(_HID, 0x0004d041)
                Name(_UID, 0x2)
                Name(MCD_, 0x15)
                Name(_EJD, "_SB.DOCK")
                Name(CRSB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x=
1, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.LPTB._STA()) {
                        CreateWordField(CRSB, 0x2, IO1B)
                        CreateWordField(CRSB, 0x4, IO2B)
                        CreateByteField(CRSB, 0x7, IO3B)
                        CreateWordField(CRSB, 0x9, IRQB)
                        Acquire(SLOK, 0xffff)
                        ENCF()
                        ShiftLeft(CR23, 0x2, IO1B)
                        Store(IO1B, IO2B)
                        Store(Zero, IRQB)
                        If(PPIR) {
                            ShiftLeft(0x1, PPIR, IRQB)
                        }
                        If(LEqual(IO1B, 0x03bc)) {
                            Store(0x3, IO3B)
                        }
                        EXCF()
                        Release(SLOK)
                        Return(CRSB)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(B_SR, 1) {
                    CreateWordField(Arg0, 0x2, IO1S)
                    CreateWordField(Arg0, 0x9, IRQS)
                    Acquire(SLOK, 0xffff)
                    ENCF()
                    ShiftRight(IO1S, 0x2, CR23)
                    FindSetRightBit(IRQS, Local0)
                    If(Local0) {
                        Decrement(Local0)
                    }
                    Store(Local0, PPIR)
                    EXCF()
                    Release(SLOK)
                }
                Method(B_PR) {
                    Return(PSPS(0x15))
                }
                Method(B_DI) {
                    PSDI(0x15)
                }
                Method(_STA) {
                    Return(PSST(0x15))
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Or(CR01, 0x4, CR01)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR01, 0xfb, CR01)
                    Store(0x3, _PSC)
                    EXCF()
                }
            }
            Device(ECP_) {
                Name(_HID, 0x0104d041)
                Name(MCD_, 0x13)
                Name(_EJD, "_SB.DOCK")
                Name(CRSA, Buffer(0x18) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0=
x1, 0x8, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8, 0x22, 0x0, 0x0, 0x2a, 0=
x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.ECP_._STA()) {
                        CreateWordField(CRSA, 0x2, IO1A)
                        CreateWordField(CRSA, 0x4, IO2A)
                        CreateByteField(CRSA, 0x7, IO3A)
                        CreateWordField(CRSA, 0xa, IO4A)
                        CreateWordField(CRSA, 0xc, IO5A)
                        CreateByteField(CRSA, 0xf, IO6A)
                        CreateWordField(CRSA, 0x11, IRQA)
                        CreateByteField(CRSA, 0x14, DMAA)
                        Acquire(SLOK, 0xffff)
                        ENCF()
                        ShiftLeft(CR23, 0x2, IO1A)
                        Store(IO1A, IO2A)
                        Add(IO1A, 0x0400, IO4A)
                        Store(IO4A, IO5A)
                        Store(Zero, IRQA)
                        If(PPIR) {
                            ShiftLeft(0x1, PPIR, IRQA)
                        }
                        If(LEqual(IO1A, 0x03bc)) {
                            Store(0x3, IO3A)
                            Store(IO3A, IO6A)
                        }
                        ShiftLeft(0x1, PPDM, DMAA)
                        EXCF()
                        Release(SLOK)
                        Return(CRSA)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(_SRS, 1) {
                    CreateWordField(Arg0, 0x2, IO1S)
                    CreateWordField(Arg0, 0x11, IRQS)
                    CreateByteField(Arg0, 0x14, DMAS)
                    Acquire(SLOK, 0xffff)
                    ENCF()
                    ShiftRight(IO1S, 0x2, CR23)
                    FindSetRightBit(IRQS, Local0)
                    If(Local0) {
                        Decrement(Local0)
                    }
                    Store(Local0, PPIR)
                    FindSetRightBit(DMAS, Local1)
                    Decrement(Local1)
                    Store(Local1, PPDM)
                    EXCF()
                    Release(SLOK)
                }
                Method(_PRS) {
                    Return(PSPS(0x13))
                }
                Method(_DIS) {
                    PSDI(0x13)
                }
                Method(_STA) {
                    Return(PSST(0x13))
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Or(CR01, 0x4, CR01)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR01, 0xfb, CR01)
                    Store(0x3, _PSC)
                    EXCF()
                }
            }
            Device(FDC_) {
                Name(_HID, 0x0007d041)
                Name(MCD_, 0x11)
                Name(ARM_, Zero)
                Method(_CRS) {
                    Acquire(SLOK, 0xffff)
                    Store(PSCS(0x11), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Method(B_SR, 1) {
                    Acquire(SLOK, 0xffff)
                    PSSS(0x11, Arg0)
                    Release(SLOK)
                }
                Method(B_PR) {
                    Acquire(SLOK, 0xffff)
                    Store(PSPS(0x11), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Method(B_DI) {
                    Acquire(SLOK, 0xffff)
                    PSDI(0x11)
                    Release(SLOK)
                }
                Method(_STA) {
                    Acquire(SLOK, 0xffff)
                    Store(PSST(0x11), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    If(LEqual(PHS_(0xd3), One)) {
                        And(CR05, 0xfd, CR05)
                        Sleep(0x1)
                    }
                    Or(CR00, 0x8, CR00)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR00, 0xf7, CR00)
                    Or(CR05, 0x2, CR05)
                    Store(0x3, _PSC)
                    EXCF()
                }
                Name(FDES, Buffer(0x14) {0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0 })
                Method(_FDE) {
                    Return(FDES)
                }
                Name(FDIB, Package(0x13) {
                    0x0,
                    0x4,
                    0x4f,
                    0x0,
                    0x12,
                    0x0,
                    0x1,
                    0x0,
                    0xdf,
                    0x2,
                    0x37,
                    0x2,
                    0x18,
                    0x1b,
                    0xff,
                    0x6c,
                    0xf6,
                    0x15,
                    0x5,
                })
                Method(_FDI) {
                    Return(FDIB)
                }
                Device(FDD_) {
                    Name(_ADR, 0x0)
                    Name(_EJD, "_SB.DOCK")
                    Method(_STA) {
                        If(LAnd(\_SB_.DOCK.DKFS, LEqual(ARM_, Zero))) {
                            Return(0xf)
                        }
                        Else {
                            Return(0x0)
                        }
                    }
                }
            }
        }
        Scope(\_SB_.PCI0.HUB_.SD94) {
            Name(_EJD, "_SB.DOCK")
        }
        Scope(\_SB_.PCI0.LPC0.EC0_) {
            Method(_Q5A) {
                Store(Zero, \_SB_.PCI0.GCH0.DODF)
                Store(Zero, \_SB_.DOCK.DCRI)
                Notify(\_SB_.DOCK, 0x0)
            }
            Method(_Q5B) {
                Signal(\_SB_.DOCK.UDCK)
                If(LEqual(\_SB_.DOCK.DCRI, Zero)) {
                    \_SB_.DOCK.DULF(0x0)
                    If(LNot(LEqual(CKOS(), 0x1))) {
                        Notify(\_SB_.DOCK, 0x0)
                    }
                }
                Store(Zero, \_SB_.DOCK.DCRI)
            }
            Method(_Q5C) {
                If(LOr(LEqual(CKOS(), 0x1), LEqual(CKOS(), 0x3))) {
                    Notify(\_SB_.DOCK, 0x1)
                }
                Else {
                    Notify(\_SB_.DOCK, 0x3)
                }
            }
        }
    }
}
Scope(\_SI_) {
    Method(_SST, 1) {
        If(LEqual(Arg0, 0x0)) {
        }
        If(LEqual(Arg0, 0x1)) {
        }
        If(LEqual(Arg0, 0x2)) {
        }
        If(LEqual(Arg0, 0x3)) {
        }
        If(LEqual(Arg0, 0x4)) {
        }
    }
}
Method(_WAK, 1) {
    If(LEqual(Arg0, 0x4)) {
        PHS_(0xa3)
    }
    If(LOr(LEqual(Arg0, 0x3), LEqual(Arg0, 0x4))) {
        \_SB_.PCI0.LPC0.SPIC._SRS(\_SB_.PCI0.LPC0.SPIC.SSRC)
        Store(\_SB_.DOCK.GDST(), Local0)
        If(LNot(LEqual(Local0, \_SB_.DOCK.DKST))) {
            Notify(\_SB_.DOCK, 0x0)
        }
    }
    If(PHS_(0xdc)) {
        Notify(\_SB_.PWRB, 0x2)
    }
    Return(Zero)
}
Scope(\_TZ_) {
    ThermalZone(ATF0) {
        Method(KELV, 1) {
            Store(Arg0, Local0)
            Multiply(Local0, 0xa, Local0)
            Add(Local0, 0x0aab, Local0)
            Return(Local0)
        }
        Method(_TMP) {
            ShiftRight(PHSD(0xd4, 0xc0), 0x8, Local0)
            If(LGreater(Local0, 0x80)) {
                Sleep(0x32)
                ShiftRight(PHSD(0xd4, 0xc0), 0x8, Local0)
            }
            Return(KELV(Local0))
        }
        Method(_PSV) {
            ShiftRight(PHSD(0xd4, 0xc4), 0x8, Local0)
            Return(KELV(Local0))
        }
        Name(_PSL, Package(0x1) {
            \_PR_.CPU0,
        })
        Method(_CRT) {
            ShiftRight(PHSD(0xd4, 0xc6), 0x8, Local0)
            Return(KELV(Local0))
        }
        Name(_TC1, 0x1)
        Name(_TC2, 0x2)
        Name(_TSP, 0x32)
    }
}
Scope(_SB_) {
    Name(IRQP, Package(0x10) {
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0200,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
    })
    Device(LNKA) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x1)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRA, 0x80, \_SB_.PCI0.LPC0.PIRA)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRA, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRA, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRA)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRA, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKB) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x2)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRB, 0x80, \_SB_.PCI0.LPC0.PIRB)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRB, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRB, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRB)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRB, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKC) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x3)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRC, 0x80, \_SB_.PCI0.LPC0.PIRC)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRC, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRC, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRC)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRC, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKD) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x4)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRD, 0x80, \_SB_.PCI0.LPC0.PIRD)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRD, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRD, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRD)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRD, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKE) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x5)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRE, 0x80, \_SB_.PCI0.LPC0.PIRE)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRE, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRE, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRE)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRE, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKH) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x8)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRH, 0x80, \_SB_.PCI0.LPC0.PIRH)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRH, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRH, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRH)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRH, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
}
Method(CKOS) {
    Store(SizeOf(_OS_), Local0)
    Name(BUFF, Buffer(Local0) { })
    Name(STRG, Buffer(0x9) { })
    Store(_OS_, BUFF)
    Store("NT E: te", STRG)
    Store(Ones, Local4)
    If(LEqual(Local0, 0x11)) {
        Add(Multiply(DerefOf(Index(BUFF, 0xf, )), 0x0100, ), DerefOf(Inde=
x(BUFF, 0x10, )), Local1)
        Add(Multiply(DerefOf(Index(STRG, 0x6, )), 0x0100, ), DerefOf(Inde=
x(STRG, 0x7, )), Local2)
        If(LEqual(Local1, Local2)) {
            Store(0x2, Local4)
        }
    }
    Else {
        If(LNot(LLess(Local0, 0x14))) {
            Add(Multiply(DerefOf(Index(BUFF, 0x12, )), 0x0100, ), DerefOf=
(Index(BUFF, 0x13, )), Local1)
            Add(Multiply(DerefOf(Index(STRG, 0x0, )), 0x0100, ), DerefOf(=
Index(STRG, 0x1, )), Local2)
            Add(Multiply(DerefOf(Index(STRG, 0x3, )), 0x0100, ), DerefOf(=
Index(STRG, 0x4, )), Local3)
            Add(Multiply(DerefOf(Index(STRG, 0x6, )), 0x0100, ), DerefOf(=
Index(STRG, 0x7, )), Local5)
            If(LEqual(Local1, Local2)) {
                Store(Zero, Local4)
            }
            Else {
                If(LEqual(Local1, Local3)) {
                    Store(One, Local4)
                }
                Else {
                    If(LEqual(Local1, Local5)) {
                        Store(0x3, Local4)
                    }
                }
            }
        }
    }
    Return(Local4)
}
Scope(\_SB_.PCI0.LPC0.EC0_) {
    Device(BAT1) {
        Name(_HID, 0x0a0cd041)
        Name(_UID, 0x1)
        Name(_PCL, Package(0x1) {
            \_SB_,
        })
        Name(BATI, Package(0xd) {
            0x0,
            0x9650,
            0x9650,
            0x0,
            0x39d0,
            0x0,
            0x78,
            0x0,
            0xa,
            "",
            "",
            "LION",
            "Sony Corp.",
        })
        Name(BATS, Package(0x4) {
            0x2,
            0xffffffff,
            0x0d7a,
            0x3840,
        })
        Method(_STA) {
            And(PHSD(0xd4, 0x80), 0x0100, Local1)
            If(Local1) {
                Store(0x1f, Local0)
            }
            Else {
                Store(0xf, Local0)
            }
            Return(Local0)
        }
        Method(_BIF) {
            Store(PHSD(0xd4, 0xb0), Local1)
            Multiply(Local1, 0xa, Index(BATI, 0x1, ))
            Store(PHSD(0xd4, 0xb2), Local1)
            Multiply(Local1, 0xa, Index(BATI, 0x2, ))
            Store(PHSD(0xd4, 0xb6), Index(BATI, 0x4, ))
            Return(BATI)
        }
        Method(_BST) {
            Store(And(PHSD(0xd4, 0x84), 0xff, Local0), Index(BATS, 0x0, )=
)
            Store(PHSD(0xd4, 0xa6), Local0)
            Store(PHSD(0xd4, 0xa4), Local1)
            If(LEqual(Local1, 0xffff)) {
                Store(0xffffffff, Local1)
            }
            Else {
                If(LNot(LLess(Local1, 0x8000))) {
                    XOr(Local1, 0xffff, Local1)
                    Increment(Local1)
                }
                Multiply(Local0, Local1, Local1)
                Divide(Local1, 0x03e8, , Local1)
            }
            Store(Local1, Index(BATS, 0x1, ))
            Multiply(PHSD(0xd4, 0xa2), 0xa, Index(BATS, 0x2, ))
            Store(Local0, Index(BATS, 0x3, ))
            Return(BATS)
        }
    }
    Device(ACAD) {
        Name(_HID, "ACPI0003")
        Name(_PCL, Package(0x1) {
            \_SB_,
        })
        Method(_PSR) {
            And(PHSD(0xd4, 0x80), 0x0400, Local1)
            If(Local1) {
                Return(One)
            }
            Else {
                Return(Zero)
            }
        }
        Method(_STA) {
            Return(0xf)
        }
    }
}

}
/*
BOOT: Length=3D40, Revision=3D1, Checksum=3D64,
	OEMID=3DSONY, OEM Table ID=3DU1, OEM Revision=3D0x20010626,
	Creator ID=3DPTL, Creator Revision=3D0x1
 */

--==_Exmh_7933893120
Content-Type: text/plain ; name="vaioR505TLK.dsdt"; charset=iso-8859-1
Content-Description: vaioR505TLK.dsdt
Content-Disposition: attachment; filename="vaioR505TLK.dsdt"
Content-Transfer-Encoding: quoted-printable

DSDTaJ=00=00=01}SONY=00=00U1=00=00=00=00=00=00&=06=01 PTL =0B=00=00=01=10=
=12_PR_[=83=0BCPU0=00=10=10=00=00=06=08_S0_=12=06=02
=00
=00=08_S3_=12=06=02
=05
=05=08_S4_=12=06=02
=06
=06=08_S5_=12=06=02
=07
=07=14G
_PTS=01=A0:=93h
=03p\/=05_SB_PCI0LPC0SPIC_CRS\/=05_SB_PCI0LPC0SPICSSRCPHS_
=A0=A0:=93h
=04p\/=05_SB_PCI0LPC0SPIC_CRS\/=05_SB_PCI0LPC0SPICSSRCPHS_
=A2=A0)=91=93h
=03=93h
=04p\/=03_SB_DOCKGDST\/=03_SB_DOCKDKST[=80SMI0=00=0C8=CB=CF=07=0C=15=04=00=
=00[=81=17SMI0=00BCMD=08DID_ INFO=80=00=01[=81
SMI0=00=00(INFB=08[=81
SMI0=00=00(INFD [=81=0FSMI0=00=00(SXBF=80=08=02[=81=12SMI0=00=00(INF1=08I=
NF2=08[=80SMI1=01=0C=00=FE=00=00=0C=02=00=00=00[=81=0BSMI1=00SMIC=08[=01M=
PHS=00=14!PHS0=01phBCMDp=00SMIC=A2=07=93BCMDhp
=00BCMD=14(PHS_	[#MPHS=FF=FFp
=00DID_PHS0hpINFD`['MPHS=A4`=14.PHSD
[#MPHS=FF=FFp
=00DID_piINFDPHS0hpINFD`['MPHS=A4`=144PHSW=0B[#MPHS=FF=FFp
=00DID_piINF1pjINF2PHS0hpINFB`['MPHS=A4`=14.PHSB
[#MPHS=FF=FFp
=00DID_piINFBPHS0hpINFB`['MPHS=A4`=14(PSCS	[#MPHS=FF=FFphDID_PHS0
=00pINFO`['MPHS=A4`=14&PSSS
[#MPHS=FF=FFphDID_piINFOPHS0
=01['MPHS=14(PSPS	[#MPHS=FF=FFphDID_PHS0
=02pINFO`['MPHS=A4`=14 PSDI	[#MPHS=FF=FFphDID_PHS0
=03['MPHS=14(PSST	[#MPHS=FF=FFphDID_PHS0
=04pINFB`['MPHS=A4`=10H=08\_GPE=14=18_L03=00=86\/=03_SB_PCI0USB1
=02=14=18_L04=00=86\/=03_SB_PCI0USB2
=02=14=18_L05=00=86\/=03_SB_PCI0MODE
=02=14=18_L0B=00=86\/=03_SB_PCI0HUB_
=02=14=1C_L1D=00=86\/=04_SB_PCI0LPC0EC0_
=02=10=8E=B2=03_SB_[=82M=05LID_=08_HID=0CA=D0=0C
=14L=04_LID=00=A0'=93\/=05_SB_PCI0LPC0EC0_ECOK
=00{PHSB
=D4
=82
=04`=A1=1Ap\/=05_SB_PCI0LPC0EC0_LIDS`=A4`[=82%PWRB=08_HID=0CA=D0=0C=0C=08=
_PRW=12=06=02
=1D
=05=14	_STA=00=A4
=0F[=82@2DOCK=08_HID=0CA=D0=0C=15=08_UID
=00=08_BDN=0C=FF=FF=FF=FF=08DKST
=00=08DKFS
=00=08DCRI
=00[=02UDCK=14E=05GDST=00=A0'=93\/=05_SB_PCI0LPC0EC0_ECOK
=00{PHSB
=D4
=80
=04`=A1=1Ap\/=05_SB_PCI0LPC0EC0_DOKD`=A0=06=93=00`=A4=00=A1=03=A4=FF=14M=0E=
_STA=00=A0=3D=93\/=05_SB_PCI0LPC0FDC_ARM_=00=A0"=93PHS_
=DD=01p=01\/=05_SB_PCI0LPC0FDC_ARM_pGDSTDKFS=A0O=05DKFS=A0E=05=93\/=05_SB=
_PCI0LPC0FDC_ARM_=00p=01=88\/=05_SB_PCI0LPC0FDC_FDIB
=00=00p=01=88\/=05_SB_PCI0LPC0FDC_FDES
=00=00=A4
=0F=A1>p=00=88\/=05_SB_PCI0LPC0FDC_FDIB
=00=00p=00=88\/=05_SB_PCI0LPC0FDC_FDES
=00=00=A4
=00=14=0C_DCK=01=A4DULFh=140_EJ0=01p=FF\/=04_SB_PCI0GCH0DODFp=01DCRI[%UDC=
K=0B=FF=FF[&UDCK=14A=16DULF=01=A0M=06=93h
=01\/=04_SB_PCI0LPC0ENCF{\/=04_SB_PCI0LPC0CR05
=FD\/=04_SB_PCI0LPC0CR05\/=04_SB_PCI0LPC0EXCFp=00\/=04_SB_PCI0LPC0GP20p=01=
`=A1I
\/=04_SB_PCI0LPC0ENCF}\/=04_SB_PCI0LPC0CR05
=02\/=04_SB_PCI0LPC0CR05\/=04_SB_PCI0LPC0EXCFp=01\/=04_SB_PCI0LPC0GP20=A0=
$=93\/=05_SB_PCI0LPC0EC0_ECOK
=00PHSW
=D5
=9F=00=A1=1Ap=00\/=05_SB_PCI0LPC0EC0_DUSEp=00`=A0$=93\/=05_SB_PCI0LPC0EC0=
_ECOK
=00PHSW
=D5
=9E`=A1=1Ap`\/=05_SB_PCI0LPC0EC0_ILED=A4=01[=82=8Dw=03PCI0=08_HID=0CA=D0
=03=08_ADR
=00=08_BBN
=00=08_PRT=12C=08=08=12=0F=04=0C=FF=FF=01=00
=00LNKA
=00=12=0F=04=0C=FF=FF=01=00
=01LNKB
=00=12=0F=04=0C=FF=FF=01=00
=02LNKC
=00=12=0F=04=0C=FF=FF=01=00
=03LNKD
=00=12=0F=04=0C=FF=FF=02=00
=00LNKA
=00=12=0F=04=0C=FF=FF=1F=00
=01LNKB
=00=12=0F=04=0C=FF=FF=1F=00
=02LNKH
=00=12=0F=04=0C=FF=FF=1F=00
=03LNKD
=00[=80REGS=02
@
=C0[=81A=05REGS=03=00@	DRP0=04DRP1=04=00=08DRP2=04=00=1C=00=07HEN_=01PAM0=
=08PAM1=08PAM2=08PAM3=08PAM4=08PAM5=08PAM6=08=00@=08=00=06UMA_=02=08DMST=12=
&=10
=00
 =

 =

0
@
@
`
=80
=00
=80
=80
=C0=0B=00=01=0B=00=01=0B=00=01=0B=00=02=08RSRC=11L=1B=0B=B7=01=88=0E=00=02=
=0C=00=00=00=00=00=FF=00=00=00=00=01=00=87=18=00=00=0C=03=00=00=00=00=00=00=

=00=FF=FF=0B=00=00=00=00=00=00=00=02=00=00=87=18=00=00=0C=03=00=00=00=00=00=
=00=0C=00=FF?=0C=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=
=00@=0C=00=FF=7F=0C=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=
=00=00=80=0C=00=FF=BF=0C=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=
=00=00=00=00=C0=0C=00=FF=FF=0C=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=
=03=00=00=00=00=00=00
=00=FF?
=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=00@
=00=FF=7F
=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=00=80
=00=FF=BF
=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=00=C0
=00=FF=FF
=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=00=00=0E=00=FF=
?=0E=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=00@=0E=00=FF=
=7F=0E=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=00=80=0E=
=00=FF=BF=0E=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=00=00=
=C0=0E=00=FF=FF=0E=00=00=00=00=00=00@=00=00=00=87=18=00=00=0C=03=00=00=00=
=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00G=01=F8=0C=F8=0C=01=
=08=88=0E=00=01=0C=03=00=00=00=00=F7=0C=00=00=F8=0C=00=88=0E=00=01=0C=03=00=
=00=00
=FF=FF=00=00=00=F3=00y=00=14LP_CRS=08p=00a=8ARSRC=0Bz=01BTMN=8ARSRC=0B~=01=
BTMX=8ARSRC=0B=86=01BTLNpDRP0`pDRP1apDRP2br=83=88DMST`=00=83=88DMSTa=00`r=
=83=88DMSTb=00``w`=0C=00=00=10=00`p`BTMNt=0C=00=00=C0=FE`BTLNtrBTMNBTLN=00=

=01BTMX=8DRSRC=0B=88=01C0RW=8ARSRC
6C0MN=8ARSRC
:C0MX=8ARSRC
BC0LNp=01C0RW=A0=12=93{PAM1
=03=00
=01p=00C0RWp=00C0LN=A0=12=92{PAM1
=03=00p=0B=00@C0LN=8DRSRC=0B`=02C4RW=8ARSRC
QC4MN=8ARSRC
UC4MX=8ARSRC
]C4LNp=01C4RW=A0=12=93{PAM1
0=00
=10p=00C4RWp=00C4LN=A0=12=92{PAM1
0=00p=0B=00@C4LN=8DRSRC=0B8=03C8RW=8ARSRC
lC8MN=8ARSRC
pC8MX=8ARSRC
xC8LNp=01C8RW=A0=12=93{PAM2
=03=00
=01p=00C8RWp=00C8LN=A0=12=92{PAM2
=03=00p=0B=00@C8LN=8DRSRC=0B=10=04CCRW=8ARSRC
=87CCMN=8ARSRC
=8BCCMX=8ARSRC
=93CCLNp=01CCRW=A0=12=93{PAM2
0=00
=10p=00CCRWp=00CCLN=A0=12=92{PAM2
0=00p=0B=00@CCLN=8DRSRC=0B=E8=04D0RW=8ARSRC
=A2D0MN=8ARSRC
=A6D0MX=8ARSRC
=AED0LNp=01D0RW=A0=12=93{PAM3
=03=00
=01p=00D0RWp=00D0LN=A0=12=92{PAM3
=03=00p=0B=00@D0LN=8DRSRC=0B=C0=05D4RW=8ARSRC
=BDD4MN=8ARSRC
=C1D4MX=8ARSRC
=C9D4LNp=01D4RW=A0=12=93{PAM3
0=00
=10p=00D4RWp=00D4LN=A0=12=92{PAM3
0=00p=0B=00@D4LN=8DRSRC=0B=98=06D8RW=8ARSRC
=D8D8MN=8ARSRC
=DCD8MX=8ARSRC
=E4D8LNp=01D8RW=A0=12=93{PAM4
=03=00
=01p=00D8RWp=00D8LN=A0=12=92{PAM4
=03=00p=0B=00@D8LN=8DRSRC=0Bp=07DCRW=8ARSRC
=F3DCMN=8ARSRC
=F7DCMX=8ARSRC
=FFDCLNp=01DCRW=A0=12=93{PAM4
0=00
=10p=00DCRWp=00DCLN=A0=12=92{PAM4
0=00p=0B=00@DCLN=8DRSRC=0BH=08E0RW=8ARSRC=0B=0E=01E0MN=8ARSRC=0B=12=01E0M=
X=8ARSRC=0B=1A=01E0LNp=01E0RW=A0=12=93{PAM5
=03=00
=01p=00E0RWp=00E0LN=A0=12=92{PAM5
=03=00p=0B=00@E0LN=8DRSRC=0B 	E4RW=8ARSRC=0B)=01E4MN=8ARSRC=0B-=01E4MX=8A=
RSRC=0B5=01E4LNp=01E4RW=A0=12=93{PAM5
0=00
=10p=00E4RWp=00E4LN=A0=12=92{PAM5
0=00p=0B=00@E4LN=8DRSRC=0B=F8	E8RW=8ARSRC=0BD=01E8MN=8ARSRC=0BH=01E8MX=8A=
RSRC=0BP=01E8LNp=01E8RW=A0=12=93{PAM6
=03=00
=01p=00E8RWp=00E8LN=A0=12=92{PAM6
=03=00p=0B=00@E8LN=8DRSRC=0B=D0
ECRW=8ARSRC=0B_=01ECMN=8ARSRC=0Bc=01ECMX=8ARSRC=0Bk=01ECLNp=01ECRW=A0=12=93=
{PAM6
0=00
=10p=00ECRWp=00ECLN=A0=12=92{PAM6
0=00p=0B=00@ECLN=A4RSRC[=82N=0BLVID=08_HID=0CA=D0=0C=02=08_UID
 =08RSRC=11=11
=0E=86	=00=00=00=00=00=00=00=00=00=00y=00=14O=08_CRS=08=8ARSRC
=04SBAS=8ARSRC
=08SLENpDRP0`pDRP1ar=83=88DMST`=00=83=88DMSTa=00`y`
=14`=A0
HEN_t`=0C=00=00=10=00`=A0=1D=93UMA_
=02t`=0C=00=00=10=00SBASp=0C=00=00=18=00SLEN=A0=1D=93UMA_
=03t`=0C=00=00=10=00SBASp=0C=00=00=10=00SLEN=A4RSRC[=82=0FAGP_=08_ADR=0C=00=
=00=01=00[=82D=82GCH0=08_ADR=0C=00=00=02=00[=80VGAB=00=0C=00=00=FA=FF=0B=00=
=C0[=81
VGAB=10BUF1=80=00`=08BUFX=11=04=0B=00=C0=08SXBB=11=04=0B=10=04=8BSXBB
=00SXFN=8BSXBB
=02SXSL=8BSXBB
 SXBX=8BSXBB
(SXCX=8BSXBB
,SXAX=08FNF7
=00=08FNF8
=00=08LDGS
=00=08PDOD
=00=08TBF7=12"=10
=02
=02
=03
=01
=02
=02
=02
=02
=03
=02
=02
=02
=02
=02
=02
=02=08TBF8=12"=10
=02
=08
=08
=08
=02
=02
=02
=02
=02
=02
=02
=02
=02
=02
=02
=02=14E	SXDD=00p
2SXFNp=0Bd_SXAXp=0B=00=02SXBXp\/=05_SB_PCI0LPC0SNC_CSXBSXBBSXBBp{zSXCX
=08=00
=0F=00`=A0&=93SXAX
_p
 SXDD return value =00[1p`[1=A4`=A1!p
 SXDD return value =00[1p
=00[1=A4
=00=14A	SXCD=00p
2SXFNp=0Bd_SXAXp=0B=00=01SXBXp\/=05_SB_PCI0LPC0SNC_CSXBSXBBSXBB=A00=93SXA=
X
_p{SXCX
=0F=00`p
 SXCD return value =00[1p`[1=A4`=A1!p
 SXCD return value =00[1p
=00[1=A4
=00=14H=04SXSD=01p
2SXFNp=0Bd_SXAXp
=01SXBXphSXCXp\/=05_SB_PCI0LPC0SNC_CSXBSXBBSXBB=A4SXAX=14 GDCS=01pSXCD`=A0=
=0B{SXCXh=00=A4
=1F=A1=04=A4
=1D=A4
=1D=14A=05GDSS=02p
 _DSS Called =00[1ph[1=A0
{h=0C=00=00=00@=00=A3=A1(pSXCD`=A0=06=93`
=00=A3=A1=19=A0
{i
=01=00}`i`=A1=07{=80i=00``SXSD`=14K=0CGDGS=01=A0=1A=93FNF7FNF8pGDCSh`=A4=91=
{`
=02=00
=00pSXDD`pSXCDa=A04=93=90a`
=00p
 Int10h failed. LCD Only =00[1=A0	{h
=02=00=A4
=01=A1=04=A4
=00=A1D=06{`ab=A0>FNF7p{`=83=88TBF7b=00=00bp
 Next Display value =00[1pb[1p=91{bh=00
=00b=A4{b
=01=00=A0=1BFNF8p=91{=83=88TBF8b=00h=00
=00b=A4{b
=01=00=A4
=00=A4
=00=14$_DOS=01p{h
=03=00LDGS=A0=13=93h
=00p
=00FNF7p
=00FNF8=08DODF=00=14G/_DOD=00=08PSIZ
=00=08PPTR
=00=A0=0EDODF=A4=12=07=01=0C=00=02=01=00pSXDD`p`ap`PDOD=A2=13a=A0=0B{a
=01=00uPSIZza
=01ap
 _DOD Called. PSIZE =00[1pPSIZ[1=A0H=08=93PSIZ
=01=08VID1=12=07=01=0C=00=02=01=00=A0=14{`
=01=00p=0C=00=01=01=00=88VID1
=00=00=A0=14{`
=02=00p=0C=00=02=01=00=88VID1
=00=00=A0=14{`
=04=00p=0C=00=03=01=00=88VID1
=00=00=A0=14{`
=08=00p=0C=00=04=01=00=88VID1
=00=00p
 _DOD Called =00[1pVID1[1=A4VID1=A0D
=93PSIZ
=02=08VID2=12=0C=02=0C=00=01=01=00=0C=00=02=01=00=A0=1B{`
=01=00p=0C=00=01=01=00=88VID2PPTR=00uPPTR=A0=1B{`
=02=00p=0C=00=02=01=00=88VID2PPTR=00uPPTR=A0=1B{`
=04=00p=0C=00=03=01=00=88VID2PPTR=00uPPTR=A0=16{`
=08=00p=0C=00=04=01=00=88VID2PPTR=00p
 _DOD Called =00[1pVID2[1=A4VID2=A0I
=93PSIZ
=03=08VID3=12=11=03=0C=00=01=01=00=0C=00=02=01=00=0C=00=03=01=00=A0=1B{`
=01=00p=0C=00=01=01=00=88VID3PPTR=00uPPTR=A0=1B{`
=02=00p=0C=00=02=01=00=88VID3PPTR=00uPPTR=A0=1B{`
=04=00p=0C=00=03=01=00=88VID3PPTR=00uPPTR=A0=16{`
=08=00p=0C=00=04=01=00=88VID3PPTR=00p
 _DOD Called =00[1pVID3[1=A4VID3=A0N
=93PSIZ
=04=08VID4=12=16=04=0C=00=01=01=00=0C=00=02=01=00=0C=00=03=01=00=0C=00=04=
=01=00=A0=1B{`
=01=00p=0C=00=01=01=00=88VID4PPTR=00uPPTR=A0=1B{`
=02=00p=0C=00=02=01=00=88VID4PPTR=00uPPTR=A0=1B{`
=04=00p=0C=00=03=01=00=88VID4PPTR=00uPPTR=A0=16{`
=08=00p=0C=00=04=01=00=88VID4PPTR=00p
 _DOD Called =00[1pVID4[1=A4VID4=A4=12=07=01=0C=00=02=01=00=14D=05_ROM=02=
pBUF1BUFX=A0=16=94rhi=00=0B=00=C0w
=00
=08`w=0B=00=10
=08a=A1=1Bwh
=08`=A0
=94i=0B=00=10w=0B=00=10
=08a=A1=06wi
=08a[=13BUFX`aBUFY=A4BUFY[=82K=05LFP_=08_ADR=0B=00=02=14
_DCS=00=A4GDCS
=02=140_DGS=00pGDGS
=02`p
 LFP _DGS return value =00[1p`[1=A4`=14
_DSS=01GDSSh
=02[=82K=05CRT_=08_ADR=0B=00=01=14
_DCS=00=A4GDCS
=01=140_DGS=00pGDGS
=01`p
 CRT _DGS return value =00[1p`[1=A4`=14
_DSS=01GDSSh
=01[=82K=05DTV_=08_ADR=0B=00=04=14
_DCS=00=A4GDCS
=08=140_DGS=00pGDGS
=08`p
 DTV _DGS return value =00[1p`[1=A4`=14
_DSS=01GDSSh
=08[=82B=0CHUB_=08_ADR=0C=00=00=1E=00=08_PRT=12A=08=08=12
=04=0B=FF=FF
=00LNKA
=00=12=0F=04=0C=FF=FF=02=00
=00LNKC
=00=12=0F=04=0C=FF=FF=02=00
=01LNKD
=00=12=0F=04=0C=FF=FF=08=00
=00LNKE
=00=12=0F=04=0C=FF=FF=0C=00
=00LNKA
=00=12=0F=04=0C=FF=FF=0C=00
=01LNKB
=00=12=0F=04=0C=FF=FF=0C=00
=02LNKC
=00=12=0F=04=0C=FF=FF=0C=00
=03LNKD
=00[=82=0CSD94=08_ADR
=00[=82=1BLAN_=08_ADR=0C=00=00=08=00=08_PRW=12=06=02
=0B
=03[=82G=FFLPC0=08_ADR=0C=00=00=1F=00[=80PIRX=02
`
=04[=81=1APIRX=01PIRA=08PIRB=08PIRC=08PIRD=08[=80PIRY=02
h
=04[=81=1APIRY=01PIRE=08PIRF=08PIRG=08PIRH=08[=80LPCR=02
=00
=F2[=81=13LPCR=01=00@bMON4=10MON5=10[=80GPIO=01=0B=80=11
,[=81=10GPIO=01=00H=07=00=01GP25=01[=80REGS=02
@
=C0[=81=1DREGS=03PMBA=10=00@=0BGPBA=10=00@K=00=05FUND=02[=82B=19MBRD=08_H=
ID=0CA=D0=0C=02=08_UID
=1F=08RSRC=11J
=D6G=01=10=00=10=00=01=10G=01$=00$=00=01=02G=01(=00(=00=01=02G=01,=00,=00=
=01=02G=010=000=00=01=02G=014=004=00=01=02G=018=008=00=01=02G=01<=00<=00=01=
=02G=01P=00P=00=01=04G=01r=00r=00=01=06G=01=80=00=80=00=01=01G=01=90=00=90=
=00=01=10G=01=A4=00=A4=00=01=02G=01=A8=00=A8=00=01=02G=01=AC=00=AC=00=01=02=
G=01=B0=00=B0=00=01=06G=01=B8=00=B8=00=01=02G=01=BC=00=BC=00=01=02G=01=00=
=10=00=10=01=80G=01=80=11=80=11=01@G=01.=00.=00=01=02G=01N=00N=00=01=02G=01=
=00=06=00=06=01=10G=01=D0=04=D0=04=01=02G=01=00=00=00=00=01=02=86	=00=00=00=
=00=80=FF=00=00=80=00y=00=14@	_CRS=00=8BRSRC
=92PMMN=8BRSRC
=94PMMX=8BRSRC
=9AGPMN=8BRSRC
=9CGPMX=8BRSRC
=C2PHMN=8BRSRC
=C4PHMX{^^PMBA=0B=80=FFPMMNpPMMNPMMX{^^GPBA=0B=80=FFGPMNpGPMNGPMXp^^MON4P=
HMNpPHMNPHMX=A4RSRC=14	_STA=00=A4
=0F[=82?DMAC=08_HID=0CA=D0=02=00=08_CRS=11 =

=1DG=01=00=00=00=00=01=10G=01=81=00=81=00=01=0FG=01=C0=00=C0=00=01 *=10=02=
y=00=14	_STA=00=A4
=0F[=82/MATH=08_HID=0CA=D0=0C=04=08_CRS=11=10

G=01=F0=00=F0=00=01=10"=00 y=00=14	_STA=00=A4
=0F[=825PIC_=08_HID=0BA=D0=08_CRS=11=18
=15G=01 =00 =00=01=02G=01=A0=00=A0=00=01=02"=04=00y=00=14	_STA=00=A4
=0F[=82/RTC_=08_HID=0CA=D0=0B=00=08_CRS=11=10

G=01p=00p=00=01=02"=00=01y=00=14	_STA=00=A4
=0F[=82,SPKR=08_HID=0CA=D0=08=00=08_CRS=11

G=01a=00a=00=01=01y=00=14	_STA=00=A4
=0F[=82/TMR_=08_HID=0CA=D0=01=00=08_CRS=11=10

G=01@=00@=00=01=04"=01=00y=00=14	_STA=00=A4
=0F[=827KBC_=08_HID=0CA=D0=03=03=08_CRS=11=18
=15G=01`=00`=00=01=01G=01d=00d=00=01=01"=02=00y=00=14	_STA=00=A4
=0F[=82=1DMOUE=08_HID=0CA=D0=0F=13=08_CRS=11=08
=05"=00=10y=00[=82J*EC0_=08_HID=0CA=D0=0C	=08_CRS=11=15
=12G=01b=00b=00=01=01G=01f=00f=00=01=01y=00=08_GPE
=1C=08ECOK
=00=14=12_REG=02=A0=0B=93h
=03piECOK=08_PRW=12=06=02
=1D
=05[=80ECR_=03
=00
=FF[=81D=14ECR_=10=00@@MPBP=01MPBD=01DOKD=01DFBP=01=00=04BT1A=01BT2A=01AC=
AT=01=00=05PWRB=01JOGB=01LIDS=01=00=05BT1P=01BT2P=01=00=06B1ST=08B2ST=08=00=
@=05MASK=08BT1S=01BT2S=01=00=06BT1W=01BT2W=01=00=06FAN0=08CB0S=01CB1S=01=00=
=06PHYO=01=00=07BRIT=08CONT=08SNDU=01SNDD=01=00=06SMDM=01=00=07=00=08SIRQ=
=08SLOB=08SHIB=08ILED=01=00=07DUSE=01=00=07B1RC=10B1AB=10B1RT=10B1VO=10B2=
RC=10B2AB=10B2RT=10B2VO=10B1DC=10B1LF=10B1DV=10B1DL=10B2DC=10B2LF=10B2DV=10=
B2DL=10A1TP=10A1AT=10A1PT=10A1CT=10A2TP=10A2AT=10A2PT=10A2CT=10=14=13_Q50=
=00PHS_
=A1=86ACAD
=80=14#_Q51=00=A0=0CBT1A=86BAT1
=00=A1=08=86BAT1
=01=86BAT1
=80=14!_Q53=00p
_Q53:Battery Selection=00[1=14>_Q58=00p
_Q58:ATF temperature trip point changd=00[1=86\._TZ_ATF0
=81=14?_Q5F=00p
_Q5F:ATF temperature reaches trip point=00[1=86\._TZ_ATF0
=80=14=13_Q60=00=86\._SB_PWRB
=80=14=13_Q66=00=86\._SB_LID_
=80[=82K9SPIC=08_HID=0CM=D9`=01=08RSRC=11=10

G=01=00=00=00=00=01 "=00=00y=00=08SSRC=11=10

G=01=00=00=00=00=01 "=00=00y=00=08SIRT=12
=04
=06
	=



=0B=14K=11_CRS=00=8CRSRC
=02IOM1=8CRSRC
=03IOM2=8BRSRC
=02IO1I=8BRSRC
=04IO1A=8BRSRC
	IRQV=A05=93\/=05_SB_PCI0LPC0EC0_ECOK
=00pPHSB
=D4
=9CIOM1pPHSB
=D4
=9DIOM2=A19p\/=05_SB_PCI0LPC0EC0_SLOBIOM1p\/=05_SB_PCI0LPC0EC0_SHIBIOM2pI=
O1IIO1A=A0'=93\/=05_SB_PCI0LPC0EC0_ECOK
=00zPHSB
=D4
=9B
=04`=A1=1Cz\/=05_SB_PCI0LPC0EC0_SIRQ
=04`=82`a=A0=16avap=83=88SIRTa=00`y
=01`IRQV=A4RSRC=14E=0F_SRS=01=8Ch
=02IOA1=8Ch
=03IOA2=8Bh
	IRQV=82IRQV`=A0=17`v`p=89SIRT=01`=00
=00
=00ay
=10ab=A1=05p
=00b=A0$=93\/=05_SB_PCI0LPC0EC0_ECOK
=00PHSW
=D5
=9Bb=A1=1Apb\/=05_SB_PCI0LPC0EC0_SIRQ=A03=93\/=05_SB_PCI0LPC0EC0_ECOK
=00PHSW
=D5
=9DIOA2PHSW
=D5
=9CIOA1=A19pIOA2\/=05_SB_PCI0LPC0EC0_SHIBpIOA1\/=05_SB_PCI0LPC0EC0_SLOB["=

=01=08_PRS=11-
*0G=01=80=10=80=10=01 0G=01=A0=10=A0=10=01 0G=01=C0=10=C0=10=01 0G=01=E0=10=
=E0=10=01 8"@=0Ey=00=14O	_DIS=00p_CRSSSRC=A09=93\/=05_SB_PCI0LPC0EC0_ECOK=

=00PHSW
=D5
=9B
=00PHSW
=D5
=9D
=00PHSW
=D5
=9C
=00=A1@=05p
=00\/=05_SB_PCI0LPC0EC0_SIRQp
=00\/=05_SB_PCI0LPC0EC0_SHIBp
=00\/=05_SB_PCI0LPC0EC0_SLOB["
=01=14I=06_STA=00=A0L=05=93CKOS
=00=A0'=93\/=05_SB_PCI0LPC0EC0_ECOK
=00zPHSB
=D4
=9B
=04`=A1=1Cz\/=05_SB_PCI0LPC0EC0_SIRQ
=04`=82`a=A0=05a=A4
=0F=A1=04=A4

=A1=04=A4
=0F[=82A\SNC_=08_HID=0CM=D9P=01=14=0FGPID=00=A4PHSB
=C0
=00=14@=05GBRT=00=A0%=93\/=05_SB_PCI0LPC0EC0_ECOK
=00pPHSD
=D4
=96`=A1=1Ap\/=05_SB_PCI0LPC0EC0_BRIT`=A4PHSB
=CF`=14@=05SBRT=01pPHSB
=CDh`=A0"=93\/=05_SB_PCI0LPC0EC0_ECOK
=00PHSB
=C3`=A1=1Ap`\/=05_SB_PCI0LPC0EC0_BRIT=A4=00=14=0FGPBR=00=A4PHSB
=C1
=00=14=0FSPBR=01PHSB
=C2h=A4=00=14@=05GCTR=00=A0%=93\/=05_SB_PCI0LPC0EC0_ECOK
=00pPHSD
=D4
=97`=A1=1Ap\/=05_SB_PCI0LPC0EC0_CONT`=A4PHSB
=D0`=14@=05SCTR=01pPHSB
=CEh`=A0"=93\/=05_SB_PCI0LPC0EC0_ECOK
=00PHSB
=C6`=A1=1Ap`\/=05_SB_PCI0LPC0EC0_CONT=A4=00=14=0FGPCR=00=A4PHSB
=C4
=00=14=0FSPCR=01PHSB
=C5h=A4=00=14=18HK_0=00=86\/=03_SB_PCI0GCH0
=00=14=18HK80=00=86\/=03_SB_PCI0GCH0
=80=14=18HK81=00=86\/=03_SB_PCI0GCH0
=81=14E=04HKF7=00p
=01\/=04_SB_PCI0GCH0FNF7p
=00\/=04_SB_PCI0GCH0FNF8=86\/=03_SB_PCI0GCH0
=80=14E=04HKF8=00p
=00\/=04_SB_PCI0GCH0FNF7p
=01\/=04_SB_PCI0GCH0FNF8=86\/=03_SB_PCI0GCH0
=80=14C=07SXF7=00p\/=04_SB_PCI0GCH0SXDD`p\/=04_SB_PCI0GCH0SXCDa=A0
=93=90a`
=00=A4
=00=A16{`abp{`=83=88\/=04_SB_PCI0GCH0TBF7b=00=00b=A4\/=04_SB_PCI0GCH0SXSD=
b=14@=07SXF8=00p\/=04_SB_PCI0GCH0SXDD`p\/=04_SB_PCI0GCH0SXCDa=A0
=93=90a`
=00=A4
=00=A13{`abp=83=88\/=04_SB_PCI0GCH0TBF8b=00b=A4\/=04_SB_PCI0GCH0SXSDb=14@=
=10SLVT=00p=00\/=04_SB_PCI0GCH0DODF=A0=15=91=93CKOS
=01=93CKOS
=02=A4SXF7=A1J=0Cp\/=04_SB_PCI0GCH0SXDD`=A0O=04=92=93\/=04_SB_PCI0GCH0PDO=
D`p
 Call _DOD to re-enumerate =00[1=86\/=03_SB_PCI0GCH0
=00["=0B=F4=01=A0=1B=93\/=04_SB_PCI0GCH0LDGS
=00HKF7=A0-=93\/=04_SB_PCI0GCH0LDGS
=01SXF7=86\/=03_SB_PCI0GCH0
=81=A0=18=93\/=04_SB_PCI0GCH0LDGS
=02=A3=A4
=00=14K=0ESLTT=00=A0=15=91=93CKOS
=01=93CKOS
=02=A4SXF8=A1J=0Cp\/=04_SB_PCI0GCH0SXDD`=A0O=04=92=93\/=04_SB_PCI0GCH0PDO=
D`p
 Call _DOD to re-enumerate =00[1=86\/=03_SB_PCI0GCH0
=00["=0B=F4=01=A0=1B=93\/=04_SB_PCI0GCH0LDGS
=00HKF8=A0-=93\/=04_SB_PCI0GCH0LDGS
=01SXF7=86\/=03_SB_PCI0GCH0
=81=A0=18=93\/=04_SB_PCI0GCH0LDGS
=02=A3=A4
=00=14=0FSEVF=00=A4PHSB
=C9
=00=14=0EGCMI=01=A4PHSD
=CAh=14=0ESCMI=01=A4PHSD
=CBh=14=08PWAK=00=A4=00=14=13PWRN=00=86\._SB_PWRB
=80=14(CSXB=01[#MPHS=FF=FFphSXBFPHS0
=CCpSXBF`['MPHS=A4`[=82O=87IDE0=08_ADR=0C=01=00=1F=00[=80IDEC=02
@
=18[=81D=06IDEC=03PRIT=10SECT=10PSIT=04SSIT=04=00=18PDMA=02SDMA=02=00=0CS=
DT0=02=00=02SDT1=02=00=02SDT2=02=00=02SDT3=02=00B=04ICR0=04ICR1=04ICR2=04=
ICR3=04ICR4=04ICR5=04=14F=04GETP=01=A0=0F=93{h
	=00
=00=A4=0C=FF=FF=FF=FF=A0
=93{h
	=00
=08=A4=0B=84=03z{h=0B=00=03=00
=08`z{h=0B=000=00
=0Ca=A4w
=1Et
	r`a=00=00=00=14,GETD=04=A0=1Fh=A0=05i=A4
=14=A0=0Cj=A4wt
=04k=00
=0F=00=A4wt
=04k=00
=1E=00=A4=0C=FF=FF=FF=FF=14J=04GETF=02=08TMPF
=00=A0=11{h
=01=00}TMPF
=01TMPF=A0=11{i
=02=00}TMPF
=02TMPF=A0=12{i=0B=00@=00}TMPF
=10TMPF=A4TMPF=14?SETP=03=A0	=92=95h
=F0=A4
=08=A1.=A0({i
=02=00=A0=10=90=92=94h
x{j
=02=00=A4=0B=01#=A0=10=90=92=94h
=B4{j
=01=00=A4=0B=01!=A4=0B=01=10=146SETD=01=A0=08=95h
=1E=A4
=01=A0=08=95h
-=A4
=02=A0=08=95h
<=A4
=01=A0=08=95h
Z=A4
=02=A0=08=95h
x=A4
=01=A4
=00[=82B6PRIM=08_ADR
=00=14K=0C_GTM=00=08PBUF=11=17
=14=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=8APBUF
=00PIO0=8APBUF
=04DMA0=8APBUF
=08PIO1=8APBUF
=0CDMA1=8APBUF
=10FLAGpGETPPRITPIO0pGETD{PDMA
=01=00{ICR3
=01=00{ICR0
=01=00SDT0DMA0=A0=14=93DMA0=0C=FF=FF=FF=FFpPIO0DMA0p=0C=FF=FF=FF=FFPIO1pP=
IO1DMA1pGETFPDMAPRITFLAG=A4PBUF=14G=16_STM=03=8Ah
=00PIO0=8Ah
=04DMA0=8Ah
=08PIO1=8Ah
=0CDMA1=8Ah
=10FLAGp
=00PRITp
=00PSITp
=00PDMAp
=00SDT0p
=00SDT1{ICR0
=0CICR0{ICR1
=0CICR1p
=04ICR2{ICR3
=0CICR3{ICR5
=0CICR5=A0A=0E=93=87i=0B=00=02=8Bi
bW490=8Bi
jW530=8Bi
=80W640=8Bi
=B0W880}PRIT=0B=04=80PRIT=A0=1E=90{FLAG
=02=00{W490=0B=00=08=00}PRIT
=02PRIT}PRITSETPPIO0W530W640PRIT=A0D=07{FLAG
=01=00}PDMA
=01PDMApSETDDMA0SDT0=A0=14{W880
 =00}ICR5
=01ICR5=A0=14{W880
=10=00}ICR1
=01ICR1=A0=13=95DMA0
=1E}ICR3
=01ICR3=A0=13=95DMA0
<}ICR0
=01ICR0[=82C=10DRV0=08_ADR
=00=14E=0F_GTF=00=08PIB0=11=11
=0E=03=00=00=00=00=A0=EF=03=00=00=00=00=A0=EF=8CPIB0
=01PMD0=8CPIB0
=08DMD0=A0@=06{PRIT
=02=00=A0=13=93{PRIT
	=00
=08p
=08PMD0=A1A=04p

PMD0z{PRIT=0B=00=03=00
=08`z{PRIT=0B=000=00
=0Car`ab=A0=0C=93
=03bp
=0BPMD0=A0=0C=93
=05bp
=0CPMD0=A1=08p
=01PMD0=A0<{PDMA
=01=00p}SDT0
@=00DMD0=A0=14{ICR0
=01=00rDMD0
=02DMD0=A0=10{ICR3
=01=00p
EDMD0=A1=14}t{PMD0
=07=00
=02=00
 DMD0=A4PIB0[=82=0CDRV1=08_ADR
=01=14=06_PS0=00=14=06_PS3=00[=82B6SCND=08_ADR
=01=14K=0C_GTM=00=08SBUF=11=17
=14=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=8ASBUF
=00PIO0=8ASBUF
=04DMA0=8ASBUF
=08PIO1=8ASBUF
=0CDMA1=8ASBUF
=10FLAGpGETPSECTPIO0pGETD{SDMA
=01=00{ICR3
=04=00{ICR0
=04=00SDT2DMA0=A0=14=93DMA0=0C=FF=FF=FF=FFpPIO0DMA0p=0C=FF=FF=FF=FFPIO1pP=
IO1DMA1pGETFSDMASECTFLAG=A4SBUF=14G=16_STM=03=8Ah
=00PIO0=8Ah
=04DMA0=8Ah
=08PIO1=8Ah
=0CDMA1=8Ah
=10FLAGp
=00SECTp
=00SSITp
=00SDMAp
=00SDT2p
=00SDT3{ICR0
=03ICR0{ICR1
=03ICR1p
=04ICR2{ICR3
=03ICR3{ICR5
=03ICR5=A0A=0E=93=87i=0B=00=02=8Bi
bW490=8Bi
jW530=8Bi
=80W640=8Bi
=B0W880}SECT=0B=04=80SECT=A0=1E=90{FLAG
=02=00{W490=0B=00=08=00}SECT
=02SECT}SECTSETPPIO0W530W640SECT=A0D=07{FLAG
=01=00}SDMA
=01SDMApSETDDMA0SDT2=A0=14{W880
 =00}ICR5
=04ICR5=A0=14{W880
=10=00}ICR1
=04ICR1=A0=13=95DMA0
=1E}ICR3
=04ICR3=A0=13=95DMA0
<}ICR0
=04ICR0[=82C=10DRV0=08_ADR
=00=14E=0F_GTF=00=08SIB0=11=11
=0E=03=00=00=00=00=A0=EF=03=00=00=00=00=A0=EF=8CSIB0
=01PMD0=8CSIB0
=08DMD0=A0@=06{SECT
=02=00=A0=13=93{SECT
	=00
=08p
=08PMD0=A1A=04p

PMD0z{SECT=0B=00=03=00
=08`z{SECT=0B=000=00
=0Car`ab=A0=0C=93
=03bp
=0BPMD0=A0=0C=93
=05bp
=0CPMD0=A1=08p
=01PMD0=A0<{SDMA
=01=00p}SDT2
@=00DMD0=A0=14{ICR0
=04=00rDMD0
=02DMD0=A0=10{ICR3
=04=00p
EDMD0=A1=14}t{PMD0
=07=00
=02=00
 DMD0=A4SIB0[=82=0CDRV1=08_ADR
=01=14=06_PS0=00=14=06_PS3=00[=82@
USB1=08_ADR=0C=02=00=1F=00[=80USB1=02
=C4
=04[=81=0BUSB1=03RSEN=02=08_PRW=12=06=02
=03
=03=14=19_PSW=01=A0	hp
=03RSEN=A1=08p
=00RSEN=14=13_PS0=00p=01^^.LPC0GP25=14=3D_PS3=00=A0'=92=91RSEN\/=04_SB_PC=
I0USB2RSENp=00^^.LPC0GP25=A1=0Ep=01^^.LPC0GP25[=82@
USB2=08_ADR=0C=04=00=1F=00[=80USB2=02
=C4
=04[=81=0BUSB2=03RSEN=02=08_PRW=12=06=02
=04
=03=14=19_PSW=01=A0	hp
=03RSEN=A1=08p
=00RSEN=14=13_PS0=00p=01^^.LPC0GP25=14=3D_PS3=00=A0'=92=91RSEN\/=04_SB_PC=
I0USB1RSENp=00^^.LPC0GP25=A1=0Ep=01^^.LPC0GP25[=82=0FSMBC=08_ADR=0C=03=00=
=1F=00[=82=0FAUDI=08_ADR=0C=05=00=1F=00[=82=1BMODE=08_ADR=0C=06=00=1F=00=08=
_PRW=12=06=02
=05
=03=10F=16\/=03_SB_PCI0HUB_[=82C=15CRD0=08_ADR=0C=00=00=02=00[=80CCRD=02
=00
=E4[=81)CCRD=03=00 CD04 =00@=1BCD3E =00=10CD44 =00@LCDE0=08CDE1=08[=80EXC=
A=01=0B=E0=03
=02[=81=10EXCA=01INDX=08DATA=08[=86=13INDXDATA=01=00=18=00=07ERIB=01=140_=
INI=00=A0 =93CKOS
=01p=00CDE0p=00CD04p=00CD3Ep=00CD44=A1=08p
=00CDE1=08_PSC
=00=14.PSX_=01p
=00CDE0p=0B=E0=03CD44p=01ERIBp
=00CD44phCDE0ph_PSC=14=14_PS0=00p
=00CDE1p
=00_PSC=14=17_PS1=00PSX_
=01}CDE1
=01CDE1=14=17_PS2=00PSX_
=02}CDE1
=01CDE1=14=17_PS3=00PSX_
=03}CDE1
=01CDE1=14	_STA=00=A4
=0F=08_PRW=12=06=02
=0B
=03=10O=94\/=03_SB_PCI0LPC0[=01SLOK=00[=80SMC1=01
=2E
=02[=81=10SMC1=01INDX=08DATA=08[=86B=05INDXDATA=01CR00=08CR01=08CR02=08=00=
=10CR05=08=00=08CR07=08=00H
CR23=08=00=10PPDM=04=00=04PPIR=04=00D=04RRBA=08=00=10DIR2=08POL2=08[=80RR=
BL=01=0B
=06
=03[=81=12RRBL=01GP20=01=00=16GP47=01=14
ENCF=00p
UINDX=14
EXCF=00p
=AAINDX[=82D=14COMA=08_HID=0CA=D0=05=01=08MCD_
=12=08_EJD
_SB.DOCK=00=14A=04_CRS=00=A00\/=05_SB_PCI0LPC0COMA_STA[#SLOK=FF=FFpPSCS
=12`['SLOK=A4`=A1=08=A4=11=05
=02y=00=14=1B_SRS=01[#SLOK=FF=FFPSSS
=12h['SLOK=14=1E_PRS=00[#SLOK=FF=FFpPSPS
=12`['SLOK=A4`=14=1A_DIS=00[#SLOK=FF=FFPSDI
=12['SLOK=14=1E_STA=00[#SLOK=FF=FFpPSST
=12`['SLOK=A4`=08_PSC
=00=14+_PS0=00ENCFp
=01GP47["
=01}CR02
=08CR02p
=00_PSCEXCF=14'_PS3=00ENCFp
=00GP47{CR02
=F7CR02p
=03_PSCEXCF=08_PRW=12=06=02
=08
=03[=82M=1ALPTA=08_HID=0CA=D0=04=00=08_UID
=01=08MCD_
=14=08_EJD
_SB.DOCK=00=08CRSB=11=10

G=01=00=00=00=00=01=08"=00=00y=00=14M
_CRS=00=A0L	\/=05_SB_PCI0LPC0LPTA_STA=8BCRSB
=02IO1B=8BCRSB
=04IO2B=8CCRSB
=07IO3B=8BCRSB
	IRQB[#SLOK=FF=FFENCFyCR23
=02IO1BpIO1BIO2Bp=00IRQB=A0=10PPIRy
=01PPIRIRQB=A0=10=93IO1B=0B=BC=03p
=03IO3BEXCF['SLOK=A4CRSB=A1=08=A4=11=05
=02y=00=14I=04B_SR=01=8Bh
=02IO1S=8Bh
	IRQS[#SLOK=FF=FFENCFzIO1S
=02CR23=82IRQS`=A0=04`v`p`PPIREXCF['SLOK=14
B_PR=00=A4PSPS
=14=14=0CB_DI=00PSDI
=14=14
_STA=00=A4PSST
=14=08_PSC
=00=14 _PS0=00ENCF}CR01
=04CR01p
=00_PSCEXCF=14 _PS3=00ENCF{CR01
=FBCR01p
=03_PSCEXCF[=82M=1ALPTB=08_HID=0CA=D0=04=00=08_UID
=02=08MCD_
=15=08_EJD
_SB.DOCK=00=08CRSB=11=10

G=01=00=00=00=00=01=08"=00=00y=00=14M
_CRS=00=A0L	\/=05_SB_PCI0LPC0LPTB_STA=8BCRSB
=02IO1B=8BCRSB
=04IO2B=8CCRSB
=07IO3B=8BCRSB
	IRQB[#SLOK=FF=FFENCFyCR23
=02IO1BpIO1BIO2Bp=00IRQB=A0=10PPIRy
=01PPIRIRQB=A0=10=93IO1B=0B=BC=03p
=03IO3BEXCF['SLOK=A4CRSB=A1=08=A4=11=05
=02y=00=14I=04B_SR=01=8Bh
=02IO1S=8Bh
	IRQS[#SLOK=FF=FFENCFzIO1S
=02CR23=82IRQS`=A0=04`v`p`PPIREXCF['SLOK=14
B_PR=00=A4PSPS
=15=14=0CB_DI=00PSDI
=15=14
_STA=00=A4PSST
=15=08_PSC
=00=14 _PS0=00ENCF}CR01
=04CR01p
=00_PSCEXCF=14 _PS3=00ENCF{CR01
=FBCR01p
=03_PSCEXCF[=82L!ECP_=08_HID=0CA=D0=04=01=08MCD_
=13=08_EJD
_SB.DOCK=00=08CRSA=11=1B
=18G=01=00=00=00=00=01=08G=01=00=00=00=00=01=08"=00=00*=00=00y=00=14B=10_=
CRS=00=A0A=0F\/=05_SB_PCI0LPC0ECP__STA=8BCRSA
=02IO1A=8BCRSA
=04IO2A=8CCRSA
=07IO3A=8BCRSA

IO4A=8BCRSA
=0CIO5A=8CCRSA
=0FIO6A=8BCRSA
=11IRQA=8CCRSA
=14DMAA[#SLOK=FF=FFENCFyCR23
=02IO1ApIO1AIO2ArIO1A=0B=00=04IO4ApIO4AIO5Ap=00IRQA=A0=10PPIRy
=01PPIRIRQA=A0=19=93IO1A=0B=BC=03p
=03IO3ApIO3AIO6Ay
=01PPDMDMAAEXCF['SLOK=A4CRSA=A1=08=A4=11=05
=02y=00=14O=05_SRS=01=8Bh
=02IO1S=8Bh
=11IRQS=8Ch
=14DMAS[#SLOK=FF=FFENCFzIO1S
=02CR23=82IRQS`=A0=04`v`p`PPIR=82DMASavapaPPDMEXCF['SLOK=14
_PRS=00=A4PSPS
=13=14=0C_DIS=00PSDI
=13=14
_STA=00=A4PSST
=13=08_PSC
=00=14 _PS0=00ENCF}CR01
=04CR01p
=00_PSCEXCF=14 _PS3=00ENCF{CR01
=FBCR01p
=03_PSCEXCF[=82F=1CFDC_=08_HID=0CA=D0=07=00=08MCD_
=11=08ARM_=00=14=1E_CRS=00[#SLOK=FF=FFpPSCS
=11`['SLOK=A4`=14=1BB_SR=01[#SLOK=FF=FFPSSS
=11h['SLOK=14=1EB_PR=00[#SLOK=FF=FFpPSPS
=11`['SLOK=A4`=14=1AB_DI=00[#SLOK=FF=FFPSDI
=11['SLOK=14=1E_STA=00[#SLOK=FF=FFpPSST
=11`['SLOK=A4`=08_PSC
=00=149_PS0=00ENCF=A0=18=93PHS_
=D3=01{CR05
=FDCR05["
=01}CR00
=08CR00p
=00_PSCEXCF=14+_PS3=00ENCF{CR00
=F7CR00}CR05
=02CR05p
=03_PSCEXCF=08FDES=11=17
=14=01=00=00=00=00=00=00=00=00=00=00=00=00=00=00=00=02=00=00=00=14=0B_FDE=
=00=A4FDES=08FDIB=12(=13
=00
=04
O
=00
=12
=00
=01
=00
=DF
=02
7
=02
=18
=1B
=FF
l
=F6
=15
=05=14=0B_FDI=00=A4FDIB[=82C=04FDD_=08_ADR
=00=08_EJD
_SB.DOCK=00=14&_STA=00=A0=1A=90\/=03_SB_DOCKDKFS=93ARM_=00=A4
=0F=A1=04=A4
=00=10#\/=04_SB_PCI0HUB_SD94=08_EJD
_SB.DOCK=00=10H=0E\/=04_SB_PCI0LPC0EC0_=149_Q5A=00p=00\/=04_SB_PCI0GCH0DO=
DFp=00\/=03_SB_DOCKDCRI=86\._SB_DOCK
=00=14D=06_Q5B=00[$\/=03_SB_DOCKUDCK=A0:=93\/=03_SB_DOCKDCRI=00\/=03_SB_D=
OCKDULF
=00=A0=16=92=93CKOS
=01=86\._SB_DOCK
=00p=00\/=03_SB_DOCKDCRI=143_Q5C=00=A0=1D=91=93CKOS
=01=93CKOS
=03=86\._SB_DOCK
=01=A1=0E=86\._SB_DOCK
=03=10+\_SI_=14$_SST=01=A0=05=93h
=00=A0=05=93h
=01=A0=05=93h
=02=A0=05=93h
=03=A0=05=93h
=04=14F	_WAK=01=A0=0B=93h
=04PHS_
=A3=A0K=06=91=93h
=03=93h
=04\/=05_SB_PCI0LPC0SPIC_SRS\/=05_SB_PCI0LPC0SPICSSRCp\/=03_SB_DOCKGDST`=A0=
 =92=93`\/=03_SB_DOCKDKST=86\._SB_DOCK
=00=A0=14PHS_
=DC=86\._SB_PWRB
=02=A4=00=10N
\_TZ_[=85E
ATF0=14=16KELV=01ph`w`

`r`=0B=AB
`=A4`=14._TMP=00zPHSD
=D4
=C0
=08`=A0=15=94`
=80["
2zPHSD
=D4
=C0
=08`=A4KELV`=14=18_PSV=00zPHSD
=D4
=C4
=08`=A4KELV`=08_PSL=12=0C=01\._PR_CPU0=14=18_CRT=00zPHSD
=D4
=C6
=08`=A4KELV`=08_TC1
=01=08_TC2
=02=08_TSP
2=10Er_SB_=08IRQP=12#=10
=00
=00
=00
=00
=00
=00
=00
=00
=00=0B=00=02
=00
=00
=00
=00
=00
=00[=82G=12LNKA=08_HID=0CA=D0=0C=0F=08_UID
=01=08_PRS=11	=

=06#=00=02=18y=00=14/_DIS=00}\/=04_SB_PCI0LPC0PIRA
=80\/=04_SB_PCI0LPC0PIRA=14H=05_CRS=00=08BUFA=11	=

=06#=00=00=18y=00=8BBUFA
=01IRA1{\/=04_SB_PCI0LPC0PIRA
=8F`=A0=1A=95`
=80{`
=0F`p=83=88IRQP`=00dpdIRA1=A4BUFA=14@=05_SRS=01=8Bh
=01IRA1pIRA1`p=89IRQP=01`=00
=00
=00a{\/=04_SB_PCI0LPC0PIRA
p`}a`\/=04_SB_PCI0LPC0PIRA=14&_STA=00=A0=1A=93\/=04_SB_PCI0LPC0PIRA
=80=A4
	=A1=04=A4
=0B[=82G=12LNKB=08_HID=0CA=D0=0C=0F=08_UID
=02=08_PRS=11	=

=06#=00=02=18y=00=14/_DIS=00}\/=04_SB_PCI0LPC0PIRB
=80\/=04_SB_PCI0LPC0PIRB=14H=05_CRS=00=08BUFA=11	=

=06#=00=00=18y=00=8BBUFA
=01IRA1{\/=04_SB_PCI0LPC0PIRB
=8F`=A0=1A=95`
=80{`
=0F`p=83=88IRQP`=00dpdIRA1=A4BUFA=14@=05_SRS=01=8Bh
=01IRA1pIRA1`p=89IRQP=01`=00
=00
=00a{\/=04_SB_PCI0LPC0PIRB
p`}a`\/=04_SB_PCI0LPC0PIRB=14&_STA=00=A0=1A=93\/=04_SB_PCI0LPC0PIRB
=80=A4
	=A1=04=A4
=0B[=82G=12LNKC=08_HID=0CA=D0=0C=0F=08_UID
=03=08_PRS=11	=

=06#=00=02=18y=00=14/_DIS=00}\/=04_SB_PCI0LPC0PIRC
=80\/=04_SB_PCI0LPC0PIRC=14H=05_CRS=00=08BUFA=11	=

=06#=00=00=18y=00=8BBUFA
=01IRA1{\/=04_SB_PCI0LPC0PIRC
=8F`=A0=1A=95`
=80{`
=0F`p=83=88IRQP`=00dpdIRA1=A4BUFA=14@=05_SRS=01=8Bh
=01IRA1pIRA1`p=89IRQP=01`=00
=00
=00a{\/=04_SB_PCI0LPC0PIRC
p`}a`\/=04_SB_PCI0LPC0PIRC=14&_STA=00=A0=1A=93\/=04_SB_PCI0LPC0PIRC
=80=A4
	=A1=04=A4
=0B[=82G=12LNKD=08_HID=0CA=D0=0C=0F=08_UID
=04=08_PRS=11	=

=06#=00=02=18y=00=14/_DIS=00}\/=04_SB_PCI0LPC0PIRD
=80\/=04_SB_PCI0LPC0PIRD=14H=05_CRS=00=08BUFA=11	=

=06#=00=00=18y=00=8BBUFA
=01IRA1{\/=04_SB_PCI0LPC0PIRD
=8F`=A0=1A=95`
=80{`
=0F`p=83=88IRQP`=00dpdIRA1=A4BUFA=14@=05_SRS=01=8Bh
=01IRA1pIRA1`p=89IRQP=01`=00
=00
=00a{\/=04_SB_PCI0LPC0PIRD
p`}a`\/=04_SB_PCI0LPC0PIRD=14&_STA=00=A0=1A=93\/=04_SB_PCI0LPC0PIRD
=80=A4
	=A1=04=A4
=0B[=82G=12LNKE=08_HID=0CA=D0=0C=0F=08_UID
=05=08_PRS=11	=

=06#=00=02=18y=00=14/_DIS=00}\/=04_SB_PCI0LPC0PIRE
=80\/=04_SB_PCI0LPC0PIRE=14H=05_CRS=00=08BUFA=11	=

=06#=00=00=18y=00=8BBUFA
=01IRA1{\/=04_SB_PCI0LPC0PIRE
=8F`=A0=1A=95`
=80{`
=0F`p=83=88IRQP`=00dpdIRA1=A4BUFA=14@=05_SRS=01=8Bh
=01IRA1pIRA1`p=89IRQP=01`=00
=00
=00a{\/=04_SB_PCI0LPC0PIRE
p`}a`\/=04_SB_PCI0LPC0PIRE=14&_STA=00=A0=1A=93\/=04_SB_PCI0LPC0PIRE
=80=A4
	=A1=04=A4
=0B[=82G=12LNKH=08_HID=0CA=D0=0C=0F=08_UID
=08=08_PRS=11	=

=06#=00=02=18y=00=14/_DIS=00}\/=04_SB_PCI0LPC0PIRH
=80\/=04_SB_PCI0LPC0PIRH=14H=05_CRS=00=08BUFA=11	=

=06#=00=00=18y=00=8BBUFA
=01IRA1{\/=04_SB_PCI0LPC0PIRH
=8F`=A0=1A=95`
=80{`
=0F`p=83=88IRQP`=00dpdIRA1=A4BUFA=14@=05_SRS=01=8Bh
=01IRA1pIRA1`p=89IRQP=01`=00
=00
=00a{\/=04_SB_PCI0LPC0PIRH
p`}a`\/=04_SB_PCI0LPC0PIRH=14&_STA=00=A0=1A=93\/=04_SB_PCI0LPC0PIRH
=80=A4
	=A1=04=A4
=0B=14J=10CKOS=00p=87_OS_`=08BUFF=11=02`=08STRG=11=03
	p_OS_BUFFp
NT E: te=00STRGp=FFd=A0A=04=93`
=11rw=83=88BUFF
=0F=00=0B=00=01=00=83=88BUFF
=10=00arw=83=88STRG
=06=00=0B=00=01=00=83=88STRG
=07=00b=A0=08=93abp
=02d=A1K=08=A0H=08=92=95`
=14rw=83=88BUFF
=12=00=0B=00=01=00=83=88BUFF
=13=00arw=83=88STRG
=00=00=0B=00=01=00=83=88STRG
=01=00brw=83=88STRG
=03=00=0B=00=01=00=83=88STRG
=04=00crw=83=88STRG
=06=00=0B=00=01=00=83=88STRG
=07=00e=A0=07=93abp=00d=A1=14=A0=07=93acp=01d=A1
=A0=08=93aep
=03d=A4d=10C=1C\/=04_SB_PCI0LPC0EC0_[=82A=16BAT1=08_HID=0CA=D0=0C
=08_UID
=01=08_PCL=12=07=01\_SB_=08BATI=12-
=00=0BP=96=0BP=96
=00=0B=D09
=00
x
=00


=00
=00
LION=00
Sony Corp.=00=08BATS=12=0F=04
=02=0C=FF=FF=FF=FF=0Bz
=0B@8=14"_STA=00{PHSD
=D4
=80=0B=00=01a=A0=06ap
=1F`=A1=05p
=0F`=A4`=14I=04_BIF=00pPHSD
=D4
=B0awa

=88BATI
=01=00pPHSD
=D4
=B2awa

=88BATI
=02=00pPHSD
=D4
=B6=88BATI
=04=00=A4BATI=14G=08_BST=00p{PHSD
=D4
=84
=FF`=88BATS
=00=00pPHSD
=D4
=A6`pPHSD
=D4
=A4a=A0
=93a=0B=FF=FFp=0C=FF=FF=FF=FFa=A1=1C=A0=0F=92=95a=0B=00=80=7Fa=0B=FF=FFau=
aw`aaxa=0B=E8=03=00apa=88BATS
=01=00wPHSD
=D4
=A2

=88BATS
=02=00p`=88BATS
=03=00=A4BATS[=82I=04ACAD=08_HID
ACPI0003=00=08_PCL=12=07=01\_SB_=14=1C_PSR=00{PHSD
=D4
=80=0B=00=04a=A0=04a=A4=01=A1=03=A4=00=14	_STA=00=A4
=0F
--==_Exmh_7933893120--




