/*
RSD PTR: Checksum=48, OEMID=ACPIAM, RsdtAddress=0x07ff0000
 */
/*
RSDT: Length=44, Revision=1, Checksum=243,
	OEMID=A M I, OEM Table ID=OEMRSDT, OEM Revision=0x8000314,
	Creator ID=MSFT, Creator Revision=0x97
 */
/*
	Entries={ 0x07ff0200, 0x07fff040 }
 */
/*
	DSDT=0x7ff0300
	INT_MODEL=PIC
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xe1, ACPI_DISABLE=0x1e, S4BIOS_REQ=0x0
	PM1a_EVT_BLK=0x400-0x403
	PM1a_CNT_BLK=0x404-0x405
	PM2_CNT_BLK=0x22-0x22
	PM2_TMR_BLK=0x408-0x40b
	PM2_GPE0_BLK=0x40c-0x40f
	P_LVL2_LAT=101ms, P_LVL3_LAT=1001ms
	FLUSH_SIZE=1024, FLUSH_STRIDE=16
	DUTY_OFFSET=0, DUTY_WIDTH=0
	DAY_ALRM=13, MON_ALRM=0, CENTURY=0
	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4}
 */
/*
DSDT: Length=8347, Revision=1, Checksum=110,
	OEMID=AMIBI, OEM Table ID=AMIBI002, OEM Revision=0x2,
	Creator ID=INTL, Creator Revision=0x2002026
 */
DefinitionBlock (	"acpi_dsdt.aml",	//Output filename	"DSDT",		//Signature	0x1,			//DSDT Revision	"AMIBI",			//OEMID	"AMIBI002",			//TABLE ID	0x2			//OEM Revision
)

{
OperationRegion(BIOS, SystemMemory, 0x07fff064, 0xff)
Field(BIOS, ByteAcc, NoLock, Preserve) {
    SS1_,	1,
    SS2_,	1,
    SS3_,	1,
    SS4_,	1,
    Offset(0x1),
    IOST,	16,
    SPIO,	16,
    PMBS,	16,
    PMLN,	8,
    SMBS,	16,
    SMLN,	8,
    IO1B,	16,
    IO1L,	8,
    IO2B,	16,
    IO2L,	8,
    TOPM,	32,
    ROMS,	32,
    APCB,	32,
    APCL,	16,
    MG1B,	32,
    MG1L,	32,
    MG2B,	32,
    MG2L,	32
}
Method(RRIO, 4) {
    Store("RRIO", Debug)
}
Method(RDMA, 3) {
    Store("rDMA", Debug)
}
Name(PICM, 0x0)
Method(_PIC, 1) {
    If(Arg0) {
        Store(0xaa, DBG8)
    }
    Else {
        Store(0x55, DBG8)
    }
    Store(Arg0, PICM)
}
Name(OSFL, 0x1)
Method(MCTH, 2) {
    If(LLess(SizeOf(Arg0), SizeOf(Arg1))) {
        Return(Zero)
    }
    Add(SizeOf(Arg0), 0x1, Local0)
    Name(BUF0, Buffer(Local0) { })
    Name(BUF1, Buffer(Local0) { })
    Store(Arg0, BUF0)
    Store(Arg1, BUF1)
    While(Local0) {
        Decrement(Local0)
        If(LNot(LEqual(DerefOf(Index(BUF0, Local0, )), DerefOf(Index(BUF1, Local0, ))))) {
            Return(Zero)
        }
    }
    Return(One)
}
Method(GPRW, 2) {
    Name(PRWP, Package(0x2) {
        0x0,
        0x0,
    })
    Store(Arg0, Index(PRWP, 0x0, ))
    Store(Arg1, Index(PRWP, 0x1, ))
    Store(0x0, Local0)
    Or(Local0, ShiftLeft(SS1_, 0x1, ), Local0)
    Or(Local0, ShiftLeft(SS2_, 0x2, ), Local0)
    Or(Local0, ShiftLeft(SS3_, 0x3, ), Local0)
    Or(Local0, ShiftLeft(SS4_, 0x4, ), Local0)
    If(And(ShiftLeft(0x1, Arg1, ), Local0, )) {
    }
    Else {
        ShiftRight(Local0, 0x1, Local0)
        If(LOr(LEqual(OSFL, 0x1), LEqual(OSFL, 0x2))) {
            FindSetLeftBit(Local0, Index(PRWP, 0x1, ))
        }
        Else {
            FindSetRightBit(Local0, Index(PRWP, 0x1, ))
        }
    }
    Return(PRWP)
}
Name(WAKP, Package(0x2) {
    0x0,
    0x0,
})
OperationRegion(DEB0, SystemIO, 0x80, 0x1)
Field(DEB0, ByteAcc, NoLock, Preserve) {
    DBG8,	8
}
OperationRegion(DEB1, SystemIO, 0x90, 0x2)
Field(DEB1, WordAcc, NoLock, Preserve) {
    DBG9,	16
}
Scope(\_PR_) {
    Processor(CPU1, 1, 0x0, 0x0) {
    }
}
Scope(\_SB_) {
    Name(PR00, Package(0x21) {
        Package(0x4) {
            0x0007ffff,
            0x3,
            LNKD,
            0x0,
        },
        Package(0x4) {
            0x0008ffff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x0008ffff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x0008ffff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x0008ffff,
            0x3,
            LNKD,
            0x0,
        },
        Package(0x4) {
            0x0009ffff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x0009ffff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x0009ffff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x0009ffff,
            0x3,
            LNKD,
            0x0,
        },
        Package(0x4) {
            0x000affff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x000affff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x000affff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x000affff,
            0x3,
            LNKD,
            0x0,
        },
        Package(0x4) {
            0x000bffff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x000bffff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x000bffff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x000bffff,
            0x3,
            LNKD,
            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,
        },
        Package(0x4) {
            0x000dffff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x000dffff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x000dffff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x000dffff,
            0x3,
            LNKD,
            0x0,
        },
        Package(0x4) {
            0x000effff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x000effff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x000effff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x000effff,
            0x3,
            LNKD,
            0x0,
        },
        Package(0x4) {
            0x000fffff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x000fffff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x000fffff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x000fffff,
            0x3,
            LNKD,
            0x0,
        },
    })
    Name(PRSA, Buffer(0x6) {0x23, 0xb8, 0xde, 0x18, 0x79, 0x0 })
    Name(PRSB, Buffer(0x6) {0x23, 0xb8, 0xde, 0x18, 0x79, 0x0 })
    Name(PRSC, Buffer(0x6) {0x23, 0xb8, 0xde, 0x18, 0x79, 0x0 })
    Name(PRSD, Buffer(0x6) {0x23, 0xb8, 0xde, 0x18, 0x79, 0x0 })
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Name(_BBN, 0x0)
        Name(_UID, 0x0)
        Method(_PRT) {
            Return(PR00)
        }
        Device(IDE0) {
            Name(_ADR, 0x00070001)
            Name(REGF, 0x1)
            Method(_REG, 2) {
                If(LEqual(Arg0, 0x2)) {
                    Store(Arg1, REGF)
                }
            }
            Name(TIM0, Package(0x6) {
                Package(0x4) {
                    0x78,
                    0xb4,
                    0xf0,
                    0x0384,
                },
                Package(0x4) {
                    0x23,
                    0x21,
                    0x10,
                    0x0,
                },
                Package(0x4) {
                    0xb,
                    0x9,
                    0x4,
                    0x0,
                },
                Package(0x4) {
                    0x70,
                    0x49,
                    0x36,
                    0x36,
                },
                Package(0x4) {
                    0x4,
                    0x3,
                    0x2,
                    0x0,
                },
                Package(0x4) {
                    0x2,
                    0x1,
                    0x0,
                    0x0,
                },
            })
            Name(TMD0, Buffer(0x14) { })
            CreateDWordField(TMD0, 0x0, PIO0)
            CreateDWordField(TMD0, 0x4, DMA0)
            CreateDWordField(TMD0, 0x8, PIO1)
            CreateDWordField(TMD0, 0xc, DMA1)
            CreateDWordField(TMD0, 0x10, CHNF)
            OperationRegion(CFG2, PCI_Config, 0x40, 0x10)
            Field(CFG2, DWordAcc, NoLock, Preserve) {
                TIMP,	16,
                TIMS,	16,
                STMP,	4,
                STMS,	4,
                Offset(0x8),
                UDMP,	2,
                UDMS,	2,
                Offset(0xa),
                UDTP,	6,
                Offset(0xb),
                UDTS,	6
            }
            Name(GTIM, 0x0)
            Name(GSTM, 0x0)
            Name(GUDM, 0x0)
            Name(GUDT, 0x0)
            Device(CHN0) {
                Name(_ADR, 0x0)
                Method(_GTM) {
                    Return(GTM_(TIMP, STMP, UDMP, UDTP))
                }
                Method(_STM, 3) {
                    Store(Arg0, Debug)
                    Store(Arg0, TMD0)
                    Store(TIMP, GTIM)
                    Store(UDTP, GUDT)
                    If(STM_()) {
                        Store(GTIM, TIMP)
                        Store(GSTM, STMP)
                        Store(GUDM, UDMP)
                        Store(GUDT, UDTP)
                    }
                    Store(GTF_(0x0, Arg1), ATA0)
                    Store(GTF_(0x1, Arg2), ATA1)
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Return(RATA(ATA0))
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                    Method(_GTF) {
                        Return(RATA(ATA1))
                    }
                }
            }
            Device(CHN1) {
                Name(_ADR, 0x1)
                Method(_GTM) {
                    Return(GTM_(TIMS, STMS, UDMS, UDTS))
                }
                Method(_STM, 3) {
                    Store(Arg0, Debug)
                    Store(Arg0, TMD0)
                    Store(TIMS, GTIM)
                    Store(UDTS, GUDT)
                    If(STM_()) {
                        Store(GTIM, TIMS)
                        Store(GSTM, STMS)
                        Store(GUDM, UDMS)
                        Store(GUDT, UDTS)
                    }
                    Store(GTF_(0x0, Arg1), ATA2)
                    Store(GTF_(0x1, Arg2), ATA3)
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Return(RATA(ATA2))
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                    Method(_GTF) {
                        Return(RATA(ATA3))
                    }
                }
            }
            Method(GTM_, 4, Serialized) {
                Store(Ones, PIO0)
                Store(PIO0, PIO1)
                Store(PIO0, DMA0)
                Store(PIO0, DMA1)
                Store(Zero, CHNF)
                If(REGF) {
                }
                Else {
                    Return(TMD0)
                }
                If(And(Arg0, 0x2, )) {
                    Or(CHNF, 0x2, CHNF)
                }
                ShiftRight(And(Arg0, 0x3300, ), 0x8, Local4)
                Store(Match(DerefOf(Index(TIM0, 0x1, )), MLE, Local4, MTR, 0x0, 0x0), Local5)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x0, )), Local5, )), Local6)
                Store(Local6, DMA0)
                If(And(Arg0, 0x8, )) {
                    Store(0x0384, PIO0)
                }
                Else {
                    Store(Local6, PIO0)
                }
                If(And(Arg0, 0x20, )) {
                    Or(CHNF, 0x8, CHNF)
                }
                If(And(Arg0, 0x4000, )) {
                    Or(CHNF, 0x10, CHNF)
                    Store(Match(DerefOf(Index(TIM0, 0x2, )), MLE, Arg1, MTR, 0x0, 0x0), Local4)
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x0, )), Local4, )), Local5)
                    Store(Local5, DMA1)
                    If(And(Arg0, 0x80, )) {
                        Store(0x0384, PIO1)
                    }
                    Else {
                        Store(Local5, PIO1)
                    }
                }
                If(And(Arg2, 0x1, )) {
                    And(Arg3, 0x3, Local5)
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x3, )), Local5, )), DMA0)
                    Or(CHNF, 0x1, CHNF)
                }
                If(And(Arg2, 0x2, )) {
                    And(ShiftRight(Arg3, 0x4, ), 0x3, Local5)
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x3, )), Local5, )), DMA1)
                    Or(CHNF, 0x4, CHNF)
                }
                Store(TMD0, Debug)
                Return(TMD0)
            }
            Method(STM_, 0, Serialized) {
                If(REGF) {
                }
                Else {
                    Return(0x0)
                }
                And(GTIM, 0x8044, GTIM)
                Store(0x0, GUDM)
                And(GUDT, 0xcc, GUDT)
                If(And(CHNF, 0x1, )) {
                    Store(Match(DerefOf(Index(TIM0, 0x3, )), MLE, DMA0, MTR, 0x0, 0x0), Local0)
                    If(LGreater(Local0, 0x2)) {
                        Store(0x2, Local0)
                    }
                    Or(GUDT, Local0, GUDT)
                    Or(GUDM, 0x1, GUDM)
                }
                Else {
                    If(Or(LEqual(PIO0, Ones), LEqual(PIO0, 0x0), )) {
                        If(And(LLess(DMA0, Ones), LGreater(DMA0, 0x0), )) {
                            Store(DMA0, PIO0)
                            Or(GTIM, 0x8, GTIM)
                        }
                    }
                }
                If(And(CHNF, 0x4, )) {
                    Store(Match(DerefOf(Index(TIM0, 0x3, )), MLT, DMA1, MTR, 0x0, 0x0), Local0)
                    If(LGreater(Local0, 0x2)) {
                        Store(0x2, Local0)
                    }
                    Or(GUDT, ShiftLeft(Local0, 0x4, ), GUDT)
                    Or(GUDM, 0x2, GUDM)
                }
                Else {
                    If(Or(LEqual(PIO1, Ones), LEqual(PIO1, 0x0), )) {
                        If(And(LLess(DMA1, Ones), LGreater(DMA1, 0x0), )) {
                            Store(DMA1, PIO1)
                            Or(GTIM, 0x80, GTIM)
                        }
                    }
                }
                If(And(CHNF, 0x2, )) {
                    Or(GTIM, 0x3, GTIM)
                }
                If(And(CHNF, 0x8, )) {
                    Or(GTIM, 0x30, GTIM)
                }
                And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIO0, MTR, 0x0, 0x0), 0x3, Local0)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x1, )), Local0, )), Local1)
                ShiftLeft(Local1, 0x8, Local2)
                Or(GTIM, Local2, GTIM)
                If(And(CHNF, 0x10, )) {
                    Or(GTIM, 0x4000, GTIM)
                    And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIO1, MTR, 0x0, 0x0), 0x3, Local0)
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x2, )), Local0, )), GSTM)
                }
                Return(0x1)
            }
            Name(AT01, Buffer(0x7) {0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef })
            Name(AT02, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x90 })
            Name(AT03, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc6 })
            Name(AT04, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x91 })
            Name(ATA0, Buffer(0x1d) { })
            Name(ATA1, Buffer(0x1d) { })
            Name(ATA2, Buffer(0x1d) { })
            Name(ATA3, Buffer(0x1d) { })
            Name(ATAB, Buffer(0x1d) { })
            CreateByteField(ATAB, 0x0, CMDC)
            Method(GTFB, 3, Serialized) {
                Multiply(CMDC, 0x38, Local0)
                Add(Local0, 0x8, Local1)
                CreateField(ATAB, Local1, 0x38, CMDX)
                Multiply(CMDC, 0x7, Local0)
                CreateByteField(ATAB, Add(Local0, 0x2, ), A001)
                CreateByteField(ATAB, Add(Local0, 0x6, ), A005)
                Store(Arg0, CMDX)
                Store(Arg1, A001)
                Store(Arg2, A005)
                Increment(CMDC)
            }
            Method(GTF_, 2, Serialized) {
                Store(Arg1, Debug)
                Store(0x0, CMDC)
                Name(ID00, 0x80)
                Name(ID49, 0x0c00)
                Name(ID59, 0x0)
                Name(ID53, 0x4)
                Name(ID63, 0x0f00)
                Name(ID88, 0x0f00)
                Name(IRDY, 0x1)
                Name(PIOT, 0x0)
                Name(DMAT, 0x0)
                If(LEqual(SizeOf(Arg1), 0x0200)) {
                    CreateWordField(Arg1, 0x62, IW49)
                    Store(IW49, ID49)
                    CreateWordField(Arg1, 0x6a, IW53)
                    Store(IW53, ID53)
                    CreateWordField(Arg1, 0x7e, IW63)
                    Store(IW63, ID63)
                    CreateWordField(Arg1, 0x76, IW59)
                    Store(IW59, ID59)
                    CreateWordField(Arg1, 0xb0, IW88)
                    Store(IW88, ID88)
                }
                Store(0xa0, Local7)
                If(Arg0) {
                    Store(0xb0, Local7)
                    And(CHNF, 0x8, IRDY)
                    If(And(CHNF, 0x10, )) {
                        Store(PIO1, PIOT)
                    }
                    Else {
                        Store(PIO0, PIOT)
                    }
                    If(And(CHNF, 0x4, )) {
                        If(And(CHNF, 0x10, )) {
                            Store(DMA1, DMAT)
                        }
                        Else {
                            Store(DMA0, DMAT)
                        }
                    }
                }
                Else {
                    And(CHNF, 0x2, IRDY)
                    Store(PIO0, PIOT)
                    If(And(CHNF, 0x1, )) {
                        Store(DMA0, DMAT)
                    }
                }
                If(LAnd(LAnd(And(ID53, 0x4, ), And(ID88, 0xff00, )), DMAT)) {
                    Store(Match(DerefOf(Index(TIM0, 0x3, )), MLE, DMAT, MTR, 0x0, 0x0), Local1)
                    If(LGreater(Local1, 0x2)) {
                        Store(0x2, Local1)
                    }
                    GTFB(AT01, Or(0x40, Local1, ), Local7)
                }
                Else {
                    If(LAnd(And(ID63, 0xff00, ), PIOT)) {
                        And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIOT, MTR, 0x0, 0x0), 0x3, Local0)
                        Or(0x20, DerefOf(Index(DerefOf(Index(TIM0, 0x5, )), Local0, )), Local1)
                        GTFB(AT01, Local1, Local7)
                    }
                }
                If(IRDY) {
                    And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIOT, MTR, 0x0, 0x0), 0x3, Local0)
                    Or(0x8, DerefOf(Index(DerefOf(Index(TIM0, 0x4, )), Local0, )), Local1)
                    GTFB(AT01, Local1, Local7)
                }
                Else {
                    If(And(ID49, 0x0400, )) {
                        GTFB(AT01, 0x1, Local7)
                    }
                }
                If(LAnd(And(ID59, 0x0100, ), And(ID59, 0xff, ))) {
                    GTFB(AT03, And(ID59, 0xff, ), Local7)
                }
                Store(ATAB, Debug)
                Return(ATAB)
            }
            Method(RATA, 1) {
                CreateByteField(Arg0, 0x0, CMDN)
                Multiply(CMDN, 0x38, Local0)
                CreateField(Arg0, 0x8, Local0, RETB)
                Store(RETB, Debug)
                Return(RETB)
            }
        }
        Device(SBRG) {
            Name(_ADR, 0x00070000)
            Device(PIC_) {
                Name(_HID, 0xd041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x0, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x0, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0 })
            }
            Device(DMAD) {
                Name(_HID, 0x0002d041)
                Name(_CRS, Buffer(0x35) {0x2a, 0x10, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x0, 0x3, 0x47, 0x1, 0x87, 0x0, 0x87, 0x0, 0x0, 0x1, 0x47, 0x1, 0x89, 0x0, 0x89, 0x0, 0x0, 0x3, 0x47, 0x1, 0x8f, 0x0, 0x8f, 0x0, 0x0, 0x1, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x0, 0x20, 0x79, 0x0 })
            }
            Device(TMR_) {
                Name(_HID, 0x0001d041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x0, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
            }
            Device(RTC0) {
                Name(_HID, 0x000bd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x0, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
            }
            Device(PS2K) {
                Name(_HID, 0x0303d041)
                Name(_CID, 0x0b03d041)
                Method(_STA) {
                    ShiftLeft(0x1, 0xa, Local0)
                    If(And(IOST, Local0, )) {
                        Return(0xf)
                    }
                    Return(0x0)
                }
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x2, 0x0, 0x79, 0x0 })
            }
            Device(PS2M) {
                Name(_HID, 0x030fd041)
                Name(_CID, 0x130fd041)
                Method(_STA) {
                    ShiftLeft(0x1, 0xc, Local0)
                    If(And(IOST, Local0, )) {
                        Return(0xf)
                    }
                    Return(0x0)
                }
                Name(CRS1, Buffer(0x5) {0x22, 0x0, 0x10, 0x79, 0x0 })
                Name(CRS2, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x0, 0x10, 0x79, 0x0 })
                Method(_CRS) {
                    ShiftLeft(0x1, 0xa, Local0)
                    If(And(IOST, Local0, )) {
                        Return(CRS1)
                    }
                    Else {
                        Return(CRS2)
                    }
                }
            }
            Device(SPKR) {
                Name(_HID, 0x0008d041)
                Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x0, 0x1, 0x79, 0x0 })
            }
            Device(COPR) {
                Name(_HID, 0x040cd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x0, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
            }
            Device(UAR1) {
                Name(_UID, 0x1)
                Name(_HID, 0x0105d041)
                Method(_STA) {
                    Return(DSTA(0x0))
                }
                Method(_DIS) {
                    DCNT(0x0, 0x0)
                }
                Method(_CRS) {
                    Return(DCRS(0x0))
                }
                Method(_SRS, 1) {
                    DSRS(Arg0, 0x0)
                }
                Method(_PRS) {
                    Return(CMPR)
                }
                Name(CMPR, Buffer(0x36) {0x22, 0xf8, 0x1c, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x38, 0x79, 0x0 })
            }
            Device(UAR2) {
                Name(_UID, 0x2)
                Name(_HID, 0x0105d041)
                Method(_STA) {
                    Return(DSTA(0x1))
                }
                Method(_DIS) {
                    DCNT(0x1, 0x0)
                }
                Method(_CRS) {
                    Return(DCRS(0x1))
                }
                Method(_SRS, 1) {
                    DSRS(Arg0, 0x1)
                }
                Method(_PRS) {
                    Return(CMPR)
                }
                Name(CMPR, Buffer(0x36) {0x22, 0xf8, 0x1c, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x38, 0x79, 0x0 })
            }
            Device(IRDA) {
                Name(_HID, 0x1005d041)
                Name(_UID, 0x3)
                Method(_STA) {
                    Return(DSTA(0x10))
                }
                Method(_DIS) {
                    DCNT(0x10, 0x0)
                }
                Method(_CRS) {
                    Return(DCRS(0x10))
                }
                Method(_SRS, 1) {
                    DSRS(Arg0, 0x10)
                }
                Method(_PRS) {
                    Return(CMPR)
                }
                Name(CMPR, Buffer(0x66) {0x22, 0xf8, 0x1c, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x30, 0x2a, 0xe, 0x0, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0xe, 0x0, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x30, 0x2a, 0xe, 0x0, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x30, 0x2a, 0xe, 0x0, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x38, 0x79, 0x0 })
            }
            Device(FDC_) {
                Name(_HID, 0x0007d041)
                Name(_FDE, Package(0x5) {
                    0x1,
                    0x0,
                    0x2,
                    0x2,
                    0x2,
                })
                Method(_STA) {
                    Return(DSTA(0x3))
                }
                Method(_DIS) {
                    DCNT(0x3, 0x0)
                }
                Method(_CRS) {
                    DCRS(0x3)
                    Store(IRQM, IRQE)
                    Store(DMAM, DMAE)
                    Store(IO11, IO21)
                    Store(IO12, IO22)
                    Store(0x6, LEN2)
                    Add(IO21, 0x7, IO31)
                    Store(IO31, IO32)
                    Store(0x1, LEN3)
                    Return(CRS2)
                }
                Method(_SRS, 1) {
                    DSRS(Arg0, 0x3)
                }
                Name(_PRS, Buffer(0x49) {0x31, 0x0, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x30, 0x22, 0xf8, 0x1c, 0x2a, 0xe, 0x0, 0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x30, 0x22, 0xf8, 0x1c, 0x2a, 0xe, 0x0, 0x47, 0x1, 0x70, 0x3, 0x70, 0x3, 0x1, 0x6, 0x47, 0x1, 0x77, 0x3, 0x77, 0x3, 0x1, 0x1, 0x38, 0x79, 0x0 })
            }
            Device(LPTE) {
                Method(_HID) {
                    If(LPTM(0x2)) {
                        Return(0x0104d041)
                    }
                    Else {
                        Return(0x0004d041)
                    }
                }
                Method(_STA) {
                    Return(DSTA(0x2))
                }
                Method(_DIS) {
                    DCNT(0x2, 0x0)
                }
                Method(_CRS) {
                    DCRS(0x2)
                    If(LPTM(0x2)) {
                        Store(IRQM, IRQE)
                        Store(DMAM, DMAE)
                        Store(IO11, IO21)
                        Store(IO12, IO22)
                        Store(LEN1, LEN2)
                        Add(IO21, 0x0400, IO31)
                        Store(IO31, IO32)
                        Store(LEN2, LEN3)
                        Return(CRS2)
                    }
                    Else {
                        Return(CRS1)
                    }
                }
                Method(_SRS, 1) {
                    DSRS(Arg0, 0x2)
                }
                Method(_PRS) {
                    If(LPTM(0x2)) {
                        Return(EPPR)
                    }
                    Else {
                        Return(LPPR)
                    }
                }
                Name(LPPR, Buffer(0x5d) {0x30, 0x22, 0xf8, 0x1c, 0x2a, 0x0, 0x0, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x1, 0x8, 0x30, 0x22, 0xf8, 0x1c, 0x2a, 0x0, 0x0, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x30, 0x22, 0xf8, 0x1c, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x4, 0x30, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x1, 0x8, 0x30, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x30, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x4, 0x38, 0x79, 0x0 })
                Name(EPPR, Buffer(0x7e) {0x22, 0xf8, 0x1c, 0x30, 0x2a, 0xe, 0x0, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x1, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x1, 0x8, 0x30, 0x2a, 0xe, 0x0, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x1, 0x8, 0x30, 0x2a, 0xe, 0x0, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x4, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x1, 0x4, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x1, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x1, 0x8, 0x30, 0x2a, 0x0, 0x0, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x4, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x1, 0x4, 0x38, 0x79, 0x0 })
            }
            Name(DCAT, Package(0x15) {
                0x2,
                0x3,
                0x1,
                0x0,
                0xff,
                0x7,
                0xff,
                0xff,
                0x7,
                0xff,
                0xff,
                0xff,
                0xff,
                0xff,
                0xff,
                0xff,
                0x6,
                0xff,
                0xff,
                0xff,
                0xff,
            })
            Method(ENFG, 1) {
                Store(0x87, INDX)
                Store(0x87, INDX)
                Store(Arg0, LDN_)
            }
            Method(EXFG) {
                Store(0xaa, INDX)
            }
            Method(LPTM, 1) {
                ENFG(CGLD(Arg0))
                And(OPT1, 0x2, Local0)
                EXFG()
                Return(Local0)
            }
            Method(UHID, 1) {
                If(LEqual(Arg0, 0x1)) {
                    ENFG(CGLD(Arg0))
                    And(OPT2, 0x38, Local0)
                    EXFG()
                    If(Local0) {
                        Return(0x1005d041)
                    }
                }
                Return(0x0105d041)
            }
            Method(SIOS, 1) {
                Store("SIOS", Debug)
            }
            Method(SIOW, 1) {
                Store("SIOW", Debug)
            }
            Method(SIOH) {
                Store("SIOH", Debug)
            }
            OperationRegion(IOID, SystemIO, SPIO, 0x2)
            Field(IOID, ByteAcc, NoLock, Preserve) {
                INDX,	8,
                DATA,	8
            }
            IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                Offset(0x7),
                LDN_,	8,
                Offset(0x22),
                FDCP,	1,
                ,	2,
                LPTP,	1,
                URAP,	1,
                URBP,	1,
                Offset(0x30),
                ACTR,	8,
                Offset(0x60),
                IOAH,	8,
                IOAL,	8,
                IOH2,	8,
                IOL2,	8,
                Offset(0x70),
                INTR,	8,
                Offset(0x74),
                DMCH,	8,
                Offset(0xf0),
                OPT1,	8,
                OPT2,	8,
                OPT3,	8
            }
            Method(CGLD, 1) {
                Return(DerefOf(Index(DCAT, Arg0, )))
            }
            Method(DSTA, 1) {
                Store(0x0, Local0)
                ShiftLeft(0x1, Arg0, Local1)
                If(And(IOST, Local1, )) {
                    ENFG(CGLD(Arg0))
                    If(ACTR) {
                        Store(0xf, Local0)
                    }
                    Else {
                        Store(0xd, Local0)
                    }
                    EXFG()
                }
                Return(Local0)
            }
            Method(DCNT, 2) {
                ENFG(CGLD(Arg0))
                ShiftLeft(IOAH, 0x8, Local1)
                Or(IOAL, Local1, Local1)
                RRIO(Arg0, Arg1, Local1, 0x8)
                If(LAnd(LLess(DMCH, 0x4), LNot(LEqual(And(DMCH, 0x3, Local1), 0x0)))) {
                    RDMA(Arg0, Arg1, Increment(Local1))
                }
                Store(Arg1, ACTR)
                EXFG()
            }
            Name(CRS1, Buffer(0x10) {0x22, 0x8, 0x0, 0x2a, 0x8, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x79, 0x0 })
            CreateWordField(CRS1, 0x1, IRQM)
            CreateByteField(CRS1, 0x4, DMAM)
            CreateWordField(CRS1, 0x8, IO11)
            CreateWordField(CRS1, 0xa, IO12)
            CreateByteField(CRS1, 0xd, LEN1)
            Name(CRS2, Buffer(0x18) {0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x79, 0x0 })
            CreateWordField(CRS2, 0x1, IRQE)
            CreateByteField(CRS2, 0x4, DMAE)
            CreateWordField(CRS2, 0x8, IO21)
            CreateWordField(CRS2, 0xa, IO22)
            CreateByteField(CRS2, 0xd, LEN2)
            CreateWordField(CRS2, 0x10, IO31)
            CreateWordField(CRS2, 0x12, IO32)
            CreateByteField(CRS2, 0x15, LEN3)
            Method(DCRS, 1) {
                ENFG(CGLD(Arg0))
                ShiftLeft(IOAH, 0x8, IO11)
                Or(IOAL, IO11, IO11)
                Store(IO11, IO12)
                Subtract(FindSetRightBit(IO11, Zero), 0x1, Local0)
                ShiftLeft(0x1, Local0, LEN1)
                If(INTR) {
                    ShiftLeft(0x1, INTR, IRQM)
                }
                Else {
                    Store(0x0, IRQM)
                }
                If(Or(LGreater(DMCH, 0x3), LEqual(And(DMCH, 0x3, Local1), 0x0), )) {
                    Store(0x0, DMAM)
                }
                Else {
                    ShiftLeft(0x1, Local1, DMAM)
                }
                EXFG()
                Return(CRS1)
            }
            Method(DSRS, 2) {
                CreateWordField(Arg0, 0x1, IRQM)
                CreateByteField(Arg0, 0x4, DMAM)
                CreateWordField(Arg0, 0x8, IO11)
                ENFG(CGLD(Arg1))
                And(IO11, 0xff, IOAL)
                ShiftRight(IO11, 0x8, IOAH)
                If(IRQM) {
                    FindSetRightBit(IRQM, Local0)
                    Subtract(Local0, 0x1, INTR)
                }
                Else {
                    Store(0x0, INTR)
                }
                If(DMAM) {
                    FindSetRightBit(DMAM, Local0)
                    Subtract(Local0, 0x1, DMCH)
                }
                Else {
                    Store(0x4, DMCH)
                }
                DCNT(Arg1, 0x1)
            }
            Device(SYSR) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x1)
                Name(_CRS, Buffer(0x72) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0, 0x0, 0x10, 0x47, 0x1, 0x22, 0x0, 0x22, 0x0, 0x0, 0x1e, 0x47, 0x1, 0x44, 0x0, 0x44, 0x0, 0x0, 0x1c, 0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x0, 0x2, 0x47, 0x1, 0x65, 0x0, 0x65, 0x0, 0x0, 0xb, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x0, 0xe, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x0, 0x1, 0x47, 0x1, 0x84, 0x0, 0x84, 0x0, 0x0, 0x3, 0x47, 0x1, 0x88, 0x0, 0x88, 0x0, 0x0, 0x1, 0x47, 0x1, 0x8c, 0x0, 0x8c, 0x0, 0x0, 0x3, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0, 0x0, 0x10, 0x47, 0x1, 0xa2, 0x0, 0xa2, 0x0, 0x0, 0x1e, 0x47, 0x1, 0xe0, 0x0, 0xe0, 0x0, 0x0, 0x10, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x0, 0x2, 0x79, 0x0 })
            }
            Device(OSYS) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x2)
                Name(CRS_, Buffer(0x3a) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateWordField(CRS_, 0x2, GP00)
                    CreateWordField(CRS_, 0x4, GP01)
                    CreateByteField(CRS_, 0x7, GP0L)
                    Store(PMBS, GP00)
                    Store(PMBS, GP01)
                    Store(PMLN, GP0L)
                    If(LAnd(LNot(LEqual(SPIO, 0x03f0)), LGreater(SPIO, 0xf0))) {
                        CreateWordField(CRS_, 0xa, GP10)
                        CreateWordField(CRS_, 0xc, GP11)
                        CreateByteField(CRS_, 0xf, GPL1)
                        Store(SPIO, GP10)
                        Store(SPIO, GP11)
                        Store(0x2, GPL1)
                    }
                    If(IO1B) {
                        CreateWordField(CRS_, 0x12, GP20)
                        CreateWordField(CRS_, 0x14, GP21)
                        CreateByteField(CRS_, 0x17, GP2L)
                        Store(IO1B, GP20)
                        Store(IO1B, GP21)
                        Store(IO1L, GP2L)
                    }
                    If(SMBS) {
                        CreateWordField(CRS_, 0x1a, GP30)
                        CreateWordField(CRS_, 0x1c, GP31)
                        CreateByteField(CRS_, 0x1f, GP3L)
                        Store(SMBS, GP30)
                        Store(SMBS, GP31)
                        Store(SMLN, GP3L)
                    }
                    If(APCB) {
                        CreateDWordField(CRS_, 0x28, ML01)
                        CreateDWordField(CRS_, 0x24, MB01)
                        CreateDWordField(CRS_, 0x34, ML02)
                        CreateDWordField(CRS_, 0x30, MB02)
                        Store(APCB, MB01)
                        Store(APCL, ML01)
                        Store(0xfee00000, MB02)
                        Store(0x1000, ML02)
                    }
                    Return(CRS_)
                }
            }
            Device(\_SB_.SYSM) {
                Name(_HID, 0x010cd041)
                Name(_UID, 0x1)
                Name(CRS_, Buffer(0x3e) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x2, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateDWordField(CRS_, 0x10, BAS1)
                    CreateDWordField(CRS_, 0x14, LEN1)
                    CreateDWordField(CRS_, 0x1c, BAS2)
                    CreateDWordField(CRS_, 0x20, LEN2)
                    CreateDWordField(CRS_, 0x2c, LEN3)
                    CreateDWordField(CRS_, 0x34, BAS4)
                    CreateDWordField(CRS_, 0x38, LEN4)
                    If(OSFL) {
                    }
                    Else {
                        If(MG1B) {
                            If(LGreater(MG1B, 0x000c0000)) {
                                Store(0x000c0000, BAS1)
                                Subtract(MG1B, BAS1, LEN1)
                            }
                        }
                        Else {
                            Store(0x000c0000, BAS1)
                            Store(0x00020000, LEN1)
                        }
                        If(Add(MG1B, MG1L, Local0)) {
                            Store(Local0, BAS2)
                            Subtract(0x00100000, BAS2, LEN2)
                        }
                    }
                    Subtract(MG2B, 0x00100000, LEN3)
                    Add(MG2B, MG2L, BAS4)
                    Subtract(0x0, BAS4, LEN4)
                    Return(CRS_)
                }
            }
        }
    }
}
Scope(\_SB_) {
    Scope(PCI0) {
        Method(_INI) {
            If(MCTH(\_OS_, "Microsoft Windows NT")) {
                Store(0x0, OSFL)
            }
        }
        Name(CRS_, Buffer(0x88) {0x88, 0xd, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
        CreateDWordField(CRS_, 0x5c, MIN5)
        CreateDWordField(CRS_, 0x60, MAX5)
        CreateDWordField(CRS_, 0x68, LEN5)
        CreateDWordField(CRS_, 0x76, MIN6)
        CreateDWordField(CRS_, 0x7a, MAX6)
        CreateDWordField(CRS_, 0x82, LEN6)
        Method(_CRS) {
            Store(MG1B, MIN5)
            Store(MG1L, LEN5)
            Store(MG1L, Local0)
            If(Local0) {
                Add(MIN5, Decrement(Local0), MAX5)
            }
            Store(MG2B, MIN6)
            Store(MG2L, LEN6)
            Store(MG2L, Local0)
            Add(MIN6, Decrement(Local0), MAX6)
            Return(CRS_)
        }
    }
}
Method(_PTS, 1) {
    Store(Arg0, DBG8)
    PTS_(Arg0)
    Store(0x0, Index(WAKP, 0x0, ))
    Store(0x0, Index(WAKP, 0x1, ))
}
Method(_WAK, 1) {
    ShiftLeft(Arg0, 0x4, DBG8)
    WAK_(Arg0)
    If(DerefOf(Index(WAKP, 0x0, ))) {
        Store(0x0, Index(WAKP, 0x1, ))
    }
    Else {
        Store(Arg0, Index(WAKP, 0x1, ))
    }
    Return(WAKP)
}
Scope(\_SB_) {
    OperationRegion(\_SB_.PCI0.SBRG.PIRG, PCI_Config, 0x60, 0x4)
    Field(\_SB_.PCI0.SBRG.PIRG, ByteAcc, NoLock, Preserve) {
        PIRA,	8,
        PIRB,	8,
        PIRC,	8,
        PIRD,	8
    }
    Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x80, 0x18, 0x79, 0x0 })
    CreateWordField(BUFA, 0x1, ICRS)
    Method(LSTA, 1) {
        And(Arg0, 0x80, Local0)
        If(Local0) {
            Return(0x9)
        }
        Else {
            Return(0xb)
        }
    }
    Method(LCRS, 1) {
        And(Arg0, 0xf, Local0)
        ShiftLeft(0x1, Local0, ICRS)
        Return(BUFA)
    }
    Method(LSRS, 1) {
        CreateWordField(Arg0, 0x1, ISRS)
        FindSetRightBit(ISRS, Local0)
        Return(Decrement(Local0))
    }
    Method(LDIS, 1) {
        Return(Or(Arg0, 0x80, ))
    }
    Device(LNKA) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x1)
        Method(_STA) {
            Return(LSTA(PIRA))
        }
        Method(_PRS) {
            Return(PRSA)
        }
        Method(_DIS) {
            Store(LDIS(PIRA), PIRA)
        }
        Method(_CRS) {
            Return(LCRS(PIRA))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRA)
        }
    }
    Device(LNKB) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x2)
        Method(_STA) {
            Return(LSTA(PIRB))
        }
        Method(_PRS) {
            Return(PRSB)
        }
        Method(_DIS) {
            Store(LDIS(PIRB), PIRB)
        }
        Method(_CRS) {
            Return(LCRS(PIRB))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRB)
        }
    }
    Device(LNKC) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x3)
        Method(_STA) {
            Return(LSTA(PIRC))
        }
        Method(_PRS) {
            Return(PRSC)
        }
        Method(_DIS) {
            Store(LDIS(PIRC), PIRC)
        }
        Method(_CRS) {
            Return(LCRS(PIRC))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRC)
        }
    }
    Device(LNKD) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x4)
        Method(_STA) {
            Return(LSTA(PIRD))
        }
        Method(_PRS) {
            Return(PRSD)
        }
        Method(_DIS) {
            Store(LDIS(PIRD), PIRD)
        }
        Method(_CRS) {
            Return(LCRS(PIRD))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRD)
        }
    }
}
Name(\_S0_, Package(0x4) {
    0x5,
    0x0,
    0x0,
    0x0,
})
Name(\_S5_, Package(0x4) {
    0x0,
    0x0,
    0x0,
    0x0,
})
Method(PTS_, 1) {
    If(Arg0) {
    }
}
Method(WAK_, 1) {
}

}
/*
OEMB: Length=83, Revision=1, Checksum=8,
	OEMID=A M I, OEM Table ID=OEMBIOS, OEM Revision=0x8000314,
	Creator ID=MSFT, Creator Revision=0x97
 */