/*
  RSD PTR: OEM=PTLTD, ACPI_Rev=1.0x (0)
	RSDT=0x0e7fbc01, cksum=239
 */
/*
  RSDT: Length=40, Revision=1, Checksum=169,
	OEMID=PTLTD, OEM Table ID=  RSDT, OEM Revision=0x6040000,
	Creator ID= LTP, Creator Revision=0x0
	Entries={ 0x0e7fbc29 }
 */
/*
  FACP: Length=116, Revision=1, Checksum=248,
	OEMID=Compaq, OEM Table ID=00B5, OEM Revision=0x6040000,
	Creator ID=PTL, Creator Revision=0x1000000
 	FACS=0xe7fffc0, DSDT=0xe7fbc9d
	INT_MODEL=PIC
	Preferred_PM_Profile=Unspecified (0)
	SCI_INT=10
	SMI_CMD=0x802f, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
	PSTATE_CNT=0x0
	PM1a_EVT_BLK=0x8000-0x8003
	PM1a_CNT_BLK=0x8004-0x8005
	PM2_CNT_BLK=0x8050-0x8050
	PM_TMR_BLK=0x8008-0x800b
	GPE0_BLK=0x8020-0x8023
	P_LVL2_LAT=15 us, P_LVL3_LAT=1001 us
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=0, DUTY_WIDTH=0
	DAY_ALRM=125, MON_ALRM=126, CENTURY=50
	IAPC_BOOT_ARCH=
	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4,DCK_CAP}
 */
/*
  FACS:	Length=64, HwSig=0x00000000, Firm_Wake_Vec=0x00000000
	Global_Lock=
	Flags=
	Version=0
 */
/*
  DSDT: Length=13155, Revision=1, Checksum=156,
	OEMID=COMPAQ, OEM Table ID=00B5, OEM Revision=0x6040000,
	Creator ID=MSFT, Creator Revision=0x100000e
 */
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20041119
 *
 * Disassembly of /tmp/acpidump.Bw95yU, Sun Mar  5 15:49:45 2006
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "COMPAQ", "00B5    ", 100925440)
{
    Mutex (MUT0, 0x00)
    Name (ECFL, Zero)
    Name (OSTY, Zero)
    Name (CSST, Zero)
    Name (\_S0, Package (0x02)
    {
        0x00, 
        0x00
    })
    Name (\_S1, Package (0x02)
    {
        0x04, 
        0x04
    })
    Name (\_S3, Package (0x02)
    {
        0x01, 
        0x01
    })
    Name (\_S4, Package (0x02)
    {
        0x02, 
        0x02
    })
    Name (\_S5, Package (0x02)
    {
        0x02, 
        0x02
    })
    OperationRegion (DBG, SystemIO, 0x80, 0x01)
    Field (DBG, ByteAcc, NoLock, Preserve)
    {
        DEBG,   8
    }

    Scope (\_PR)
    {
        Processor (CPU0, 0x01, 0x00008010, 0x06)
        {
            Name (_PCT, Package (0x02)
            {
                ResourceTemplate ()
                {
                    Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
                }, 

                ResourceTemplate ()
                {
                    Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
                }
            })
            Name (_PSS, Package (0x01)
            {
                Package (0x06)
                {
                    0x03E8, 
                    0x251C, 
                    0x14, 
                    0x14, 
                    0x00640000, 
                    0x00640000
                }
            })
            Method (_PPC, 0, NotSerialized)
            {
                Return (0x00)
            }
        }
    }

    Method (\_PTS, 1, NotSerialized)
    {
        Store (Arg0, CSST)
        Store (CSST, DEBG)
        Acquire (MUT0, 0xFFFF)
        Store (CSST, \_SB.PCI0.PIB.EC.SLPT)
        If (LEqual (CSST, 0x05))
        {
            Store (0x00, \_SB.PCI0.PIB.EC.ACPI)
        }

        Release (MUT0)
        If (LEqual (CSST, 0x03))
        {
            And (\_SB.PCI0.PM.PBCR, 0xFB, \_SB.PCI0.PM.PBCR)
        }

        Store (Or (\_SB.PCI0.PM.GO16, 0x20), \_SB.PCI0.PM.GO16)
    }

    Method (\_WAK, 1, NotSerialized)
    {
        Store (Arg0, CSST)
        Store (And (\_SB.PCI0.PM.GO16, 0xDF), \_SB.PCI0.PM.GO16)
        Acquire (MUT0, 0xFFFF)
        Store (0x00, \_SB.PCI0.PIB.EC.SLPT)
        Store (0x00, \_SB.PCI0.PIB.EC.T1LO)
        If (LEqual (\_SB.PCI0.PIB.EC.NDMD, 0x01))
        {
            Store (0x3A, \_SB.PCI0.PIB.EC.T1HI)
        }
        Else
        {
            Store (0x4E, \_SB.PCI0.PIB.EC.T1HI)
        }

        Release (MUT0)
        Store (One, \_TZ.TSCI)
        Notify (\_TZ.THRM, 0x81)
        Notify (\_TZ.THRM, 0x80)
        Notify (\_SB.PCI0.CRD0, 0x00)
        Notify (\_SB.PCI0.CRD1, 0x00)
        Notify (\_SB.PCI0.USB0, 0x00)
        Notify (\_SB.PCI0.USB1, 0x00)
        Notify (\_SB.PCI0.USB2, 0x00)
        Notify (\_SB.AC, 0x80)
        Notify (\_SB.CMB0, 0x81)
        Notify (\_SB.CMB0, 0x80)
        Acquire (MUT0, 0xFFFF)
        Store (\_SB.WMID.STD, Local0)
        Store (\_SB.PCI0.PIB.EC.NDMD, Local1)
        Store (Local1, \_SB.WMID.STD)
        Release (MUT0)
        If (LNot (LEqual (Local0, Local1)))
        {
            Notify (\_SB.WMID, 0x80)
        }

        If (LNot (LLess (\_SB.PCI0.PIB.CLKR, 0x47)))
        {
            If (LNot (LLess (CSST, 0x03)))
            {
                Or (\_SB.PCI0.PM.PBCR, 0x04, \_SB.PCI0.PM.PBCR)
            }
        }

        Store (Or (CSST, 0x30), DEBG)
        Store (Zero, CSST)
    }

    Scope (\_SI)
    {
    }

    Scope (\_GPE)
    {
        Method (_L05, 0, NotSerialized)
        {
            Notify (\_SB.PWRB, 0x02)
        }
    }

    Scope (\_SB)
    {
        Device (WMID)
        {
            Name (_HID, EisaId ("PNP0C14"))
            Name (_UID, 0x00)
            Name (STD, 0x00)
            Name (_WDG, Buffer (0x28)
            {
                0x71, 0xAC, 0x64, 0xC3, 0xDB, 0x36, 0x5A, 0x49, 
                0x84, 0x94, 0xB4, 0x39, 0xD4, 0x72, 0xA5, 0x05, 
                0x42, 0x41, 0x01, 0x00, 0xEE, 0xB5, 0x17, 0x07, 
                0x66, 0xF4, 0x10, 0x41, 0xA5, 0x54, 0xC5, 0x58, 
                0x8B, 0x80, 0x28, 0xC0, 0x80, 0x00, 0x01, 0x08
            })
            Method (WQBA, 1, NotSerialized)
            {
                Store (STD, Local0)
                Return (STD)
            }

            Method (_WED, 1, NotSerialized)
            {
                Return (0x00)
            }

            Method (WE80, 1, NotSerialized)
            {
                Return (0x00)
            }
        }

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

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

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

        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Name (ACPW, Ones)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (_STA, 0x0F)
            Method (_PSR, 0, NotSerialized)
            {
                If (\ECFL)
                {
                    Acquire (MUT0, 0xFFFF)
                    And (\_SB.PCI0.PIB.EC.ADP, 0x01, ACPW)
                    Release (MUT0)
                    Return (ACPW)
                }
                Else
                {
                    Return (0x01)
                }
            }
        }

        Device (CMB0)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x01)
            Name (BATS, Ones)
            Name (CRIT, 0x00)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (_STA, 0, NotSerialized)
            {
                If (\ECFL)
                {
                    Acquire (MUT0, 0xFFFF)
                    And (\_SB.PCI0.PIB.EC.BATP, 0x01, BATS)
                    Release (MUT0)
                    If (LEqual (BATS, Zero))
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (0x1F)
                    }
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Name (PBIF, Package (0x0D)
            {
                0x00, 
                Ones, 
                Ones, 
                0x01, 
                Ones, 
                0x0320, 
                0x0320, 
                0x64, 
                0x64, 
                "BAT1", 
                "1234", 
                "LION", 
                "COMPAQ"
            })
            Method (_BIF, 0, NotSerialized)
            {
                If (\ECFL)
                {
                    Acquire (MUT0, 0xFFFF)
                    Store (\_SB.PCI0.PIB.EC.BDC, Index (PBIF, 0x01))
                    Store (\_SB.PCI0.PIB.EC.BFC, Index (PBIF, 0x02))
                    Store (0x01, Index (PBIF, 0x03))
                    Store (\_SB.PCI0.PIB.EC.BDV, Index (PBIF, 0x04))
                    Store (\_SB.PCI0.PIB.EC.BCW, Index (PBIF, 0x05))
                    Store (0x10, Index (PBIF, 0x06))
                    Release (MUT0)
                }

                Return (PBIF)
            }

            Name (BUFF, Package (0x04)
            {
                0x00, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0xFFFFFFFF
            })
            Method (_BST, 0, NotSerialized)
            {
                If (\ECFL)
                {
                    Acquire (MUT0, 0xFFFF)
                    Store (\_SB.PCI0.PIB.EC.BST, Local0)
                    Store (And (Local0, 0x07), Local1)
                    Store (Local1, Index (BUFF, 0x00))
                    Store (\_SB.PCI0.PIB.EC.BPR, Local0)
                    Store (Local0, Local1)
                    If (And (Local0, 0x8000))
                    {
                        Store (Subtract (0x00010000, Local1), Local2)
                    }
                    Else
                    {
                        Store (Local1, Local2)
                    }

                    Store (Local2, Index (BUFF, 0x01))
                    Store (\_SB.PCI0.PIB.EC.BRC, Index (BUFF, 0x02))
                    Store (\_SB.PCI0.PIB.EC.BPV, Index (BUFF, 0x03))
                    Release (MUT0)
                }

                Return (BUFF)
            }

            Method (_BTP, 1, NotSerialized)
            {
                If (\ECFL)
                {
                    Store ("_SB.CMB0._BTP", Debug)
                }
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Name (_PRW, Package (0x02)
            {
                0x0B, 
                0x04
            })
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_PRW, Package (0x02)
            {
                0x05, 
                0x03
            })
            Method (_INI, 0, NotSerialized)
            {
                If (CondRefOf (\_OSI, Local0))
                {
                    If (\_OSI ("Windows 2001"))
                    {
                        Store (0x04, OSTY)
                        \_SB.VSMI (0x84)
                    }
                }
                Else
                {
                    If (LEqual (\SCMP (\_OS, "Microsoft Windows"), Zero))
                    {
                        Store (0x01, ECFL)
                        Store (0x01, OSTY)
                        \_SB.VSMI (0x81)
                    }
                    Else
                    {
                        If (LEqual (\SCMP (\_OS, "Microsoft Windows NT"), Zero))
                        {
                            Store (0x03, OSTY)
                            \_SB.VSMI (0x83)
                        }
                        Else
                        {
                            If (LEqual (\SCMP (\_OS, "Microsoft WindowsME: Millennium Edition"), Zero))
                            {
                                Store (0x01, ECFL)
                                Store (0x02, OSTY)
                                \_SB.VSMI (0x81)
                            }
                        }
                    }
                }
            }

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

            OperationRegion (REGS, PCI_Config, 0x40, 0x34)
            Field (REGS, DWordAcc, NoLock, Preserve)
            {
                Offset (0x0A), 
                TOM,    16, 
                Offset (0x1A), 
                PAM1,   8, 
                PAM2,   8, 
                PAM3,   8, 
                PAM4,   8, 
                PAM5,   8, 
                PAM6,   8, 
                Offset (0x33), 
                T_EN,   1
            }

            Name (RSRC, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,
                    0x0000,
                    0x00FF,
                    0x0000,
                    0x0001, 0x00)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,
                    0x0000,
                    0x0CF7,
                    0x0000,
                    0x0CF8, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000A0000,
                    0x000BFFFF,
                    0x00000000,
                    0x00020000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C0000,
                    0x000C3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C4000,
                    0x000C7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C8000,
                    0x000CBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000CC000,
                    0x000CFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D0000,
                    0x000D3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D4000,
                    0x000D7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D8000,
                    0x000DBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000DC000,
                    0x000DFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E0000,
                    0x000E3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E4000,
                    0x000E7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E8000,
                    0x000EBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000EC000,
                    0x000EFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x00000000,
                    0x00000000,
                    0x00000000,
                    0x00000000, 0x00)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,
                    0x0D00,
                    0xFFFF,
                    0x0000,
                    0xF300, 0x00)
            })
            Method (_CRS, 0, Serialized)
            {
                CreateDWordField (RSRC, 0x0193, ATMN)
                CreateDWordField (RSRC, 0x0197, ATMX)
                CreateDWordField (RSRC, 0x019F, ATLN)
                Multiply (TOM, 0x00010000, Local0)
                If (T_EN)
                {
                    Add (Local0, 0x000E0000, ATMN)
                }
                Else
                {
                    Store (Local0, ATMN)
                }

                Subtract (0xFFE00000, ATMN, ATLN)
                Subtract (Add (ATMN, ATLN), 0x01, ATMX)
                CreateBitField (RSRC, 0x0250, C0RW)
                CreateDWordField (RSRC, 0x4F, C0MN)
                CreateDWordField (RSRC, 0x53, C0MX)
                CreateDWordField (RSRC, 0x5B, C0LN)
                Store (One, C0RW)
                If (LEqual (And (PAM1, 0x03), 0x01))
                {
                    Store (Zero, C0RW)
                }

                Store (Zero, C0LN)
                If (LNot (And (PAM1, 0x03)))
                {
                    Store (0x4000, C0LN)
                }

                CreateBitField (RSRC, 0x0328, C4RW)
                CreateDWordField (RSRC, 0x6A, C4MN)
                CreateDWordField (RSRC, 0x6E, C4MX)
                CreateDWordField (RSRC, 0x76, 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, 0x0400, C8RW)
                CreateDWordField (RSRC, 0x85, C8MN)
                CreateDWordField (RSRC, 0x89, C8MX)
                CreateDWordField (RSRC, 0x91, C8LN)
                Store (One, C8RW)
                If (LEqual (And (PAM2, 0x03), 0x01))
                {
                    Store (Zero, C8RW)
                }

                Store (Zero, C8LN)
                If (LNot (And (PAM2, 0x03)))
                {
                    Store (0x4000, C8LN)
                }

                CreateBitField (RSRC, 0x04D8, CCRW)
                CreateDWordField (RSRC, 0xA0, CCMN)
                CreateDWordField (RSRC, 0xA4, CCMX)
                CreateDWordField (RSRC, 0xAC, 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, 0x05B0, D0RW)
                CreateDWordField (RSRC, 0xBB, D0MN)
                CreateDWordField (RSRC, 0xBF, D0MX)
                CreateDWordField (RSRC, 0xC7, D0LN)
                Store (One, D0RW)
                If (LEqual (And (PAM3, 0x03), 0x01))
                {
                    Store (Zero, D0RW)
                }

                Store (Zero, D0LN)
                If (LNot (And (PAM3, 0x03)))
                {
                    Store (0x4000, D0LN)
                }

                CreateBitField (RSRC, 0x0688, D4RW)
                CreateDWordField (RSRC, 0xD6, D4MN)
                CreateDWordField (RSRC, 0xDA, D4MX)
                CreateDWordField (RSRC, 0xE2, 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, 0x0760, D8RW)
                CreateDWordField (RSRC, 0xF1, D8MN)
                CreateDWordField (RSRC, 0xF5, D8MX)
                CreateDWordField (RSRC, 0xFD, D8LN)
                Store (One, D8RW)
                If (LEqual (And (PAM4, 0x03), 0x01))
                {
                    Store (Zero, D8RW)
                }

                Store (Zero, D8LN)
                If (LNot (And (PAM4, 0x03)))
                {
                    Store (0x4000, D8LN)
                }

                CreateBitField (RSRC, 0x0838, DCRW)
                CreateDWordField (RSRC, 0x010C, DCMN)
                CreateDWordField (RSRC, 0x0110, DCMX)
                CreateDWordField (RSRC, 0x0118, 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, 0x0910, E0RW)
                CreateDWordField (RSRC, 0x0127, E0MN)
                CreateDWordField (RSRC, 0x012B, E0MX)
                CreateDWordField (RSRC, 0x0133, E0LN)
                Store (One, E0RW)
                If (LEqual (And (PAM5, 0x03), 0x01))
                {
                    Store (Zero, E0RW)
                }

                Store (Zero, E0LN)
                If (LNot (And (PAM5, 0x03)))
                {
                    Store (0x4000, E0LN)
                }

                CreateBitField (RSRC, 0x09E8, E4RW)
                CreateDWordField (RSRC, 0x0142, E4MN)
                CreateDWordField (RSRC, 0x0146, E4MX)
                CreateDWordField (RSRC, 0x014E, 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, 0x0AC0, E8RW)
                CreateDWordField (RSRC, 0x015D, E8MN)
                CreateDWordField (RSRC, 0x0161, E8MX)
                CreateDWordField (RSRC, 0x0169, E8LN)
                Store (One, E8RW)
                If (LEqual (And (PAM6, 0x03), 0x01))
                {
                    Store (Zero, E8RW)
                }

                Store (Zero, E8LN)
                If (LNot (And (PAM6, 0x03)))
                {
                    Store (0x4000, E8LN)
                }

                CreateBitField (RSRC, 0x0B98, ECRW)
                CreateDWordField (RSRC, 0x0178, ECMN)
                CreateDWordField (RSRC, 0x017C, ECMX)
                CreateDWordField (RSRC, 0x0184, 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)
            }

            Name (_PRT, Package (0x0D)
            {
                Package (0x04)
                {
                    0x0007FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x01, 
                    \_SB.PCI0.PIB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x02, 
                    \_SB.PCI0.PIB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0007FFFF, 
                    0x03, 
                    \_SB.PCI0.PIB.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x01, 
                    \_SB.PCI0.PIB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x02, 
                    \_SB.PCI0.PIB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x01, 
                    \_SB.PCI0.PIB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    \_SB.PCI0.PIB.LNKD, 
                    0x00
                }
            })
            Device (PIB)
            {
                Name (_ADR, 0x00070000)
                OperationRegion (IRQR, PCI_Config, 0x00, 0xF8)
                Field (IRQR, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x48), 
                        ,   2, 
                    EUSB,   1, 
                    Offset (0x50), 
                    FDDA,   2, 
                    LPDA,   2, 
                    Offset (0x51), 
                    FDIQ,   4, 
                    LPIQ,   4, 
                    SAIQ,   4, 
                    SBIQ,   4, 
                    Offset (0x55), 
                        ,   4, 
                    PIRA,   4, 
                    PIRB,   4, 
                    PIRC,   4, 
                        ,   4, 
                    PIRD,   4, 
                    Offset (0x78), 
                    Z000,   16, 
                    Offset (0x81), 
                    PDC1,   8, 
                    PDC2,   8, 
                    PDC3,   8, 
                    PDC4,   8, 
                    EXFE,   8, 
                    Offset (0x8A), 
                    Z001,   1, 
                    Offset (0x8B), 
                    Offset (0xF6), 
                    CLKR,   8
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRA)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRA, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFA, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFA, 0x01, IRA1)
                        CreateByteField (BUFA, 0x02, IRA2)
                        Store (\_SB.PCI0.PIB.PIRA, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local0)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRA2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRA1)
                            }
                        }

                        Return (BUFA)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRA1)
                        CreateByteField (Arg0, 0x02, IRA2)
                        If (LGreater (IRA2, Zero))
                        {
                            FindSetLeftBit (IRA2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRA1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRA)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {11}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRB)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRB, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFB, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFB, 0x01, IRB1)
                        CreateByteField (BUFB, 0x02, IRB2)
                        Store (\_SB.PCI0.PIB.PIRB, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local0)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRB2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRB1)
                            }
                        }

                        Return (BUFB)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRB1)
                        CreateByteField (Arg0, 0x02, IRB2)
                        If (LGreater (IRB2, Zero))
                        {
                            FindSetLeftBit (IRB2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRB1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRB)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {7}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRC, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFC, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFC, 0x01, IRC1)
                        CreateByteField (BUFC, 0x02, IRC2)
                        Store (\_SB.PCI0.PIB.PIRC, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local0)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRC2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, IRC1)
                            }
                        }

                        Return (BUFC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRC1)
                        CreateByteField (Arg0, 0x02, IRC2)
                        If (LGreater (IRC2, Zero))
                        {
                            FindSetLeftBit (IRC2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRC1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRC)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {15}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.PIRD)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.PIB.PIRD, 0x00))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateByteField (BUFD, 0x01, IRD1)
                        CreateByteField (BUFD, 0x02, IRD2)
                        Store (\_SB.PCI0.PIB.PIRD, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            If (LGreater (Local0, 0x07))
                            {
                                Subtract (Local0, 0x08, Local2)
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local2, Local3)
                                Store (Local3, IRD2)
                            }
                            Else
                            {
                                Store (0x01, Local1)
                                ShiftLeft (Local1, Local0, Local2)
                                Store (Local2, IRD1)
                            }
                        }

                        Return (BUFD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x01, IRD1)
                        CreateByteField (Arg0, 0x02, IRD2)
                        If (LGreater (IRD2, Zero))
                        {
                            FindSetLeftBit (IRD2, Local0)
                            Decrement (Local0)
                            Add (Local0, 0x08, Local0)
                        }
                        Else
                        {
                            FindSetLeftBit (IRD1, Local0)
                            Decrement (Local0)
                        }

                        Store (Local0, \_SB.PCI0.PIB.PIRD)
                    }
                }

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

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

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

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

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

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

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x0022, 0x0022, 0x01, 0x01)
                        IO (Decode16, 0x00B1, 0x00B1, 0x01, 0x01)
                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
                        IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
                        IO (Decode16, 0x3810, 0x3810, 0x01, 0x10)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IO (Decode16, 0x04D6, 0x04D6, 0x01, 0x01)
                        IO (Decode16, 0x0480, 0x0480, 0x01, 0x10)
                        IO (Decode16, 0x040B, 0x040B, 0x01, 0x01)
                        Memory32Fixed (ReadOnly, 0xFFFC0000, 0x00040000)
                    })
                }

                Device (DIGI)
                {
                    Name (_HID, EisaId ("FPI2002"))
                    Name (_UID, 0x01)
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x08, 0x08)
                        IRQNoFlags () {}
                    })
                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                            IRQNoFlags () {4}
                        }
                        EndDependentFn ()
                    })
                    OperationRegion (VSIO, SystemIO, 0x03F0, 0x02)
                    Field (VSIO, ByteAcc, NoLock, Preserve)
                    {
                        INDX,   8, 
                        DATA,   8
                    }

                    IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0xE2), 
                        CRE2,   8, 
                        CRE3,   8, 
                        Offset (0xE6), 
                        CRE6,   8, 
                        CRE7,   8, 
                        CRE8,   8, 
                        Offset (0xEE), 
                        CREE,   8
                    }

                    Method (ENCG, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.PIB.EXFE, Local0)
                        Or (Local0, 0x02, Local0)
                        Store (Local0, \_SB.PCI0.PIB.EXFE)
                    }

                    Method (EXCG, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.PIB.EXFE, Local0)
                        And (Local0, 0xFD, Local0)
                        Store (Local0, \_SB.PCI0.PIB.EXFE)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        ENCG ()
                        Store (CRE2, Local0)
                        And (Local0, 0x04, Local0)
                        If (Local0)
                        {
                            Store (CRE7, Local1)
                            EXCG ()
                            Return (0x0F)
                        }

                        EXCG ()
                        Return (0x0D)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENCG ()
                        Store (CRE2, Local0)
                        And (Local0, 0xFB, Local0)
                        Store (Local0, CRE2)
                        Store (Zero, CRE7)
                        EXCG ()
                        Store (Zero, \_SB.PCI0.PIB.SAIQ)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, ResourceTemplate ()
                        {
                            IO (Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
                            IRQNoFlags () {4}
                        })
                        CreateByteField (BUF0, 0x02, IOLO)
                        CreateByteField (BUF0, 0x03, IOHI)
                        CreateByteField (BUF0, 0x04, IORL)
                        CreateByteField (BUF0, 0x05, IORH)
                        CreateByteField (BUF0, 0x09, IRQL)
                        ENCG ()
                        Store (CRE7, Local0)
                        Store (Local0, Local1)
                        And (Local1, 0xC0, Local1)
                        ShiftRight (Local1, 0x06, Local1)
                        And (Local0, 0x3F, Local0)
                        ShiftLeft (Local0, 0x02, Local0)
                        Store (Local0, IOLO)
                        Store (Local1, IOHI)
                        Store (IOLO, IORL)
                        Store (IOHI, IORH)
                        EXCG ()
                        Store (\_SB.PCI0.PIB.SAIQ, Local0)
                        Store (0x01, Local1)
                        ShiftLeft (Local1, Local0, IRQL)
                        Return (BUF0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateByteField (Arg0, 0x09, IRQL)
                        ENCG ()
                        Store (CRE2, Local0)
                        And (Local0, 0xFB, Local0)
                        Store (Local0, CRE2)
                        Store (IOLO, Local0)
                        ShiftRight (Local0, 0x02, Local0)
                        And (Local0, 0xFE, Local0)
                        Store (IOHI, Local1)
                        ShiftLeft (Local1, 0x06, Local1)
                        Or (Local0, Local1, Local0)
                        Store (Local0, CRE7)
                        FindSetRightBit (IRQL, Local0)
                        Decrement (Local0)
                        Store (Local0, \_SB.PCI0.PIB.SAIQ)
                        Store (CRE2, Local0)
                        Or (Local0, 0x04, Local0)
                        Store (Local0, CRE2)
                        EXCG ()
                    }
                }

                Device (BTNS)
                {
                    Name (_HID, "Compaq TabletPC Buttons")
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQ (Edge, ActiveHigh, Exclusive) {1}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (EC)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_GPE, 0x01)
                    Name (SFBE, Zero)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
                    })
                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x80), 
                        NMSG,   8, 
                        SLED,   4, 
                        SLPT,   4, 
                        MODE,   1, 
                        KYIN,   1, 
                        ACPI,   1, 
                        PWBN,   1, 
                        TMWK,   1, 
                        TME1,   1, 
                        FANC,   1, 
                        DETF,   1, 
                        LIDS,   1, 
                        LWKE,   1, 
                        IWKE,   1, 
                        INTM,   1, 
                        MWKE,   1, 
                        COMM,   1, 
                        PME,    1, 
                        SBVD,   1, 
                        ADP,    1, 
                        AFLT,   1, 
                            ,   1, 
                        LCTV,   1, 
                        BATP,   4, 
                        BPU0,   1, 
                        Offset (0x86), 
                        BSEL,   4, 
                        Offset (0x89), 
                        BDC,    16, 
                        Offset (0x8D), 
                        BFC,    16, 
                        Offset (0x91), 
                        BTC,    1, 
                        Offset (0x95), 
                        BDV,    16, 
                        Offset (0x99), 
                        BST,    4, 
                        Offset (0x9D), 
                        BPR,    16, 
                        Offset (0xA1), 
                        BRC,    16, 
                        Offset (0xA5), 
                        BPV,    16, 
                        Offset (0xA9), 
                        BTP,    16, 
                        Offset (0xAD), 
                        BCW,    16, 
                        Offset (0xB1), 
                        BCL,    16, 
                        Offset (0xB5), 
                        BCG,    8, 
                        Offset (0xB9), 
                        BCG2,   8, 
                        Offset (0xBD), 
                        BMO,    8, 
                        Offset (0xC1), 
                        BIF,    32, 
                        BIF1,   32, 
                        BSN,    32, 
                        BSN1,   32, 
                        BTY,    32, 
                        T1LO,   8, 
                        T1HI,   8, 
                        T2LO,   8, 
                        T2HI,   8, 
                        CRT1,   8, 
                        CRT2,   8, 
                        TMP1,   8, 
                        TMP2,   8, 
                        NABT,   4, 
                        BCM,    4, 
                        CCBQ,   16, 
                        CBT,    16, 
                        Offset (0xE3), 
                        OST,    4, 
                        C3FG,   1, 
                        Offset (0xE4), 
                        FSR,    8, 
                        FOM1,   8, 
                        FOM2,   8, 
                        FOF1,   8, 
                        FOF2,   8, 
                        FFZ1,   8, 
                        FFZ2,   8, 
                        FFM1,   8, 
                        FFM2,   8, 
                        SHT1,   8, 
                        SHT2,   8, 
                        TMOD,   8, 
                        FMD,    8, 
                        FFD,    8, 
                        FCD,    8, 
                        TSTA,   4, 
                        Offset (0xF4), 
                        WRS,    1, 
                        SLB,    1, 
                        SPW,    1, 
                        KSCC,   1, 
                        LB1D,   1, 
                        LB2D,   1, 
                        TM1D,   1, 
                        Offset (0xF5), 
                        LBV,    4, 
                        Offset (0xF6), 
                        NDMD,   6, 
                        Offset (0xFA), 
                        DIPM,   8
                    }

                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, \ECFL)
                            Acquire (MUT0, 0xFFFF)
                            Store (Zero, \_SB.PCI0.PIB.EC.TME1)
                            Store (NDMD, \_SB.WMID.STD)
                            Store (Zero, \_SB.PCI0.LREN)
                            Store (0x00, \_SB.PCI0.PIB.EC.T1LO)
                            If (LEqual (NDMD, 0x01))
                            {
                                Store (0x3A, \_SB.PCI0.PIB.EC.T1HI)
                            }
                            Else
                            {
                                Store (0x4E, \_SB.PCI0.PIB.EC.T1HI)
                            }

                            Store (One, \_SB.PCI0.PIB.EC.TME1)
                            Release (MUT0)
                        }
                    }

                    Method (_Q03, 0, NotSerialized)
                    {
                        Acquire (MUT0, 0xFFFF)
                        Store (One, \_SB.PCI0.PIB.EC.LB1D)
                        Release (MUT0)
                        Notify (\_SB.CMB0, 0x80)
                    }

                    Method (_Q04, 0, NotSerialized)
                    {
                        Acquire (MUT0, 0xFFFF)
                        Store (One, \_SB.PCI0.PIB.EC.LB1D)
                        Store (One, \_SB.PCI0.PIB.EC.LB2D)
                        Release (MUT0)
                        Notify (\_SB.CMB0, 0x80)
                    }

                    Method (_Q06, 0, NotSerialized)
                    {
                        Notify (\_SB.AC, 0x80)
                        Notify (\_SB.CMB0, 0x80)
                    }

                    Method (_Q08, 0, NotSerialized)
                    {
                        Notify (\_SB.CMB0, 0x81)
                    }

                    Method (_Q09, 0, NotSerialized)
                    {
                        If (LNot (LLess (SFBE, 0x02)))
                        {
                            Notify (\_SB.CMB0, 0x80)
                        }
                        Else
                        {
                            Add (SFBE, 0x01, SFBE)
                        }
                    }

                    Method (_Q20, 0, NotSerialized)
                    {
                        Store ("=============== Thermal sensor tripped =================", Debug)
                        Acquire (MUT0, 0xFFFF)
                        Store (\_SB.PCI0.PIB.EC.TMP1, Local0)
                        Store (\_SB.PCI0.PIB.EC.T1HI, Local1)
                        Store (\_SB.PCI0.PIB.EC.T1LO, Local2)
                        SNTP (Local0, Local1, Local2)
                        Store (One, \_TZ.TSCI)
                        Release (MUT0)
                        Notify (\_TZ.THRM, 0x80)
                    }

                    Method (_Q21, 0, NotSerialized)
                    {
                        Acquire (MUT0, 0xFFFF)
                        Store (One, \_SB.PCI0.PIB.EC.TM1D)
                        Release (MUT0)
                        Notify (\_TZ.THRM, 0x81)
                        Notify (\_TZ.THRM, 0x80)
                        Notify (\_SB.PWRB, 0x80)
                    }

                    Method (_Q24, 0, NotSerialized)
                    {
                        Store (\_SB.WMID.STD, Local0)
                        Acquire (MUT0, 0xFFFF)
                        Store (NDMD, Local1)
                        Release (MUT0)
                        Store (Local1, \_SB.WMID.STD)
                        And (Local0, 0x3C, Local2)
                        If (Local2)
                        {
                            And (Local1, 0x03, Local3)
                            If (Local3)
                            {
                                If (LEqual (\_SB.PCI0.VIDO.DOSA, 0x00))
                                {
                                    \_SB.VSMI (0x86)
                                    Acquire (MUT0, 0xFFFF)
                                    Store (DIPM, Local4)
                                    Release (MUT0)
                                    If (LEqual (Local4, 0xCC))
                                    {
                                        Notify (\_SB.PCI0.VIDO, 0x80)
                                    }
                                }
                                Else
                                {
                                    \_SB.VSMI (0x85)
                                }
                            }
                        }

                        And (Local0, 0x01, Local0)
                        And (Local1, 0x01, Local1)
                        If (LNot (LEqual (Local0, Local1)))
                        {
                            Acquire (MUT0, 0xFFFF)
                            Store (0x00, \_SB.PCI0.PIB.EC.T1LO)
                            If (LEqual (\_SB.WMID.STD, 0x01))
                            {
                                Store (0x3A, \_SB.PCI0.PIB.EC.T1HI)
                            }
                            Else
                            {
                                Store (0x4E, \_SB.PCI0.PIB.EC.T1HI)
                            }

                            Release (MUT0)
                            Store (One, \_TZ.TSCI)
                            Notify (\_TZ.THRM, 0x81)
                            Notify (\_TZ.THRM, 0x80)
                        }

                        Notify (\_SB.WMID, 0x80)
                    }

                    Method (SNTP, 3, NotSerialized)
                    {
                        Store (Zero, \_SB.PCI0.PIB.EC.TME1)
                        Store (\_SB.PCI0.PIB.EC.TSTA, Local0)
                        If (And (Local0, 0x01))
                        {
                            Store ("---------Above ACTIVE_TP---", Debug)
                            Subtract (Arg1, 0x02, Local1)
                            Store (Local1, \_SB.PCI0.PIB.EC.T1LO)
                            Add (Arg1, 0x02, Local1)
                            Store (Local1, \_SB.PCI0.PIB.EC.T1HI)
                        }

                        If (And (Local0, 0x02))
                        {
                            Store ("---------Below SENSOR1_ACTIVE_TP---", Debug)
                            Subtract (Arg2, 0x02, Local1)
                            If (LAnd (LEqual (NDMD, 0x01), LLess (Local1, 0x3A)))
                            {
                                Store (0x00, Local1)
                            }

                            If (LAnd (LNot (LEqual (NDMD, 0x01)), LLess (Local1, 0x4E)))
                            {
                                Store (0x00, Local1)
                            }

                            Store (Local1, \_SB.PCI0.PIB.EC.T1LO)
                            Add (Arg2, 0x02, Local2)
                            If (LAnd (LEqual (NDMD, 0x01), LLess (Local2, 0x3A)))
                            {
                                Store (0x3A, Local2)
                            }

                            If (LAnd (LNot (LEqual (NDMD, 0x01)), LLess (Local2, 0x4E)))
                            {
                                Store (0x4E, Local2)
                            }

                            Store (Local2, \_SB.PCI0.PIB.EC.T1HI)
                        }

                        Store (One, \_SB.PCI0.PIB.EC.TME1)
                    }
                }
            }

            Name (REGT, Package (0x15)
            {
                0x10, 
                0x20, 
                0x21, 
                0x22, 
                0x23, 
                0x33, 
                0x34, 
                0x35, 
                0x36, 
                0x37, 
                0x47, 
                0x48, 
                0x49, 
                0x4A, 
                0x4B, 
                0x4C, 
                0x5C, 
                0x5D, 
                0x5E, 
                0x5F, 
                0x6F
            })
            Name (DMTB, Package (0x08)
            {
                0x05, 
                0x04, 
                0x03, 
                0x02, 
                0x02, 
                0x01, 
                0x01, 
                0x00
            })
            Name (PIOT, Package (0x07)
            {
                0x0258, 
                0x017F, 
                0xF0, 
                0xB4, 
                0x78, 
                0x5A, 
                0x00
            })
            Device (IDE)
            {
                Name (_ADR, 0x00070001)
                OperationRegion (PCI, PCI_Config, 0x48, 0x60)
                Field (PCI, DWordAcc, NoLock, Preserve)
                {
                    SDR1,   8, 
                    SDR0,   8, 
                    PDR1,   8, 
                    PDR0,   8, 
                    SDST,   4, 
                    PDST,   4, 
                    Offset (0x08), 
                    UDMS,   16, 
                    UDMP,   16
                }

                Method (GTM, 3, NotSerialized)
                {
                    Store (Buffer (0x14) {}, Local0)
                    CreateDWordField (Local0, 0x00, PIO0)
                    CreateDWordField (Local0, 0x04, DMA0)
                    CreateDWordField (Local0, 0x08, PIO1)
                    CreateDWordField (Local0, 0x0C, DMA1)
                    CreateDWordField (Local0, 0x10, FLAG)
                    Store (Zero, FLAG)
                    Or (FLAG, 0x10, FLAG)
                    Add (And (Arg1, 0x0F), ShiftRight (Arg1, 0x04), Local1)
                    Add (Local1, 0x02, Local1)
                    Multiply (Local1, 0x1E, PIO0)
                    Or (FLAG, 0x02, FLAG)
                    Add (And (Arg2, 0x0F), ShiftRight (Arg2, 0x04), Local1)
                    Add (Local1, 0x02, Local1)
                    Multiply (Local1, 0x1E, PIO1)
                    Or (FLAG, 0x08, FLAG)
                    If (And (Arg0, 0xE000))
                    {
                        Or (FLAG, 0x01, FLAG)
                    }

                    Add (ShiftRight (And (Arg0, 0x0700), 0x08), 0x02, Local1)
                    Multiply (Local1, 0x0A, DMA0)
                    If (And (Arg0, 0xE0))
                    {
                        Or (FLAG, 0x04, FLAG)
                    }

                    Add (And (Arg0, 0x07), 0x02, Local1)
                    Multiply (Local1, 0x0A, DMA1)
                    Return (Local0)
                }

                Method (STM, 3, NotSerialized)
                {
                    Store (Buffer (0x05) {}, Local7)
                    CreateWordField (Local7, 0x00, UDMT)
                    CreateWordField (Local7, 0x02, PIOT)
                    CreateByteField (Local7, 0x04, R4CT)
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Store (FLAG, Local4)
                    Store (0x0707, Local1)
                    If (And (Local4, 0x01))
                    {
                        And (Local1, 0x07, Local1)
                        Divide (DMA0, 0x0A, , Local3)
                        Subtract (Local3, 0x02, Local3)
                        Or (Local3, 0xE0, Local3)
                        Or (ShiftLeft (Local3, 0x08, Local3), Local1, Local1)
                    }

                    If (And (Local4, 0x04))
                    {
                        And (Local1, 0xFF00, Local1)
                        Divide (DMA1, 0x0A, , Local3)
                        Subtract (Local3, 0x02, Local3)
                        Or (Or (Local3, 0xE0), Local1, Local1)
                    }

                    Store (Local1, UDMT)
                    Store (0x0A, Local2)
                    If (And (Local4, 0x02))
                    {
                        Divide (PIO0, 0x1E, , Local3)
                        Subtract (Local3, 0x03, Local3)
                        If (LLess (Local3, 0x0C))
                        {
                            And (Local2, 0x03, Local2)
                            Or (Local2, 0x04, Local2)
                        }

                        Store (ShiftLeft (DerefOf (Index (^^REGT, Local3)), 0x08), Local6)
                    }
                    Else
                    {
                        Store (0x00, Local6)
                    }

                    If (And (Local4, 0x08))
                    {
                        Divide (PIO1, 0x1E, , Local3)
                        Subtract (Local3, 0x03, Local3)
                        If (LLess (Local3, 0x0C))
                        {
                            And (Local2, 0x0C, Local2)
                            Or (Local2, 0x01, Local2)
                        }

                        Store (DerefOf (Index (^^REGT, Local3)), Local6)
                    }
                    Else
                    {
                        Store (And (Local6, 0xFF00), Local6)
                    }

                    Store (Local2, R4CT)
                    Store (Local6, PIOT)
                    Return (Local7)
                }

                Method (GTF, 3, NotSerialized)
                {
                    If (Arg2)
                    {
                        Store (Buffer (0x07)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            }, Local7)
                    }
                    Else
                    {
                        Store (Buffer (0x07)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            }, Local7)
                    }

                    CreateByteField (Local7, 0x01, MODE)
                    Add (And (Arg0, 0x0F), ShiftRight (Arg0, 0x04), Local1)
                    Add (Local1, 0x02, Local1)
                    Multiply (Local1, 0x1E, Local0)
                    Store (Match (^^PIOT, MLT, Local0, MTR, 0x00, 0x00), Local1)
                    If (Local1)
                    {
                        Decrement (Local1)
                    }

                    If (And (Arg1, 0xE0))
                    {
                        Store (DerefOf (Index (^^DMTB, And (Arg1, 0x07))), Local0)
                        Or (Local0, 0x40, MODE)
                    }
                    Else
                    {
                        Or (Local1, 0x08, MODE)
                    }

                    Concatenate (Local7, Local7, Local6)
                    Or (Local1, 0x08, MODE)
                    Concatenate (Local6, Local7, Local5)
                    Return (Local5)
                }

                Device (PRIM)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Store ("GTM - Primary Controller", Debug)
                        Store (^^GTM (^^UDMP, ^^PDR0, ^^PDR1), Local0)
                        Return (Local0)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store ("STM - Primary Controller", Debug)
                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
                        CreateWordField (Local0, 0x00, UDMA)
                        CreateWordField (Local0, 0x02, PIOM)
                        CreateByteField (Local0, 0x04, ADST)
                        Store (UDMA, ^^UDMP)
                        Store (And (PIOM, 0xFF), Local1)
                        If (Local1)
                        {
                            Store (Local1, ^^PDR1)
                        }

                        ShiftRight (PIOM, 0x08, Local1)
                        If (Local1)
                        {
                            Store (Local1, ^^PDR0)
                        }

                        Store (ADST, ^^PDST)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Primary Master", Debug)
                            ShiftRight (^^^UDMP, 0x08, Local0)
                            Store (^^^GTF (^^^PDR0, Local0, 0x01), Local0)
                            Return (Local0)
                        }

                        Name (FWSO, "FWSO")
                    }
                }
            }

            Device (PM)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0xF1)
                Name (RSRC, ResourceTemplate ()
                {
                    IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
                    IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
                })
                Name (_ADR, 0x00070004)
                OperationRegion (SB74, PCI_Config, 0x00, 0x0100)
                Field (SB74, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x48), 
                    Z004,   16, 
                    Offset (0x70), 
                    Z005,   16, 
                    Offset (0x90), 
                    Z006,   16
                }

                OperationRegion (PMIO, SystemIO, 0x8000, 0x50)
                Field (PMIO, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x11), 
                    PBCR,   8, 
                    Offset (0x20), 
                    GPSL,   8, 
                    GPSH,   8, 
                    Offset (0x2F), 
                    SCMD,   8, 
                    Offset (0x48), 
                    GI00,   8, 
                    GI08,   8, 
                    GI16,   8, 
                    GI24,   8, 
                    GO00,   8, 
                    GO08,   8, 
                    GO16,   8, 
                    GO24,   8
                }

                Method (_CRS, 0, Serialized)
                {
                    CreateWordField (RSRC, 0x02, PMMN)
                    CreateWordField (RSRC, 0x04, PMMX)
                    And (^Z004, 0xFF80, PMMN)
                    Store (PMMN, PMMX)
                    CreateWordField (RSRC, 0x0A, HMMN)
                    CreateWordField (RSRC, 0x0C, HMMX)
                    And (^Z005, 0xFF80, HMMN)
                    Store (HMMN, HMMX)
                    Return (RSRC)
                }
            }

            Device (AUDO)
            {
                Name (_ADR, 0x00070005)
                OperationRegion (SB75, PCI_Config, 0x00, 0x85)
                Field (SB75, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x3C), 
                    ACIR,   4
                }
            }

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

            Device (VIDO)
            {
                Name (_ADR, 0x00050000)
                Name (DOSA, 0x01)
                Name (LDCS, 0x00)
                Name (CDCS, 0x00)
                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

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

                Method (_DOS, 1, NotSerialized)
                {
                    Store (Arg0, DOSA)
                }

                Method (EDGS, 0, NotSerialized)
                {
                    Store (0x01, ^LCD._DGS)
                    Store (0x00, ^CRT._DGS)
                }

                Method (USTS, 0, NotSerialized)
                {
                    And (^LCD._DCS, 0xFFFFFFFD, ^LCD._DCS)
                    Or (^LCD._DCS, ShiftLeft (LDCS, 0x01), ^LCD._DCS)
                    EDGS ()
                }

                Method (SWIT, 0, NotSerialized)
                {
                    USTS ()
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Return (Package (0x02)
                    {
                        0x00010100, 
                        0x00010110
                    })
                }

                Device (LCD)
                {
                    Name (_ADR, 0x0110)
                    Name (_DCS, 0x1F)
                    Name (_DGS, 0x00)
                    Method (_DSS, 1, NotSerialized)
                    {
                        If (And (Arg0, 0x40000000))
                        {
                            And (Arg0, 0x01, LDCS)
                            If (And (Arg0, 0x80000000))
                            {
                                ^^USTS ()
                            }
                        }
                        Else
                        {
                            And (Arg0, 0x01, LDCS)
                            If (And (Arg0, 0x80000000))
                            {
                                ^^SWIT ()
                            }
                        }
                    }
                }

                Device (CRT)
                {
                    Name (_ADR, 0x0100)
                    Name (_DGS, 0x00)
                    Name (_DCS, 0x0F)
                    Method (_DSS, 1, NotSerialized)
                    {
                        If (And (Arg0, 0x40000000))
                        {
                            And (Arg0, 0x01, CDCS)
                            If (And (Arg0, 0x80000000))
                            {
                                ^^USTS ()
                            }
                        }
                        Else
                        {
                            And (Arg0, 0x01, CDCS)
                            If (And (Arg0, 0x80000000))
                            {
                                ^^SWIT ()
                            }
                        }
                    }
                }
            }

            Device (LANI)
            {
                Name (_ADR, 0x00080000)
            }

            Device (CRD0)
            {
                Name (_ADR, 0x000B0000)
                OperationRegion (CBD0, PCI_Config, 0x00, 0xC0)
                Field (CBD0, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x3C), 
                    CD3C,   8, 
                    Offset (0x44), 
                    CD44,   32, 
                    Offset (0x80), 
                    OPME,   1, 
                    Offset (0x8F), 
                    MF06,   4, 
                    Offset (0xA4), 
                    PWST,   2, 
                    Offset (0xA5), 
                    PMEE,   1, 
                        ,   6, 
                    PMST,   1
                }

                Method (_INI, 0, NotSerialized)
                {
                    Or (CD3C, 0xFF, CD3C)
                    Store (0x00, CD44)
                    Or (OPME, 0x01, OPME)
                    Or (MF06, 0x01, MF06)
                }
            }

            Device (CRD1)
            {
                Name (_ADR, 0x000B0001)
                OperationRegion (CBD1, PCI_Config, 0x00, 0xB4)
                Field (CBD1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x3C), 
                    CD3C,   8, 
                    Offset (0x44), 
                    CD44,   32, 
                    Offset (0x80), 
                    OPME,   1, 
                    Offset (0x8F), 
                    MF06,   4, 
                    Offset (0xA4), 
                    PWST,   2, 
                    Offset (0xA5), 
                    PMEE,   1, 
                        ,   6, 
                    PMST,   1
                }

                Method (_INI, 0, NotSerialized)
                {
                    Or (CD3C, 0xFF, CD3C)
                    Store (0x00, CD44)
                    Or (OPME, 0x01, OPME)
                    Or (MF06, 0x01, MF06)
                }
            }

            Device (USB0)
            {
                Name (_ADR, 0x000C0000)
                OperationRegion (NUD0, PCI_Config, 0x00, 0xE8)
                Field (NUD0, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x44), 
                    PMCR,   8, 
                    PMCS,   8
                }

                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Device (RHUB)
                {
                    Name (_ADR, 0x00)
                    Device (POT0)
                    {
                        Name (_ADR, 0x00)
                    }

                    Device (POT1)
                    {
                        Name (_ADR, 0x01)
                    }

                    Device (POT2)
                    {
                        Name (_ADR, 0x02)
                    }
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x000C0001)
                OperationRegion (NUD1, PCI_Config, 0x00, 0xE8)
                Field (NUD1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x44), 
                    PMCR,   8, 
                    PMCS,   8
                }

                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Device (RHUB)
                {
                    Name (_ADR, 0x00)
                    Device (POT0)
                    {
                        Name (_ADR, 0x00)
                    }

                    Device (POT1)
                    {
                        Name (_ADR, 0x01)
                    }
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x000C0002)
                OperationRegion (NUD2, PCI_Config, 0x00, 0xE8)
                Field (NUD2, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x44), 
                    PMCR,   8, 
                    PMCS,   8
                }

                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
                Device (RHUB)
                {
                    Name (_ADR, 0x00)
                    Device (POT0)
                    {
                        Name (_ADR, 0x00)
                    }

                    Device (POT1)
                    {
                        Name (_ADR, 0x01)
                    }

                    Device (POT2)
                    {
                        Name (_ADR, 0x02)
                    }

                    Device (POT3)
                    {
                        Name (_ADR, 0x03)
                    }

                    Device (POT4)
                    {
                        Name (_ADR, 0x04)
                    }
                }
            }
        }

        Mutex (VSMX, 0x00)
        Method (VSMI, 1, Serialized)
        {
            Acquire (VSMX, 0xFFFF)
            Store (Arg0, \_SB.PCI0.PM.SCMD)
            Release (VSMX)
        }
    }

    Scope (\_SB.PCI0)
    {
        OperationRegion (LRCR, PCI_Config, 0xA8, 0x04)
        Field (LRCR, ByteAcc, NoLock, Preserve)
        {
            LRON,   1, 
            LRRV,   3, 
            LREN,   1
        }
    }

    Scope (\_TZ)
    {
        Name (TSCP, 0x00)
        Name (L0ST, 0x00)
        Name (L1ST, 0x00)
        Name (L2ST, 0x00)
        Name (TSCI, 0x00)
        PowerResource (LRP0, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Store ("LRP0 _STA", Debug)
                Return (L0ST)
            }

            Method (_ON, 0, Serialized)
            {
                If (TSCI)
                {
                    Store ("LRP0 _ON", Debug)
                    Store (One, L0ST)
                    Store (0x05, \_SB.PCI0.LRRV)
                    Store (One, \_SB.PCI0.LREN)
                }
            }

            Method (_OFF, 0, Serialized)
            {
                If (TSCI)
                {
                    Store ("LRP0 _OFF", Debug)
                    Store (Zero, L0ST)
                    If (LOr (L1ST, L2ST))
                    {
                        If (L1ST)
                        {
                            Store (0x06, \_SB.PCI0.LRRV)
                        }
                        Else
                        {
                            Store (0x07, \_SB.PCI0.LRRV)
                        }
                    }
                    Else
                    {
                        Store (Zero, \_SB.PCI0.LREN)
                    }
                }
            }
        }

        PowerResource (LRP1, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Store ("LRP1 _STA", Debug)
                Return (L1ST)
            }

            Method (_ON, 0, Serialized)
            {
                If (LNot (L0ST))
                {
                    If (TSCI)
                    {
                        Store ("LRP1 _ON", Debug)
                        Store (One, L1ST)
                        Store (0x06, \_SB.PCI0.LRRV)
                        Store (One, \_SB.PCI0.LREN)
                    }
                }
            }

            Method (_OFF, 0, Serialized)
            {
                If (TSCI)
                {
                    Store ("LRP1 _OFF", Debug)
                    Store (Zero, L1ST)
                    If (LOr (L0ST, L2ST))
                    {
                        If (L0ST)
                        {
                            Store (Zero, L0ST)
                            Store (0x07, \_SB.PCI0.LRRV)
                            Store (One, L2ST)
                        }
                        Else
                        {
                            Store (0x07, \_SB.PCI0.LRRV)
                        }
                    }
                    Else
                    {
                        Store (Zero, \_SB.PCI0.LREN)
                    }
                }
            }
        }

        PowerResource (LRP2, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Store ("LRP2 _STA", Debug)
                Return (L2ST)
            }

            Method (_ON, 0, Serialized)
            {
                If (LNot (LOr (L0ST, L1ST)))
                {
                    If (TSCI)
                    {
                        Store ("LRP2 _ON", Debug)
                        Store (One, L2ST)
                        Store (0x07, \_SB.PCI0.LRRV)
                        Store (One, \_SB.PCI0.LREN)
                    }
                }
            }

            Method (_OFF, 0, Serialized)
            {
                If (TSCI)
                {
                    Store ("LRP2 _OFF", Debug)
                    Store (Zero, L2ST)
                    Store (Zero, L1ST)
                    Store (Zero, L0ST)
                    Store (Zero, \_SB.PCI0.LREN)
                    If (LOr (L0ST, L1ST))
                    {
                        If (L0ST)
                        {
                            Store (0x05, \_SB.PCI0.LRRV)
                        }
                        Else
                        {
                            Store (0x06, \_SB.PCI0.LRRV)
                        }
                    }
                    Else
                    {
                        Store (Zero, \_SB.PCI0.LREN)
                    }
                }
            }
        }

        Device (FAN0)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x01)
            Name (_PR0, Package (0x01)
            {
                LRP0
            })
        }

        Device (FAN1)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x02)
            Name (_PR0, Package (0x01)
            {
                LRP1
            })
        }

        Device (FAN2)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x03)
            Name (_PR0, Package (0x01)
            {
                LRP2
            })
        }

        ThermalZone (THRM)
        {
            Name (SCIF, 0x00)
            Method (_AC0, 0, NotSerialized)
            {
                Store ("_AC0", Debug)
                Return (GACX (0x42, 0x5E))
            }

            Name (_AL0, Package (0x01)
            {
                FAN0
            })
            Method (_AC1, 0, NotSerialized)
            {
                Store ("_AC1", Debug)
                Return (GACX (0x3E, 0x56))
            }

            Name (_AL1, Package (0x01)
            {
                FAN1
            })
            Method (_AC2, 0, NotSerialized)
            {
                Store ("_AC2", Debug)
                Return (GACX (0x3A, 0x4E))
            }

            Name (_AL2, Package (0x01)
            {
                FAN2
            })
            Method (_CRT, 0, NotSerialized)
            {
                Store ("_CRT", Debug)
                Return (KELV (0x64))
            }

            Method (_TMP, 0, NotSerialized)
            {
                If (\ECFL)
                {
                    Acquire (MUT0, 0xFFFF)
                    Store (\_SB.PCI0.PIB.EC.TMP1, Local0)
                    Release (MUT0)
                    Return (KELV (Local0))
                }
                Else
                {
                    Return (KELV (0x3C))
                }
            }

            Method (KELV, 1, NotSerialized)
            {
                Multiply (Arg0, 0x0A, Local0)
                Add (Local0, 0x0AAC, Local0)
                Return (Local0)
            }

            Method (_SCP, 1, NotSerialized)
            {
                Store (Arg0, TSCP)
                Notify (\_TZ.THRM, 0x81)
            }

            Method (GACX, 2, Serialized)
            {
                If (LEqual (\_SB.WMID.STD, 0x01))
                {
                    Return (KELV (Arg0))
                }
                Else
                {
                    Return (KELV (Arg1))
                }
            }
        }
    }

    Method (ITOS, 1, NotSerialized)
    {
        Store ("", Local0)
        Store (0x04, Local1)
        While (Local1)
        {
            Decrement (Local1)
            And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
            Store (DerefOf (Index (CHAR, Local4)), Local2)
            Concatenate (Local0, Local2, Local5)
            Store (Local5, Local0)
        }

        Return (Local0)
    }

    Name (CHAR, Package (0x10)
    {
        "0", 
        "1", 
        "2", 
        "3", 
        "4", 
        "5", 
        "6", 
        "7", 
        "8", 
        "9", 
        "A", 
        "B", 
        "C", 
        "D", 
        "E", 
        "F"
    })
    Method (MIN, 2, NotSerialized)
    {
        If (LLess (Arg0, Arg1))
        {
            Return (Arg0)
        }
        Else
        {
            Return (Arg1)
        }
    }

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

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

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

            Increment (Local4)
        }

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