DefinitionBlock ("DSDT.AML", "DSDT", 01, "LENOVO", "AMD", 0x00001000)
{
	If(Zero)
	{
		External(\_SB.ALIB, 0x08, 0x02)
		External(\_SB.APTS, 0x08, 0x01)
		External(\_SB.AWAK, 0x08, 0x01)
		External(\_SB.PCI0.GP17.VGA.AFN4, 0x08, 0x01)
		External(\_SB.PCI0.GP17.VGA.AFN7, 0x08, 0x01)
		External(\_SB.TPM.PTS, 0x08, 0x01)
		External(\_SB.PCI0.LPC0.TPOS, 0x00, 0x00)
		External(\_SB.PCI0.SMB.GP62, 0x00, 0x00)
		External(\_SB.LSKD, 0x00, 0x00)
	}
	OperatnRegion(SYST, SystemMemory, 0xCD62EF18, 0x00000001)
	Field(SYST, AnyAcc, Lock, Preserve)
	{
		RV2, 8,
	}
	Scope (_SB)
	{
		Device (PLTF)
		{
			Name(_HID, "ACPI0010")
			Name(_CID, EISAID("PNP0A05"))
			Name(_UID, One)
			Device (C000)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, Zero)
			}
			Device (C001)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, One)
			}
			Device (C002)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x02)
			}
			Device (C003)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x03)
			}
			Device (C004)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x04)
			}
			Device (C005)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x05)
			}
			Device (C006)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x06)
			}
			Device (C007)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x07)
			}
			Device (C008)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x08)
			}
			Device (C009)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x09)
			}
			Device (C00A)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x0A)
			}
			Device (C00B)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x0B)
			}
			Device (C00C)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x0C)
			}
			Device (C00D)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x0D)
			}
			Device (C00E)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x0E)
			}
			Device (C00F)
			{
				Name(_HID, "ACPI0007")
				Name(_UID, 0x0F)
			}
		}
	}
	Name(_S0, Package(4) {0x00, 0x00, 0x00, 0x00})
	Name(_S3, Package(4) {0x03, 0x03, 0x00, 0x00})
	Name(_S4, Package(4) {0x04, 0x04, 0x00, 0x00})
	Name(_S5, Package(4) {0x05, 0x05, 0x00, 0x00})
	Name(TZFG, 0x00)
	OperationRegion(DBG0, SystemIO, 0x80, 0x01)
	Field(DBG0, ByteAcc, NoLock, Preserve)
	{
		IO80, 8,
	}
	OperationRegion(DEB2, SystemIO, 0x80, 0x02)
	Field(DEB2, WordAcc, NoLock, Preserve)
	{
		P80H, 16,
	}
	Method (TPST, 1, Serialized)
	{
		Add(Arg0, 0xB0000000, Local0)
		OperationRegion(VARM, SystemIO, 0x80, 0x04)
		Field(VARM, DWordAcc, NoLock, Preserve)
		{
			VARR, 32,
		}
		Store(Local0, VARR)
	}
	OperationRegion(P01, SystemIO, 0x0401, 0x01)
	Field(P01, ByteAcc, NoLock, Preserve)
	{
		PST1, 8,
	}
	Name(PRWP, Package(2) {Zero, Zero})
	Method (GPRW, 2, NotSerialized)
	{
		Store(Arg0, Index(PRWP, Zero))
		Store(Arg1, Index(PRWP, One))
		Return(PRWP)
	}
	OperationRegion(GNVS, SystemMemory, 0xCD779C98, 0x00000009)
	Field(GNVS, AnyAcc, NoLock, Preserve)
	{
		BRTL, 8,
		DAS3, 8,
		WKPM, 8,
		PCBA, 32,
		MWTT, 8,
		WOVS, 8,
	}
	OperationRegion(OGNS, SystemMemory, 0xCD62EE98, 0x00000004)
	Field(OGNS, AnyAcc, Lock, Preserve)
	{
		THPN, 8,
		SDMO, 8,
		TBEN, 8,
		TBNH, 8,
	}
	OperationRegion(SM66, SystemIO, 0xB0, 0x01)
	Field(SM66, ByteAcc, NoLock, Preserve)
	{
		IOB0, 8,
	}
	Name(LINX, 0x00)
	Name(OSSP, 0x00)
	Name(OSTB, Ones)
	Name(TPOS, Zero)
	Method (OSTP, 0, NotSerialized)
	{
		If(LEqual(OSTB, Ones))
		{
			If(CondRefOf(\_OSI, Local0))
			{
				Store(0x00, OSTB)
				Store(0x00, TPOS)
				If(_OSI("Windows 2001"))
				{
					Store(0x08, OSTB)
					Store(0x08, TPOS)
				}
				If(_OSI("Windows 2001.1"))
				{
					Store(0x20, OSTB)
					Store(0x20, TPOS)
				}
				If(_OSI("Windows 2001 SP1"))
				{
					Store(0x10, OSTB)
					Store(0x10, TPOS)
				}
				If(_OSI("Windows 2001 SP2"))
				{
					Store(0x11, OSTB)
					Store(0x11, TPOS)
				}
				If(_OSI("Windows 2001 SP3"))
				{
					Store(0x12, OSTB)
					Store(0x12, TPOS)
				}
				If(_OSI("Windows 2006"))
				{
					Store(0x40, OSTB)
					Store(0x40, TPOS)
				}
				If(_OSI("Windows 2006 SP1"))
				{
					Store(0x01, OSSP)
					Store(0x40, OSTB)
					Store(0x40, TPOS)
				}
				If(_OSI("Windows 2009"))
				{
					Store(0x01, OSSP)
					Store(0x50, OSTB)
					Store(0x50, TPOS)
				}
				If(_OSI("Windows 2012"))
				{
					Store(0x01, OSSP)
					Store(0x60, OSTB)
					Store(0x60, TPOS)
				}
				If(_OSI("Windows 2013"))
				{
					Store(0x01, OSSP)
					Store(0x61, OSTB)
					Store(0x61, TPOS)
				}
				If(_OSI("Windows 2015"))
				{
					Store(0x01, OSSP)
					Store(0x70, OSTB)
					Store(0x70, TPOS)
				}
				If(_OSI("Linux"))
				{
					Store(0x01, LINX)
					Store(0x80, OSTB)
					Store(0x80, TPOS)
				}
			}
			Else
			{
				If(CondRefOf(\_OS, Local0))
				{
					If(SEQL(_OS, "Microsoft Windows"))
					{
						Store(0x01, OSTB)
						Store(0x01, TPOS)
					}
					Else
					{
						If(SEQL(_OS, "Microsoft WindowsME: Millennium Edition"))
						{
							Store(0x02, OSTB)
							Store(0x02, TPOS)
						}
						Else
						{
							If(SEQL(_OS, "Microsoft Windows NT"))
							{
								Store(0x04, OSTB)
								Store(0x04, TPOS)
							}
							Else
							{
								Store(0x00, OSTB)
								Store(0x00, TPOS)
							}
						}
					}
				}
				Else
				{
					Store(0x00, OSTB)
					Store(0x00, TPOS)
				}
			}
			If(LEqual(TPOS, 0x80)) {}
		}
		Return(OSTB)
	}
	Method (SEQL, 2, Serialized)
	{
		Store(SizeOf(Arg0), Local0)
		Store(SizeOf(Arg1), Local1)
		If(LNotEqual(Local0, Local1))
		{
			Return(Zero)
		}
		Name(BUF0, Buffer(Local0){})
		Store(Arg0, BUF0)
		Name(BUF1, Buffer(Local0){})
		Store(Arg1, BUF1)
		Store(Zero, Local2)
		While(LLess(Local2, Local0))
		{
			Store(DerefOf(Index(BUF0, Local2)), Local3)
			Store(DerefOf(Index(BUF1, Local2)), Local4)
			If(LNotEqual(Local3, Local4))
			{
				Return(Zero)
			}
			Increment(Local2)
		}
		Return(One)
	}
	Method (_PTS, 1, NotSerialized)
	{
		If(LNotEqual(Arg0, 0x03))
		{
			Store(0x66, IOB0)
		}
		If(LNotEqual(Arg0, 0x03))
		{
			If(LNotEqual(Arg0, 0x04))
			{
				Store(0x01, \_SB.PCI0.LPC0.EC0.FBRS)
			}
		}
		If(CondRefOf(\_SB.TPM.PTS))
		{
			\_SB.TPM.PTS(Arg0)
		}
		If(LEqual(Arg0, 0x05))
		{
			Store(0xC5, P80H)
			Store(0x00, \_SB.PCI0.SMB.BLNK)
		}
		If(LEqual(Arg0, 0x04))
		{
			Store(0xC4, P80H)
			Store(0x00, \_SB.PCI0.SMB.BLNK)
		}
		If(LEqual(Arg0, 0x03))
		{
			Store(0xC3, P80H)
			Store(0x01, \_SB.PCI0.SMB.BLNK)
			Store(Zero, \_SB.PCI0.SMB.RSTU)
		}
		Store(0x01, \_SB.PCI0.SMB.CLPS)
		Store(0x01, \_SB.PCI0.SMB.SLPS)
		Store(\_SB.PCI0.SMB.PEWS, \_SB.PCI0.SMB.PEWS)
		\_SB.APTS(Arg0)
	}
	OperationRegion(XMOS, SystemIO, 0x72, 0x02)
	Field(XMOS, ByteAcc, Lock, Preserve)
	{
		XIDX, 8,
		XDAT, 8,
	}
	IndexField(XIDX, XDAT, ByteAcc, Lock, Preserve)
	{
		Offset(0x74),	//Offset(116),
		WKSR, 8,
		Offset(0xD0),	//Offset(208),
		WLNS, 1,
		BTNS, 1,
	}
	Method (_WAK, 1, NotSerialized)
	{
		Store(0xFF, \_SB.ADP0.ACDC)
		Store(0x03, \_SB.PCI0.SMB.BLNK)
		If(LEqual(\_SB.PCI0.LPC0.EC0.SPMO, 0x01))
		{
			Store(0x05, SMUF)
			If(LEqual(\_SB.PCI0.LPC0.EC0.PSYS, 0x01))
			{
				Store(SPL5, SMUD)
			}
			Else
			{
				If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
				{
					Store(SPL6, SMUD)
				}
				Else
				{
					If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
					{
						Store(SPL4, SMUD)
					}
					Else
					{
						Store(SPL2, SMUD)
					}
				}
			}
			\_SB.ALIB(0x0C, XX11)
			Store(0x07, SMUF)
			If(LEqual(\_SB.PCI0.LPC0.EC0.PSYS, 0x01))
			{
				Store(SPP5, SMUD)
			}
			Else
			{
				If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
				{
					Store(SPP6, SMUD)
				}
				Else
				{
					If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
					{
						Store(SPP4, SMUD)
					}
					Else
					{
						Store(SPP2, SMUD)
					}
				}
			}
			\_SB.ALIB(0x0C, XX11)
			Store(0x06, SMUF)
			If(LEqual(\_SB.PCI0.LPC0.EC0.PSYS, 0x01))
			{
				Store(FPP5, SMUD)
			}
			Else
			{
				If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
				{
					Store(FPP6, SMUD)
				}
				Else
				{
					If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
					{
						Store(FPP4, SMUD)
					}
					Else
					{
						Store(FPP2, SMUD)
					}
				}
			}
			\_SB.ALIB(0x0C, XX11)
			Store(0x0B, SMUF)
			Store(TDC2, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x0C, SMUF)
			Store(EDC2, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x08, SMUF)
			Store(SPT2, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x01, SMUF)
			Store(STC2, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x03, SMUF)
			Store(TCL2, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x20, SMUF)
			Store(0x199A, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x22, SMUF)
			Store(0x3000, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x24, SMUF)
			Store(0x0148, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x25, SMUF)
			Store(0x2666, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x26, SMUF)
			Store(0x01EF, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x27, SMUF)
			Store(0x0430, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x2C, SMUF)
			Store(0xB06D, SMUD)
			\_SB.ALIB(0x0C, XX11)
			Store(0x2E, SMUF)
			Store(0x61A8, SMUD)
			\_SB.ALIB(0x0C, XX11)
		}
		Else
		{
			If(LEqual(\_SB.PCI0.LPC0.EC0.SPMO, 0x02))
			{
				Store(0x05, SMUF)
				Store(SPL3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x07, SMUF)
				Store(SPP3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x06, SMUF)
				Store(FPP3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x0B, SMUF)
				Store(TDC3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x0C, SMUF)
				Store(EDC3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x08, SMUF)
				Store(SPT3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x01, SMUF)
				Store(STC3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x03, SMUF)
				Store(TCL3, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x20, SMUF)
				Store(0x199A, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x22, SMUF)
				Store(0x2C00, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x24, SMUF)
				Store(0x0148, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x25, SMUF)
				Store(0x2666, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x26, SMUF)
				Store(0x011C, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x27, SMUF)
				Store(0x040B, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x2C, SMUF)
				Store(0xC936, SMUD)
				\_SB.ALIB(0x0C, XX11)
				Store(0x2E, SMUF)
				Store(0x2EE0, SMUD)
				\_SB.ALIB(0x0C, XX11)
			}
			Else
			{
				If(LEqual(\_SB.PCI0.LPC0.EC0.FCMO, 0x03))
				{
					\_SB.PCI0.LPC0.EC0.VPC0.DYTC(0x001F5001)
					Store(0x05, SMUF)
					If(LEqual(\_SB.PCI0.LPC0.EC0.PSYS, 0x01))
					{
						Store(SPL5, SMUD)
					}
					Else
					{
						If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
						{
							Store(SPL6, SMUD)
						}
						Else
						{
							If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
							{
								Store(SPL4, SMUD)
							}
							Else
							{
								Store(SPL7, SMUD)
							}
						}
					}
					\_SB.ALIB(0x0C, XX11)
					Store(0x07, SMUF)
					If(LEqual(\_SB.PCI0.LPC0.EC0.PSYS, 0x01))
					{
						Store(SPP5, SMUD)
					}
					Else
					{
						If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
						{
							Store(SPP6, SMUD)
						}
						Else
						{
							If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
							{
								Store(SPP4, SMUD)
							}
							Else
							{
								Store(SPP7, SMUD)
							}
						}
					}
					\_SB.ALIB(0x0C, XX11)
					Store(0x06, SMUF)
					If(LEqual(\_SB.PCI0.LPC0.EC0.PSYS, 0x01))
					{
						Store(FPP5, SMUD)
					}
					Else
					{
						If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
						{
							Store(FPP6, SMUD)
						}
						Else
						{
							If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
							{
								Store(FPP4, SMUD)
							}
							Else
							{
								Store(FPP7, SMUD)
							}
						}
					}
					\_SB.ALIB(0x0C, XX11)
				}
				Else
				{
					If(LEqual(\_SB.PCI0.LPC0.EC0.FCMO, 0x04))
					{
						\_SB.PCI0.LPC0.EC0.VPC0.DYTC(0x001F6001)
					}
					Else
					{
						\_SB.PCI0.LPC0.EC0.VPC0.DYTC(0x000FB001)
						Store(0x05, SMUF)
						If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
						{
							Store(SPL6, SMUD)
						}
						Else
						{
							If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
							{
								Store(SPL4, SMUD)
							}
							Else
							{
								Store(SPL9, SMUD)
							}
						}
						\_SB.ALIB(0x0C, XX11)
						Store(0x07, SMUF)
						If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
						{
							Store(SPP6, SMUD)
						}
						Else
						{
							If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
							{
								Store(SPP4, SMUD)
							}
							Else
							{
								Store(SPP9, SMUD)
							}
						}
						\_SB.ALIB(0x0C, XX11)
						Store(0x06, SMUF)
						If(LEqual(\_SB.PCI0.LPC0.EC0.LBPR, 0x01))
						{
							Store(FPP6, SMUD)
						}
						Else
						{
							If(LEqual(\_SB.PCI0.LPC0.EC0.OVLD, 0x01))
							{
								Store(FPP4, SMUD)
							}
							Else
							{
								Store(FPP9, SMUD)
							}
						}
						\_SB.ALIB(0x0C, XX11)
					}
				}
			}
		}
		If(LEqual(Arg0, 0x03))
		{
			If(LEqual(\_SB.PCI0.LPC0.EC0.HKDB, 0x01))
			{
				Store(0xA4, \_SB.PCI0.SMB.GP62)
			}
			Else
			{
				Store(0xC5, \_SB.PCI0.SMB.GP62)
			}
		}
		If(LEqual(Arg0, 0x03))
		{
			Store(One, \_SB.PCI0.SMB.RSTU)
		}
		Store(\_SB.PCI0.SMB.PEWS, \_SB.PCI0.SMB.PEWS)
		Store(0x01, \_SB.PCI0.SMB.PWDE)
		Store(Zero, \_SB.PCI0.SMB.PEWD)
		\_SB.AWAK(Arg0)
		If(LEqual(Arg0, 0x03))
		{
			Store(0xE3, P80H)
			If(GPIC)
			{
				\_SB.PCI0.LPC0.DSPI()
			}
			If(LOr(LEqual(WKSR, 0x06), LEqual(WKSR, 0x07)))
			{
				Notify(\_SB.GPIO, 0x00)
				Notify(\_SB.I2CD, 0x00)
			}
			Else
			{
				Notify(_SB, 0x00)
				Notify(\_SB.PWRB, 0x02)
			}
		}
		If(LEqual(Arg0, 0x04))
		{
			Store(0xE4, P80H)
			If(GPIC)
			{
				\_SB.PCI0.LPC0.DSPI()
			}
			Notify(\_SB.PWRB, 0x02)
		}
		If(LEqual(Arg0, 0x05))
		{
			Store(0xE5, P80H)
		}
		If(LEqual(TPOS, 0x40))
		{
			Store(0x01, Local0)
		}
		If(LEqual(TPOS, 0x80))
		{
			Store(0x02, Local0)
		}
		If(LEqual(TPOS, 0x50))
		{
			Store(0x03, Local0)
		}
		If(LEqual(TPOS, 0x60))
		{
			Store(0x04, Local0)
		}
		If(LEqual(TPOS, 0x61))
		{
			Store(0x05, Local0)
		}
		If(LEqual(TPOS, 0x70))
		{
			Store(0x06, Local0)
		}
		Store(Local0, \_SB.PCI0.LPC0.EC0.OSTY)
		Notify(\_SB.PCI0, 0x00)
		Return(Zero)
	}
	Scope (_SI)
	{
		Method (_SST, 1, NotSerialized)
		{
			If(LEqual(Arg0, 0x01))
			{
				Store("===== SST Working =====", Debug)
			}
			If(LEqual(Arg0, 0x02))
			{
				Store("===== SST Waking =====", Debug)
			}
			If(LEqual(Arg0, 0x03))
			{
				Store("===== SST Sleeping =====", Debug)
			}
			If(LEqual(Arg0, 0x04))
			{
				Store("===== SST Sleeping S4 =====", Debug)
			}
		}
	}
	Name(GPIC, 0x00)
	Method (_PIC, 1, NotSerialized)
	{
		Store(Arg0, GPIC)
		If(Arg0)
		{
			\_SB.PCI0.LPC0.DSPI()
		}
	}
	Scope (_SB)
	{
		Device (PCI0)
		{
			Name(_HID, EISAID("PNP0A08"))
			Name(_CID, EISAID("PNP0A03"))
			Name(_UID, 0x01)
			Name(_BBN, 0x00)
			Name(_ADR, 0x00)
			Method (_INI, 0, NotSerialized)
			{
				If(LNotEqual(GPIC, Zero))
				{
					^LPC0.DSPI()
				}
				OSTP()
			}
			Name(SUPP, 0x00)
			Name(CTRL, 0x00)
			Method (_OSC, 4, NotSerialized)
			{
				CreateDWordField(Arg3, 0x00, CDW1)
				CreateDWordField(Arg3, 0x04, CDW2)
				CreateDWordField(Arg3, 0x08, CDW3)
				If(LEqual(Arg0, ToUUID("33DB4D5B-1FF7401C-96577441C03DD766")}))
				{
					Store(CDW2, SUPP)
					Store(CDW3, CTRL)
					If(LEqual(TBEN, One))
					{
						If(LNotEqual(TBNH, Zero))
						{
							And(CTRL, 0xFFFFFFF5, CTRL)
						}
						Else
						{
							And(CTRL, 0xFFFFFFF4, CTRL)
						}
					}
					If(LNotEqual(And(SUPP, 0x16), 0x16))
					{
						And(CTRL, 0x1E, CTRL)
					}
					And(CTRL, 0x1D, CTRL)
					If(Not(And(CDW1, 0x01)))
					{
						If(And(CTRL, 0x01)) {}
						If(And(CTRL, 0x04)) {}
						If(And(CTRL, 0x10)) {}
					}
					If(LNotEqual(Arg1, One))
					{
						Or(CDW1, 0x08, CDW1)
					}
					If(LNotEqual(CDW3, CTRL))
					{
						Or(CDW1, 0x10, CDW1)
					}
					And(CTRL, 0xF7, CTRL)
					Store(CTRL, CDW3)
					Return(Arg3)
				}
				Else
				{
					Or(CDW1, 0x04, CDW1)
					Return(Arg3)
				}
			}
			OperationRegion(K8ST, SystemMemory, 0xCD779B98, 0x00000068)
			Field(K8ST, AnyAcc, NoLock, Preserve)
			{
				C0_0, 16,
				C2_0, 16,
				C4_0, 16,
				C6_0, 16,
				C8_0, 16,
				CA_0, 16,
				CC_0, 16,
				CE_0, 16,
				D0_0, 16,
				D2_0, 16,
				D4_0, 16,
				D6_0, 16,
				D8_0, 16,
				DA_0, 16,
				DC_0, 16,
				DE_0, 16,
				E0_0, 16,
				E2_0, 16,
				E4_0, 16,
				E6_0, 16,
				E8_0, 16,
				EA_0, 16,
				EC_0, 16,
				EE_0, 16,
				F0_0, 16,
				F2_0, 16,
				F4_0, 16,
				F6_0, 16,
				F8_0, 16,
				FA_0, 16,
				FC_0, 16,
				FE_0, 16,
				TOML, 32,
				TOMH, 32,
				PCIB, 32,
				PCIS, 32,
				T1MN, 64,
				T1MX, 64,
				T1LN, 64,
			}
			Name(RSRC, ResourceTemplate()
			{
				WordBusNumber(ResourceProducer, MinFixed, MaxFixed, SubDecode,
					0x0000,
					0x0000,
					0x00FF,
					0x0000,
					0x0100,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000A0000,
					0x000BFFFF,
					0x00000000,
					0x00020000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000C0000,
					0x000C1FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000C2000,
					0x000C3FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000C4000,
					0x000C5FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000C6000,
					0x000C7FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000C8000,
					0x000C9FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000CA000,
					0x000CBFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000CC000,
					0x000CDFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000CE000,
					0x000CFFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000D0000,
					0x000D1FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000D2000,
					0x000D3FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000D4000,
					0x000D5FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000D6000,
					0x000D7FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000D8000,
					0x000D9FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000DA000,
					0x000DBFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000DC000,
					0x000DDFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000DE000,
					0x000DFFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000E0000,
					0x000E1FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000E2000,
					0x000E3FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000E4000,
					0x000E5FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000E6000,
					0x000E7FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000E8000,
					0x000E9FFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000EA000,
					0x000EBFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000EC000,
					0x000EDFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x000EE000,
					0x000EFFFF,
					0x00000000,
					0x00002000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0x00000000,
					0x00000000,
					0x00000000,
					0x00000000,
					0x00
				)
				DWordMemory(ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x00000000,
					0xFC000000,
					0xFDFFFFFF,
					0x00000000,
					0x02000000,
					0x00
				)
				QWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
					0x0000000000000000,
					0x0000000000000000,
					0x0000000000000000,
					0x0000000000000000,
					0x0000000000000000
				)
				IO(Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
				WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
					0x0000,
					0x0000,
					0x0CF7,
					0x0000,
					0x0CF8,
					0x00
				)
				WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
					0x0000,
					0x0D00,
					0xFFFF,
					0x0000,
					0xF300,
					0x00
				)
			})
			Method (_CRS, 0, Serialized)
			{
				CreateDWordField(RSRC, 0x02BE, BT1S)
				CreateDWordField(RSRC, 0x02C2, BT1M)
				CreateDWordField(RSRC, 0x02CA, BT1L)
				CreateDWordField(RSRC, 0x02D9, BT2S)
				CreateDWordField(RSRC, 0x02DD, BT2M)
				CreateDWordField(RSRC, 0x02E5, BT2L)
				Store(PCIB, Local0)
				Store(TOML, BT1S)
				Store(Subtract(Local0, 0x01), BT1M)
				Subtract(Local0, TOML, BT1L)
				CreateQWordField(RSRC, 0x02F8, M1MN)
				CreateQWordField(RSRC, 0x0300, M1MX)
				CreateQWordField(RSRC, 0x0310, M1LN)
				Store(T1MN, M1MN)
				Store(T1MX, M1MX)
				Store(T1LN, M1LN)
				Return(RSRC)
			}
			Device (MEMR)
			{
				Name(_HID, EISAID("PNP0C02"))
				Name(MEM1, ResourceTemplate()
				{
					IO(Decode16, 0x0F50, 0x0F50, 0x01, 0x02)
					Memory32Fixed(ReadWrite, 0x00000000, 0x00000000)
					Memory32Fixed(ReadWrite, 0x00000000, 0x00000000)
					Memory32Fixed(ReadWrite, 0x00000000, 0x00000000)
				})
				Method (_CRS, 0, NotSerialized)
				{
					CreateDWordField(MEM1, 0x0C, MB01)
					CreateDWordField(MEM1, 0x10, ML01)
					CreateDWordField(MEM1, 0x18, MB02)
					CreateDWordField(MEM1, 0x1C, ML02)
					If(GPIC)
					{
						Store(0xFEC00000, MB01)
						Store(0xFEE00000, MB02)
						Store(0x2000, ML01)
						Store(0x1000, ML02)
					}
					CreateDWordField(MEM1, 0x24, MB03)
					CreateDWordField(MEM1, 0x28, ML03)
					Store(PCIB, MB03)
					Store(PCIS, ML03)
					Return(MEM1)
				}
			}
			Method (_PRT, 0, NotSerialized)
			{
				If(GPIC)
				{
					Return(Package(14)
					{
						Package(4) {0x0001FFFF, 0x00, 0x00, 0x28}, 
						Package(4) {0x0001FFFF, 0x01, 0x00, 0x29}, 
						Package(4) {0x0001FFFF, 0x02, 0x00, 0x2A}, 
						Package(4) {0x0002FFFF, 0x00, 0x00, 0x24}, 
						Package(4) {0x0002FFFF, 0x01, 0x00, 0x25}, 
						Package(4) {0x0002FFFF, 0x02, 0x00, 0x26}, 
						Package(4) {0x0002FFFF, 0x03, 0x00, 0x27}, 
						Package(4) {0x0008FFFF, 0x00, 0x00, 0x20}, 
						Package(4) {0x0008FFFF, 0x01, 0x00, 0x21}, 
						Package(4) {0x0008FFFF, 0x01, 0x00, 0x22}, 
						Package(4) {0x0014FFFF, 0x00, 0x00, 0x10}, 
						Package(4) {0x0014FFFF, 0x01, 0x00, 0x11}, 
						Package(4) {0x0014FFFF, 0x02, 0x00, 0x12}, 
						Package(4) {0x0014FFFF, 0x03, 0x00, 0x13}
					})
				}
				Else
				{
					Return(Package(14)
					{
						Package(4) {0x0001FFFF, 0x00, ^LPC0.LNKA, 0x00}, 
						Package(4) {0x0001FFFF, 0x01, ^LPC0.LNKB, 0x00}, 
						Package(4) {0x0001FFFF, 0x02, ^LPC0.LNKC, 0x00}, 
						Package(4) {0x0002FFFF, 0x00, ^LPC0.LNKE, 0x00}, 
						Package(4) {0x0002FFFF, 0x01, ^LPC0.LNKF, 0x00}, 
						Package(4) {0x0002FFFF, 0x02, ^LPC0.LNKG, 0x00}, 
						Package(4) {0x0002FFFF, 0x03, ^LPC0.LNKH, 0x00}, 
						Package(4) {0x0008FFFF, 0x00, ^LPC0.LNKA, 0x00}, 
						Package(4) {0x0008FFFF, 0x01, ^LPC0.LNKB, 0x00}, 
						Package(4) {0x0008FFFF, 0x02, ^LPC0.LNKC, 0x00}, 
						Package(4) {0x0014FFFF, 0x00, ^LPC0.LNKA, 0x00}, 
						Package(4) {0x0014FFFF, 0x01, ^LPC0.LNKB, 0x00}, 
						Package(4) {0x0014FFFF, 0x02, ^LPC0.LNKC, 0x00}, 
						Package(4) {0x0014FFFF, 0x03, ^LPC0.LNKD, 0x00}
					})
				}
			}
			OperationRegion(BAR1, PCI_Config, 0x14, 0x04)
			Field(BAR1, ByteAcc, NoLock, Preserve)
			{
				NBBA, 32,
			}
			Device (GPP4)
			{
				Name(_ADR, 0x00020002)
				Method (RHRW, 0, NotSerialized)
				{
					If(LEqual(WKPM, One))
					{
						Return(GPRW(0x0E, 0x03))
					}
					Else
					{
						Return(GPRW(0x0E, Zero))
					}
				}
				Method (_PRT, 0, NotSerialized)
				{
					If(GPIC)
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, 0x00, 0x28}, 
							Package(4) {0xFFFF, 0x01, 0x00, 0x29}, 
							Package(4) {0xFFFF, 0x02, 0x00, 0x2A}, 
							Package(4) {0xFFFF, 0x03, 0x00, 0x2B}
						})
					}
					Else
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, ^^LPC0.LNKA, 0x00}, 
							Package(4) {0xFFFF, 0x01, ^^LPC0.LNKB, 0x00}, 
							Package(4) {0xFFFF, 0x02, ^^LPC0.LNKC, 0x00}, 
							Package(4) {0xFFFF, 0x03, ^^LPC0.LNKD, 0x00}
						})
					}
				}
				Device (PXSX)
				{
					Name(_ADR, 0x00)
					OperationRegion(FLDR, PCI_Config, 0x44, 0x06)
					Field(FLDR, ByteAcc, NoLock, Preserve)
					{
						DCAP, 32,
						DCTR, 16,
					}
					PowerResource(WRST, 5, 0)
					{
						Method (_STA, 0, NotSerialized)
						{
							Return(0x01)
						}
						Method (_ON, 0, NotSerialized)
						{
						}
						Method (_OFF, 0, NotSerialized)
						{
						}
						Method (_RST, 0, NotSerialized)
						{
							If(And(DCAP, 0x10000000))
							{
								Store(DCTR, Local0)
								Or(Local0, 0x8000, Local0)
								Store(Local0, DCTR)
							}
						}
					}
					Method (_PRR, 0, NotSerialized)
					{
						Return(Package(1) {WRST})
					}
				}
			}
			Device (GPP6)
			{
				Name(_ADR, 0x00020004)
				Method (_PRT, 0, NotSerialized)
				{
					If(GPIC)
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, 0x00, 0x30}, 
							Package(4) {0xFFFF, 0x01, 0x00, 0x31}, 
							Package(4) {0xFFFF, 0x02, 0x00, 0x32}, 
							Package(4) {0xFFFF, 0x03, 0x00, 0x33}
						})
					}
					Else
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, ^^LPC0.LNKA, 0x00}, 
							Package(4) {0xFFFF, 0x01, ^^LPC0.LNKB, 0x00}, 
							Package(4) {0xFFFF, 0x02, ^^LPC0.LNKC, 0x00}, 
							Package(4) {0xFFFF, 0x03, ^^LPC0.LNKD, 0x00}
						})
					}
				}
			}
			Device (GP17)
			{
				Name(_ADR, 0x00080001)
				Method (_PRW, 0, NotSerialized)
				{
					If(LEqual(WKPM, One))
					{
						Return(GPRW(0x19, 0x03))
					}
					Else
					{
						Return(GPRW(0x19, Zero))
					}
				}
				Method (_PRT, 0, NotSerialized)
				{
					If(GPIC)
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, 0x00, 0x26}, 
							Package(4) {0xFFFF, 0x01, 0x00, 0x27}, 
							Package(4) {0xFFFF, 0x02, 0x00, 0x24}, 
							Package(4) {0xFFFF, 0x03, 0x00, 0x25}
						})
					}
					Else
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, ^^LPC0.LNKG, 0x00}, 
							Package(4) {0xFFFF, 0x01, ^^LPC0.LNKH, 0x00}, 
							Package(4) {0xFFFF, 0x02, ^^LPC0.LNKE, 0x00}, 
							Package(4) {0xFFFF, 0x03, ^^LPC0.LNKF, 0x00}
						})
					}
				}
				Device (VGA)
				{
					Name(_ADR, Zero)
					Method (_STA, 0, NotSerialized)
					{
						Return(0x0F)
					}
					Name(DOSA, Zero)
					Method (_DOS, 1, NotSerialized)
					{
						Store(Arg0, DOSA)
					}
					Method (_DOD, 0, NotSerialized)
					{
						Return(Package(7)
						{
							0x00010110, 0x00010210, 0x00010220, 0x00010230, 0x00010240, 0x00031000,
							0x00032000
						})
					}
					Device (LCD)
					{
						Name(_ADR, 0x0110)
						Method (_BCL, 0, NotSerialized)
						{
							Return(Package(103)
							{
								0x50, 0x32, 0x00, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
								0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
								0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
								0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
								0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34,
								0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
								0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
								0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
								0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60,
								0x61, 0x62, 0x63, 0x64
							})
						}
						Method (_BCM, 1, NotSerialized)
						{
							Divide(Multiply(Arg0, 0xFF), 0x64, Local1, Local0)
							AFN7(Local0)
							Store(Arg0, BRTL)
						}
					}
					OperationRegion(GPUM, PCI_Config, 0x24, 0x04)
					Field(GPUM, ByteAcc, NoLock, Preserve)
					{
						GPUB, 32,
					}
					Method (GBSA, 0, Serialized)
					{
						Store(GPUB, Local0)
						And(Local0, 0xFFFFFF00, Local0)
						Add(Local0, 0x0138, Local0)
						Return(Local0)
					}
					OperationRegion(SCRA, SystemMemory, GBSA, 0x04)
					Field(SCRA, ByteAcc, NoLock, Preserve)
					{
						, 8,
						BRIL, 8,
					}
				}
				Device (PSP)
				{
					Name(_ADR, 0x02)
				}
				Device (ACP)
				{
					Name(_ADR, 0x05)
				}
				Device (AZAL)
				{
					Name(_ADR, 0x06)
				}
				Device (HDAU)
				{
					Name(_ADR, One)
				}
				Device (XHC0)
				{
					Name(_ADR, 0x03)
					Method (_S0W, 0, NotSerialized)
					{
						Return(0x00)
					}
					Name(_PRW, Package(2) {0x19, 0x03})
					Device (RHUB)
					{
						Name(_ADR, Zero)
						Device (HSP1)
						{
							Name(_ADR, 0x01)
							Name(_UPC, Package(4) {0xFF, 0x09, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x31, 0x1C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (SSP1)
						{
							Name(_ADR, 0x05)
							Name(_UPC, Package(4) {0xFF, 0x09, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x31, 0x1C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (HSP2)
						{
							Name(_ADR, 0x02)
							Name(_UPC, Package(4) {0xFF, 0x00, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x31, 0x1C, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (SSP2)
						{
							Name(_ADR, 0x06)
							Name(_UPC, Package(4) {0xFF, 0x03, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x31, 0x1C, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (HSP3)
						{
							Name(_ADR, 0x03)
							Name(_UPC, Package(4) {0xFF, 0xFF, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x14)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x24, 0x01, 0x00, 0x02, 0x00, 0x00, 0x80, 0x01, 
									0xFF, 0xFF, 0xFF, 0xFF
								}
							})
							Device (CAMA)
							{
								Name(_ADR, 0x03)
								Name(_UPC, Package(4) {0xFF, 0xFF, 0x00, 0x00})
								Name(_PLD, Package(1)
								{
									Buffer(0x14)
									{
										0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
										0x24, 0x01, 0x00, 0x02, 0x00, 0x00, 0x80, 0x01, 
										0xFF, 0xFF, 0xFF, 0xFF
									}
								})
							}
						}
						Device (HSP4)
						{
							Name(_ADR, 0x04)
							Name(_UPC, Package(4) {0x00, 0x00, 0x00, 0x00})
						}
					}
				}
				Device (XHC1)
				{
					Name(_ADR, 0x04)
					Method (_S0W, 0, NotSerialized)
					{
						Return(0x00)
					}
					Name(_PRW, Package(2) {0x19, 0x03})
					Method (_STA, 0, NotSerialized)
					{
						Return(0x0F)
					}
					Device (RHUB)
					{
						Name(_ADR, Zero)
						Device (HSP1)
						{
							Name(_ADR, 0x01)
							Name(_UPC, Package(4) {0xFF, 0x00, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x31, 0x1C, 0x80, 0x02, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (SSP1)
						{
							Name(_ADR, 0x05)
							Name(_UPC, Package(4) {0xFF, 0x03, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x31, 0x1C, 0x80, 0x02, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (HSP2)
						{
							Name(_ADR, 0x02)
							Name(_UPC, Package(4) {0xFF, 0xFF, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x30, 0x1C, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (HSP3)
						{
							Name(_ADR, 0x03)
							Name(_UPC, Package(4) {0xFF, 0xFF, 0x00, 0x00})
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x58, 0x1E, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00
								}
							})
							Device (BLTH)
							{
								Name(_ADR, One)
								Name(_PLD, Package(1)
								{
									Buffer(0x10)
									{
										0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
										0x58, 0x1E, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00
									}
								})
							}
							Method (_STA, 0, NotSerialized)
							{
								Return(0x0F)
							}
						}
						Device (HSP4)
						{
							Name(_ADR, 0x04)
							Name(UPC, Package(4) {0xFF, 0xFF, 0x00, 0x00})
							Name(UPCN, Package(4) {0x00, 0x00, 0x00, 0x00})
							Method (_UPC, 0, NotSerialized)
							{
								If(FPEX)
								{
									Return(UPC)
								}
								Else
								{
									Return(UPCN)
								}
							}
							Name(_PLD, Package(1)
							{
								Buffer(0x10)
								{
									0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
									0x30, 0x1C, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00
								}
							})
						}
						Device (SSP2)
						{
							Name(_ADR, 0x06)
							Name(_UPC, Package(4) {0x00, 0x00, 0x00, 0x00})
						}
					}
				}
			}
			Device (GP18)
			{
				Name(_ADR, 0x00080002)
				Method (_PRT, 0, NotSerialized)
				{
					If(GPIC)
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, 0x00, 0x22}, 
							Package(4) {0xFFFF, 0x01, 0x00, 0x23}, 
							Package(4) {0xFFFF, 0x02, 0x00, 0x20}, 
							Package(4) {0xFFFF, 0x03, 0x00, 0x21}
						})
					}
					Else
					{
						Return(Package(4)
						{
							Package(4) {0xFFFF, 0x00, ^^LPC0.LNKC, 0x00}, 
							Package(4) {0xFFFF, 0x01, ^^LPC0.LNKD, 0x00}, 
							Package(4) {0xFFFF, 0x02, ^^LPC0.LNKA, 0x00}, 
							Package(4) {0xFFFF, 0x03, ^^LPC0.LNKB, 0x00}
						})
					}
				}
				Device (SATA)
				{
					Name(_ADR, Zero)
				}
				Device (SAT1)
				{
					Name(_ADR, One)
				}
			}
			Scope (GPP4)
			{
				Device (WLAN)
				{
					Name(_ADR, Zero)
					Name(_S0W, 0x04)
				}
			}
			Scope (GPP6)
			{
				Device (NVME)
				{
					Name(_ADR, Zero)
					Name(_S0W, 0x04)
				}
			}
			Device (SMB)
			{
				Name(_ADR, 0x00140000)
				OperationRegion(SBRV, PCI_Config, 0x08, 0x0100)
				Field(SBRV, AnyAcc, NoLock, Preserve)
				{
					RVID, 8,
					Offset(0x5A),	//Offset(90),
					I1F, 1,
					I12F, 1,
					Offset(0x7A),	//Offset(122),
					, 2,
					G31O, 1,
					Offset(0xD9),	//Offset(217),
					, 6,
					ACIR, 1,
				}
				OperationRegion(PMIO, SystemIO, 0x0CD6, 0x02)
				Field(PMIO, ByteAcc, NoLock, Preserve)
				{
					INPM, 8,
					DAPM, 8,
				}
				IndexField(INPM, DAPM, ByteAcc, NoLock, Preserve)
				{
					, 6,
					HPEN, 1,
					Offset(0x60),	//Offset(96),
					P1EB, 16,
					Offset(0xF0),	//Offset(240),
					, 3,
					RSTU, 1,
				}
				OperationRegion(ERMG, SystemMemory, 0xFED81500, 0x03FF)
				Field(ERMG, AnyAcc, NoLock, Preserve)
				{
					Offset(0x18),	//Offset(24),
					Offset(0x1A),	//Offset(26),
					GE10, 1,
					Offset(0x1C),	//Offset(28),
					Offset(0x1E),	//Offset(30),
					GE11, 1,
					Offset(0x40),	//Offset(64),
					Offset(0x42),	//Offset(66),
					GE12, 1,
					Offset(0x46),	//Offset(70),
					GS17, 1,
					, 5,
					GV17, 1,
					GE17, 1,
					Offset(0x62),	//Offset(98),
					GP62, 8,
					Offset(0x108),	//Offset(264),
					Offset(0x10A),	//Offset(266),
					P33I, 1,
					Offset(0x10C),	//Offset(268),
					Offset(0x10E),	//Offset(270),
					P37I, 1,
					Offset(0x118),	//Offset(280),
					Offset(0x11A),	//Offset(282),
					P3BI, 1,
					Offset(0x11C),	//Offset(284),
					Offset(0x11E),	//Offset(286),
					P40I, 1,
				}
				OperationRegion(ERMM, SystemMemory, 0xFED80000, 0x1000)
				Field(ERMM, ByteAcc, NoLock, Preserve)
				{
					Offset(0x200),	//Offset(512),
					, 1,
					E01S, 1,
					, 3,
					E05S, 1,
					, 2,
					Offset(0x201),	//Offset(513),
					, 7,
					E15S, 1,
					E16S, 1,
					, 5,
					E22S, 1,
					Offset(0x204),	//Offset(516),
					, 1,
					E01E, 1,
					, 3,
					E05E, 1,
					, 2,
					Offset(0x205),	//Offset(517),
					, 7,
					E15E, 1,
					E16E, 1,
					, 5,
					E22E, 1,
					Offset(0x208),	//Offset(520),
					, 1,
					E01C, 1,
					, 3,
					E05C, 1,
					, 4,
					E10C, 1,
					, 4,
					E15C, 1,
					E16C, 1,
					, 4,
					E21C, 1,
					E22C, 1,
					, 3,
					E26C, 1,
					, 5,
					, 1,
					E01L, 1,
					, 3,
					E05L, 1,
					, 2,
					Offset(0x20D),	//Offset(525),
					, 7,
					E15L, 1,
					E16L, 1,
					, 5,
					E22L, 1,
					Offset(0x288),	//Offset(648),
					, 1,
					CLPS, 1,
					Offset(0x299),	//Offset(665),
					, 7,
					G15A, 1,
					Offset(0x2AC),	//Offset(684),
					, 6,
					SRBT, 2,
					Offset(0x2B0),	//Offset(688),
					, 2,
					SLPS, 2,
					Offset(0x2B2),	//Offset(690),
					, 4,
					SPBT, 2,
					Offset(0x362),	//Offset(866),
					, 6,
					MT3A, 1,
					Offset(0x377),	//Offset(887),
					EPNM, 1,
					DPPF, 1,
					Offset(0x3BB),	//Offset(955),
					, 6,
					PWDE, 1,
					Offset(0x3BE),	//Offset(958),
					, 5,
					ALLS, 1,
					Offset(0x3C8),	//Offset(968),
					, 2,
					TFTE, 1,
					Offset(0x3DF),	//Offset(991),
					BLNK, 2,
					Offset(0x3F0),	//Offset(1008),
					PHYD, 1,
					, 1,
					, 1,
					US5R, 1,
					Offset(0x400),	//Offset(1024),
					F0CT, 8,
					F0MS, 8,
					F0FQ, 8,
					F0LD, 8,
					F0MD, 8,
					F0MP, 8,
					LT0L, 8,
					LT0H, 8,
					MT0L, 8,
					MT0H, 8,
					HT0L, 8,
					HT0H, 8,
					LRG0, 8,
					LHC0, 8,
					Offset(0x410),	//Offset(1040),
					F1CT, 8,
					F1MS, 8,
					F1FQ, 8,
					F1LD, 8,
					F1MD, 8,
					F1MP, 8,
					LT1L, 8,
					LT1H, 8,
					MT1L, 8,
					MT1H, 8,
					HT1L, 8,
					HT1H, 8,
					LRG1, 8,
					LHC1, 8,
					Offset(0x420),	//Offset(1056),
					F2CT, 8,
					F2MS, 8,
					F2FQ, 8,
					F2LD, 8,
					F2MD, 8,
					F2MP, 8,
					LT2L, 8,
					LT2H, 8,
					MT2L, 8,
					MT2H, 8,
					HT2L, 8,
					HT2H, 8,
					LRG2, 8,
					LHC2, 8,
					Offset(0x430),	//Offset(1072),
					F3CT, 8,
					F3MS, 8,
					F3FQ, 8,
					F3LD, 8,
					F3MD, 8,
					F3MP, 8,
					LT3L, 8,
					LT3H, 8,
					MT3L, 8,
					MT3H, 8,
					HT3L, 8,
					HT3H, 8,
					LRG3, 8,
					LHC3, 8,
					Offset(0x700),	//Offset(1792),
					SEC, 8,
					, 8,
					MIN, 8,
					Offset(0xD01),	//Offset(3329),
					MX01, 8,
					Offset(0xD07),	//Offset(3335),
					MX07, 8,
					Offset(0xD0E),	//Offset(3342),
					MX14, 8,
					MX15, 8,
					MX16, 8,
					Offset(0xD15),	//Offset(3349),
					MX21, 8,
					MX22, 8,
					MX23, 8,
					Offset(0xD1B),	//Offset(3355),
					MX27, 8,
					MX28, 8,
					Offset(0xD20),	//Offset(3360),
					MX32, 8,
					MX33, 8,
					MX34, 8,
					Offset(0xD29),	//Offset(3369),
					MX41, 8,
					Offset(0xD2C),	//Offset(3372),
					MX44, 8,
					Offset(0xD33),	//Offset(3379),
					MX51, 8,
					, 8,
					MX53, 8,
					Offset(0xD39),	//Offset(3385),
					MX57, 8,
					MX58, 8,
					MX59, 8,
					Offset(0xD42),	//Offset(3394),
					MX66, 8,
					Offset(0xD66),	//Offset(3430),
					M102, 8,
					Offset(0xD6C),	//Offset(3436),
					M108, 8,
					Offset(0xDAA),	//Offset(3498),
					M170, 8,
					Offset(0xDAF),	//Offset(3503),
					M175, 8,
					M176, 8,
					Offset(0xDB4),	//Offset(3508),
					M180, 8,
					M181, 8,
					M182, 8,
					Offset(0xDC5),	//Offset(3525),
					M197, 8,
					, 8,
					M199, 8,
					M200, 8,
					Offset(0xE00),	//Offset(3584),
					MS00, 8,
					MS01, 8,
					MS02, 8,
					MS03, 8,
					MS04, 8,
					Offset(0xE40),	//Offset(3648),
					MS40, 8,
					Offset(0xE81),	//Offset(3713),
					, 2,
					ECES, 1,
				}
				OperationRegion(P1E0, SystemIO, P1EB, 0x04)
				Field(P1E0, ByteAcc, NoLock, Preserve)
				{
					Offset(0x1),	//Offset(1),
					, 6,
					PEWS, 1,
					WSTA, 1,
					Offset(0x3),	//Offset(3),
					, 6,
					PEWD, 1,
				}
				Method (TRMD, 0, NotSerialized)
				{
					Store(Zero, TFTE)
				}
				Method (HTCD, 0, NotSerialized)
				{
				}
				OperationRegion(ABIO, SystemIO, 0x0CD8, 0x08)
				Field(ABIO, DWordAcc, NoLock, Preserve)
				{
					INAB, 32,
					DAAB, 32,
				}
				Method (RDAB, 1, NotSerialized)
				{
					Store(Arg0, INAB)
					Return(DAAB)
				}
				Method (WTAB, 2, NotSerialized)
				{
					Store(Arg0, INAB)
					Store(Arg1, DAAB)
				}
				Method (RWAB, 3, NotSerialized)
				{
					And(RDAB(Arg0), Arg1, Local0)
					Or(Local0, Arg2, Local1)
					WTAB(Arg0, Local1)
				}
				Method (CABR, 3, NotSerialized)
				{
					ShiftLeft(Arg0, 0x05, Local0)
					Add(Local0, Arg1, Local1)
					ShiftLeft(Local1, 0x18, Local2)
					Add(Local2, Arg2, Local3)
					Return(Local3)
				}
			}
			Device (LPC0)
			{
				Name(_ADR, 0x00140003)
				OperationRegion(PIRQ, SystemIO, 0x0C00, 0x02)
				Field(PIRQ, ByteAcc, NoLock, Preserve)
				{
					PIID, 8,
					PIDA, 8,
				}
				IndexField(PIID, PIDA, ByteAcc, NoLock, Preserve)
				{
					PIRA, 8,
					PIRB, 8,
					PIRC, 8,
					PIRD, 8,
					PIRE, 8,
					PIRF, 8,
					PIRG, 8,
					PIRH, 8,
					Offset(0xC),	//Offset(12),
					SIRA, 8,
					SIRB, 8,
					SIRC, 8,
					SIRD, 8,
					PIRS, 8,
					Offset(0x13),	//Offset(19),
					HDAD, 8,
					Offset(0x17),	//Offset(23),
					SDCL, 8,
					Offset(0x1A),	//Offset(26),
					SDIO, 8,
					Offset(0x30),	//Offset(48),
					USB1, 8,
					Offset(0x34),	//Offset(52),
					USB3, 8,
					Offset(0x41),	//Offset(65),
					SATA, 8,
					Offset(0x62),	//Offset(98),
					GIOC, 8,
					Offset(0x70),	//Offset(112),
					I2C0, 8,
					I2C1, 8,
					I2C2, 8,
					I2C3, 8,
					URT0, 8,
					URT1, 8,
				}
				Name(IPRS, ResourceTemplate()
				{
					IRQ(Level, ActiveLow, Shared) {3, 4, 5, 7, 10, 11, 12, 14, 15}
				})
				Name(UPRS, ResourceTemplate()
				{
					IRQ(Level, ActiveLow, Exclusive) {3, 4, 5, 7}
				})
				OperationRegion(KBDD, SystemIO, 0x64, 0x01)
				Field(KBDD, ByteAcc, NoLock, Preserve)
				{
					PD64, 8,
				}
				Method (DSPI, 0, NotSerialized)
				{
					INTA(0x1F)
					INTB(0x1F)
					INTC(0x1F)
					INTD(0x1F)
					Store(PD64, Local1)
					Store(0x1F, PIRE)
					Store(0x1F, PIRF)
					Store(0x1F, PIRG)
					Store(0x1F, PIRH)
				}
				Method (INTA, 1, NotSerialized)
				{
					Store(Arg0, PIRA)
					If(GPIC)
					{
						Store(Arg0, HDAD)
						Store(Arg0, SDCL)
					}
				}
				Method (INTB, 1, NotSerialized)
				{
					Store(Arg0, PIRB)
				}
				Method (INTC, 1, NotSerialized)
				{
					Store(Arg0, PIRC)
					If(GPIC)
					{
						Store(Arg0, USB1)
						Store(Arg0, USB3)
					}
				}
				Method (INTD, 1, NotSerialized)
				{
					Store(Arg0, PIRD)
					If(GPIC)
					{
						Store(Arg0, SATA)
					}
				}
				Device (LNKA)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x01)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRA)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						INTA(0x1F)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRA, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						INTA(Local0)
					}
				}
				Device (LNKB)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x02)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRB)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						INTB(0x1F)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRB, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						INTB(Local0)
					}
				}
				Device (LNKC)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x03)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRC)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						INTC(0x1F)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRC, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						INTC(Local0)
					}
				}
				Device (LNKD)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x04)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRD)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						INTD(0x1F)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRD, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						INTD(Local0)
					}
				}
				Device (LNKE)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x05)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRE)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						Store(0x1F, PIRE)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRE, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						Store(Local0, PIRE)
					}
				}
				Device (LNKF)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x06)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRF)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						Store(0x1F, PIRF)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRF, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						Store(Local0, PIRF)
					}
				}
				Device (LNKG)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x07)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRG)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						Store(0x1F, PIRG)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRG, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						Store(Local0, PIRG)
					}
				}
				Device (LNKH)
				{
					Name(_HID, EISAID("PNP0C0F"))
					Name(_UID, 0x08)
					Method (_STA, 0, NotSerialized)
					{
						If(PIRH)
						{
							Return(0x0B)
						}
						Else
						{
							Return(0x09)
						}
					}
					Method (_PRS, 0, NotSerialized)
					{
						Return(IPRS)
					}
					Method (_DIS, 0, NotSerialized)
					{
						Store(0x1F, PIRH)
					}
					Method (_CRS, 0, NotSerialized)
					{
						Store(IPRS, Local0)
						CreateWordField(Local0, 0x01, IRQ0)
						ShiftLeft(0x01, PIRH, IRQ0)
						Return(Local0)
					}
					Method (_SRS, 1, NotSerialized)
					{
						CreateWordField(Arg0, 0x01, IRQ0)
						FindSetRightBit(IRQ0, Local0)
						Decrement(Local0)
						Store(Local0, PIRH)
					}
				}
				Device (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, Transfer8_16) {4}
					})
				}
				Device (MATH)
				{
					Name(_HID, EISAID("PNP0C04"))
					Name(_CRS, ResourceTemplate()
					{
						IO(Decode16, 0x00F0, 0x00F0, 0x01, 0x0F)
						IRQNoFlags() {13}
					})
				}
				Device (PIC)
				{
					Name(_HID, EISAID("PNP0000"))
					Name(_CRS, ResourceTemplate()
					{
						IO(Decode16, 0x0020, 0x0020, 0x01, 0x02)
						IO(Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
						IRQNoFlags() {2}
					})
				}
				Device (RTC)
				{
					Name(_HID, EISAID("PNP0B00"))
					Name(BUF0, ResourceTemplate()
					{
						IO(Decode16, 0x0070, 0x0070, 0x01, 0x02)
					})
					Name(BUF1, ResourceTemplate()
					{
						IO(Decode16, 0x0070, 0x0070, 0x01, 0x02)
						IRQNoFlags() {8}
					})
					Method (_CRS, 0, Serialized)
					{
						If(LEqual(^^^SMB.HPEN, One))
						{
							Return(BUF0)
						}
						Return(BUF1)
					}
				}
				Device (SPKR)
				{
					Name(_HID, EISAID("PNP0800"))
					Name(_CRS, ResourceTemplate()
					{
						IO(Decode16, 0x0061, 0x0061, 0x01, 0x01)
					})
				}
				Device (TIME)
				{
					Name(_HID, EISAID("PNP0100"))
					Name(_CRS, ResourceTemplate()
					{
						IO(Decode16, 0x0040, 0x0040, 0x01, 0x04)
						IRQ(Edge, ActiveHigh, Exclusive) {0}
					})
				}
				Device (KBC0)
				{
					Name(_HID, "PTL0001")
					Name(_CID, EISAID("PNP0303"))
					Name(_CRS, ResourceTemplate()
					{
						IO(Decode16, 0x0060, 0x0060, 0x01, 0x01)
						IO(Decode16, 0x0064, 0x0064, 0x01, 0x01)
						IRQ(Edge, ActiveHigh, Exclusive) {1}
					})
				}
				Device (SYSR)
				{
					Name(_HID, EISAID("PNP0C02"))
					Name(_CRS, ResourceTemplate()
					{
						IO(Decode16, 0x0022, 0x0022, 0x01, 0x02)
						IO(Decode16, 0x002E, 0x002E, 0x01, 0x02)
						IO(Decode16, 0x0072, 0x0072, 0x01, 0x02)
						IO(Decode16, 0x0080, 0x0080, 0x01, 0x01)
						IO(Decode16, 0x0092, 0x0092, 0x01, 0x01)
						IO(Decode16, 0x00B0, 0x00B0, 0x01, 0x02)
						IO(Decode16, 0x00B2, 0x00B2, 0x01, 0x01)
						IO(Decode16, 0x00B8, 0x00B8, 0x01, 0x01)
						IO(Decode16, 0x00BC, 0x00BC, 0x01, 0x01)
						IO(Decode16, 0x00F0, 0x00F0, 0x01, 0x01)
						IO(Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
						IO(Decode16, 0x0530, 0x0530, 0x01, 0x08)
						IO(Decode16, 0x0400, 0x0400, 0x01, 0x28)
						IO(Decode16, 0x0430, 0x0430, 0x01, 0x01)
						IO(Decode16, 0x0440, 0x0440, 0x01, 0x08)
						IO(Decode16, 0x0B00, 0x0B00, 0x01, 0x20)
						IO(Decode16, 0x0B20, 0x0B20, 0x01, 0x20)
						IO(Decode16, 0x0C00, 0x0C00, 0x01, 0x02)
						IO(Decode16, 0x0C14, 0x0C14, 0x01, 0x01)
						IO(Decode16, 0x0C50, 0x0C50, 0x01, 0x03)
						IO(Decode16, 0x0CD0, 0x0CD0, 0x01, 0x02)
						IO(Decode16, 0x0CD2, 0x0CD2, 0x01, 0x02)
						IO(Decode16, 0x0CD4, 0x0CD4, 0x01, 0x02)
						IO(Decode16, 0x0CD6, 0x0CD6, 0x01, 0x02)
						IO(Decode16, 0x0CD8, 0x0CD8, 0x01, 0x08)
						IO(Decode16, 0x0CF9, 0x0CF9, 0x01, 0x01)
						WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
							0x0000,
							0x8100,
							0x81FF,
							0x0000,
							0x0100
						)
						WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
							0x0000,
							0x8200,
							0x82FF,
							0x0000,
							0x0100
						)
					})
				}
				OperationRegion(LPCS, PCI_Config, 0xA0, 0x04)
				Field(LPCS, DWordAcc, NoLock, Preserve)
				{
					SPBA, 32,
				}
				Device (MEM)
				{
					Name(_HID, EISAID("PNP0C01"))
					Name(MSRC, ResourceTemplate()
					{
						Memory32Fixed(ReadOnly, 0x000E0000, 0x00020000)
						Memory32Fixed(ReadOnly, 0xFF000000, 0x01000000)
						Memory32Fixed(ReadWrite, 0x00000000, 0x00000000)
						Memory32Fixed(ReadWrite, 0xFEC10000, 0x00000020)
						Memory32Fixed(ReadOnly, 0xFED00000, 0x00000400)
						Memory32Fixed(ReadWrite, 0xFED61000, 0x00000400)
						Memory32Fixed(ReadWrite, 0xFED80000, 0x00001000)
					})
					Method (_CRS, 0, NotSerialized)
					{
						CreateDWordField(MSRC, 0x1C, BARX)
						CreateDWordField(MSRC, 0x20, GALN)
						CreateDWordField(MSRC, 0x28, MB01)
						CreateDWordField(MSRC, 0x2C, ML01)
						Store(SPBA, Local0)
						And(Local0, 0xFFFFFFE0, MB01)
						Store(NBBA, Local0)
						If(Local0)
						{
							Store(0x1000, GALN)
							And(Local0, 0xFFFFFFF0, BARX)
						}
						Return(MSRC)
					}
					Method (_STA, 0, NotSerialized)
					{
						Return(0x0F)
					}
				}
				Scope (\)
				{
					Name(ECON, 0x01)
				}
				Scope (\)
				{
					OperationRegion(LFCN, SystemMemory, 0xCB775B18, 0x00FF)
					Field(LFCN, AnyAcc, Lock, Preserve)
					{
						TSEX, 8,
						FPEX, 8,
						PS2V, 8,
						KBID, 8,
						MCSZ, 8,
						OKRB, 8,
						HEAD, 80,
						PAID, 16,
						REST, 928,
						TPTY, 8,
						SORV, 8,
						TPTP, 16,
						TPNY, 8,
						TPNP, 16,
						DYTP, 32,
						FCAP, 16,
						VSTD, 1,
						, 1,
						VFBC, 1,
						VMYH, 1,
						VSTP, 1,
						VAPM, 1,
						VAQM, 1,
						, 1,
						, 1,
						, 1,
						VAAA, 1,
						VMMC, 1,
						, 1,
						, 1,
						, 1,
						, 1,
						MYHC, 8,
						MMCC, 8,
						SMYH, 8,
						SMMC, 8,
						CICF, 4,
						CICM, 4,
						HDIS, 8,
						LFCO, 800,
					}
					OperationRegion(SMIO, SystemIO, 0xB0, 0x02)
					Field(SMIO, ByteAcc, NoLock, Preserve)
					{
						SMBA, 8,
						SMBB, 8,
					}
				}
				Device (EC0)
				{
					Name(_HID, EISAID("PNP0C09"))
					Name(_UID, 0x01)
					Name(ECAV, Zero)
					Name(DPTI, Buffer(0x07){})
					Name(XX11, Buffer(0x07){})
					CreateWordField(XX11, 0x00, SSZE)
					CreateByteField(XX11,0x02,SMUF)
					CreateDWordField(XX11, 0x03, SMUD)
					Store(0x07, SSZE)
					Name(SPL2, 0x61A8)
					Name(SPL3, 0x2EE0)
					Name(SPL9, 0x4E20)
					Name(SPP2, 0x927C)
					Name(SPP3, 0x3A98)
					Name(SPP9, 0x4E20)
					Name(FPP2, 0xA410)
					Name(FPP3, 0x4E20)
					Name(FPP9, 0x7530)
					Name(TDC2, 0xABE0)
					Name(TDC3, 0x88B8)
					Name(TDC9, 0x88B8)
					Name(EDC2, 0x00011170)
					Name(EDC3, 0xAFC8)
					Name(EDC9, 0xAFC8)
					Name(SPT2, 0x0F)
					Name(SPT3, 0x05)
					Name(SPT9, 0x05)
					Name(STC2, 0x01F4)
					Name(STC3, 0xC8)
					Name(STC9, 0xC8)
					Name(TCL2, 0x62)
					Name(TCL3, 0x5F)
					Name(TCL9, 0x5F)
					Name(SPL4, 0x3A98)
					Name(SPP4, 0x3A98)
					Name(FPP4, 0x4E20)
					Name(SPL5, 0x4E20)
					Name(SPP5, 0x7530)
					Name(FPP5, 0x9C40)
					Name(SPL6, 0x3A98)
					Name(SPP6, 0x4650)
					Name(FPP6, 0x4E20)
					Mutex(LFCM, 0)
					Name(_GPE, 0x03)
					Method (_CRS, 0, NotSerialized)
					{
						Name(BFFR, ResourceTemplate()
						{
							IO(Decode16, 0x0062, 0x0062, 0x00, 0x01)
							IO(Decode16, 0x0066, 0x0066, 0x00, 0x01)
						})
						Return(BFFR)
					}
					Method (_STA, 0, NotSerialized)
					{
						If(LEqual(ECON, 0x01))
						{
							Return(0x0F)
						}
						Return(0x00)
					}
					OperationRegion(ECB2, SystemMemory, 0xFE00D22E, 0xFF)
					Field(ECB2, AnyAcc, Lock, Preserve)
					{
						BAR1, 184,
						BAR2, 80,
					}
					OperationRegion(ERAM, EmbeddedControl, 0x00, 0xFF)
					Field(ERAM, ByteAcc, Lock, Preserve)
					{
						VCMD, 8,
						Offset(0x60),	//Offset(96),
						SMPR, 8,
					}
					OperationRegion(ERAX, SystemMemory, 0xFE00D400, 0xFF)
					Field(ERAX, ByteAcc, Lock, Preserve)
					{
						, 8,
						VDAT, 8,
						VPCS, 8,
						Offset(0x6),	//Offset(6),
						FANS, 8,
						BUSG, 1,
						BLEG, 1,
						BATF, 1,
						BNSM, 1,
						BTST, 1,
						BBAD, 1,
						AUTO, 1,
						FCHG, 1,
						ABTL, 8,
						DBTL, 8,
						EDCC, 1,
						ALSC, 1,
						CDMB, 1,
						CCSB, 1,
						BTSM, 1,
						BTCM, 1,
						LBTM, 1,
						CSBM, 1,
						SGST, 1,
						HDMI, 1,
						HYBD, 1,
						SWST, 1,
						EVNT, 1,
						DCRF, 1,
						COLR, 1,
						SGCN, 1,
						ODPO, 1,
						EODD, 1,
						ODPK, 1,
						CMEX, 1,
						CMON, 1,
						SODD, 1,
						ODFB, 1,
						EODS, 1,
						RTMP, 8,
						VTMP, 8,
						AFCC, 8,
						PINF, 3,
						SUPR, 1,
						GTMP, 1,
						QUIT, 1,
						LS35, 1,
						, 1,
						RMBT, 1,
						RSBT, 1,
						VTYP, 2,
						, 4,
						FUSL, 8,
						FUSH, 8,
						FWBT, 64,
						, 8,
						SPMO, 8,
						, 8,
						LSKV, 8,
						FCMO, 8,
						Offset(0x31),	//Offset(49),
						GIRT, 8,
						PIRT, 8,
						KIRT, 8,
						IRTI, 8,
						, 8,
						DGPU, 8,
						GUST, 8,
						GDST, 8,
						FCST, 8,
						Offset(0x43),	//Offset(67),
						ECTP, 8,
						Offset(0x4A),	//Offset(74),
						ESMC, 1,
						, 7,
						EMOD, 8,
						BFUD, 16,
						Offset(0x5D),	//Offset(93),
						EXSI, 8,
						EXSB, 8,
						EXND, 8,
						, 8,
						SMST, 8,
						SMAD, 8,
						SMCM, 8,
						SMDA, 256,
						BCNT, 8,
						SMAA, 8,
						SAD0, 8,
						SAD1, 8,
						, 1,
						, 1,
						, 1,
						, 1,
						, 1,
						FBFG, 1,
						Offset(0x8A),	//Offset(138),
						KBLO, 1,
						UCHE, 1,
						KLCH, 1,
						, 1,
						KLFS, 1,
						KLOR, 1,
						CIBM, 1,
						UCER, 1,
						TPDV, 3,
						, 5,
						QCHO, 1,
						BKLT, 1,
						, 1,
						, 1,
						, 1,
						QCBX, 1,
						, 2,
						FLBT, 1,
						PSYS, 1,
						LBPR, 1,
						, 1,
						, 1,
						, 1,
						OVLD, 1,
						Offset(0x8F),	//Offset(143),
						BMN0, 72,
						BDN0, 64,
						IBTL, 1,
						IBCL, 1,
						ISS0, 1,
						IRTC, 1,
						ISUP, 1,
						ISC2, 1,
						IWAK, 1,
						, 1,
						, 1,
						VOUT, 1,
						TPAD, 1,
						HKDB, 1,
						, 4,
						, 8,
						OSTY, 3,
						, 1,
						ADPI, 2,
						, 1,
						ADPT, 1,
						PMEW, 1,
						MODW, 1,
						LANW, 1,
						RTCW, 1,
						WLAW, 1,
						USBW, 1,
						KEYW, 1,
						TPWK, 1,
						CHCR, 1,
						ADPP, 1,
						LERN, 1,
						ACMD, 1,
						BOVP, 1,
						LEAK, 1,
						AIRP, 1,
						ACOF, 1,
						S3EN, 1,
						S3RS, 1,
						S4EN, 1,
						S4RS, 1,
						S5EN, 1,
						S5RS, 1,
						, 2,
						OSTT, 8,
						OSST, 8,
						THRT, 8,
						TCOT, 8,
						MODE, 1,
						, 2,
						INIT, 1,
						FAN1, 1,
						FAN2, 1,
						FAOK, 1,
						SKIN, 1,
						SDTE, 8,
						SPDN, 4,
						FNUM, 4,
						TLVL, 4,
						, 2,
						THSW, 1,
						TPIN, 1,
						TSTH, 1,
						TSCP, 1,
						, 2,
						PLVL, 4,
						CPUT, 8,
						CPTL, 8,
						Offset(0xB7),	//Offset(183),
						, 1,
						PWDB, 1,
						DIGT, 1,
						CDLK, 1,
						, 4,
						, 1,
						LSTE, 1,
						PMEE, 1,
						PWBE, 1,
						RNGE, 1,
						BTWE, 1,
						, 2,
						LCBV, 8,
						AOAC, 1,
						S35F, 1,
						IFFS, 1,
						INS0, 1,
						ISBL, 1,
						ISOV, 1,
						, 1,
						ISRT, 1,
						WLAN, 1,
						BLUE, 1,
						WEXT, 1,
						BEXT, 1,
						KILL, 1,
						WLOK, 1,
						EN3G, 1,
						EX3G, 1,
						KPID, 8,
						CTYP, 3,
						CORE, 3,
						GATY, 2,
						BA1P, 1,
						BA2P, 1,
						, 2,
						B1CH, 1,
						B2CH, 1,
						, 2,
						PBY1, 1,
						PBY2, 1,
						, 2,
						SMB1, 1,
						SMB2, 1,
						, 2,
						B1TY, 1,
						B1MD, 1,
						B1LW, 1,
						, 1,
						B1MF, 3,
						, 1,
						B1ST, 8,
						B1RC, 16,
						B1SN, 16,
						B1FV, 16,
						B1DV, 16,
						B1DC, 16,
						B1FC, 16,
						B1GS, 8,
						B1XX, 8,
						B1CR, 16,
						B1AC, 16,
						B1PC, 8,
						B1VL, 8,
						B1TM, 8,
						B1AT, 8,
						B1CC, 16,
						B1TC, 8,
						B1CI, 8,
						B1CU, 8,
						B1CA, 8,
						B1SM, 16,
						B1VC, 8,
						B1FA, 8,
						B1VA, 8,
						B1C1, 16,
						B1C2, 16,
						B1C3, 16,
						B1C4, 16,
						Offset(0xEE),	//Offset(238),
						B1CT, 16,
						B1EX, 1,
						B1FL, 1,
						B1EP, 1,
						B1FI, 1,
						, 2,
						B1RE, 1,
						, 1,
						B1LL, 1,
						B1CE, 1,
						B1SE, 1,
						B1S5, 1,
						B1SR, 1,
						B1SC, 1,
						, 2,
						B1TO, 1,
						B1BC, 1,
						B1CF, 1,
						B1CS, 1,
						B1SG, 1,
						B1SU, 1,
						B1OV, 1,
						B1OT, 1,
						B1TT, 1,
						B1SA, 1,
						B1SS, 1,
						, 1,
						B1SF, 1,
						B1WN, 1,
						, 2,
						B1DA, 16,
						Offset(0xF8),	//Offset(248),
						B1CN, 8,
						ITMD, 1,
						, 7,
						, 8,
						FBRS, 1,
						Offset(0xFE),	//Offset(254),
						FA2S, 8,
					}
					OperationRegion(ECMS, SystemIO, 0x72, 0x02)
					Field(ECMS, ByteAcc, Lock, Preserve)
					{
						INDX, 8,
						DATA, 8,
					}
					Method (RECM, 1, Serialized)
					{
						Store(Arg0, INDX)
						Return(DATA)
					}
					Method (WECM, 2, Serialized)
					{
						Store(Arg0, INDX)
						Store(Arg1, DATA)
					}
					OperationRegion(CMDE, SystemIO, 0x62, 0x0B)
					Field(CMDE, ByteAcc, Lock, Preserve)
					{
						EC62, 8,
						, 8,
						, 8,
						, 8,
						EC66, 8,
						, 8,
						EC68, 8,
						, 8,
						, 8,
						, 8,
						EC6C, 8,
					}
					Method (WIBE, 1, Serialized)
					{
						Store(0x00010000, Local0)
						While(Local0)
						{
							If(LEqual(Arg0, 0x01))
							{
								Store(EC66, Local1)
							}
							Else
							{
								If(LEqual(Arg0, 0x02))
								{
									Store(EC6C, Local1)
								}
								Else
								{
									Return(0x02)
								}
							}
							If(LEqual(And(Local1, 0x02), 0x00))
							{
								Return(0x00)
							}
							Stall(0x0A)
							Decrement(Local0)
						}
						Return(0x01)
					}
					Method (WOBF, 1, Serialized)
					{
						Store(0x00010000, Local0)
						While(Local0)
						{
							If(LEqual(Arg0, 0x01))
							{
								Store(EC66, Local1)
							}
							Else
							{
								If(LEqual(Arg0, 0x02))
								{
									Store(EC6C, Local1)
								}
								Else
								{
									Return(0x02)
								}
							}
							If(LEqual(And(Local1, 0x01), 0x01))
							{
								Return(0x00)
							}
							Stall(0x0A)
							Decrement(Local0)
						}
						Return(0x01)
					}
					Method (WOBE, 1, Serialized)
					{
						Store(0x00010000, Local0)
						While(Local0)
						{
							If(LEqual(Arg0, 0x01))
							{
								Store(EC66, Local1)
							}
							Else
							{
								If(LEqual(Arg0, 0x02))
								{
									Store(EC6C, Local1)
								}
								Else
								{
									Return(0x02)
								}
							}
							If(LEqual(And(Local1, 0x01), 0x01))
							{
								If(LEqual(Arg0, 0x01))
								{
									Store(EC62, Local2)
								}
								Else
								{
									If(LEqual(Arg0, 0x02))
									{
										Store(EC68, Local2)
									}
									Else
									{
										Return(0x02)
									}
								}
							}
							Else
							{
								Return(0x00)
							}
							Stall(0x0A)
							Decrement(Local0)
						}
						Return(0x01)
					}
					Method (LCMD, 2, Serialized)
					{
						Name(LBUF, Buffer(0x1E)
						{
							0x00
						})
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBE(0x02), 0x00))
						{
							Return(0x01)
						}
						Store(Arg0, EC6C)
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						If(LAnd(LNotEqual(Arg1, 0x00), LNotEqual(Arg1, 0xFF)))
						{
							Store(Arg1, EC68)
							If(LNotEqual(WIBE(0x02), 0x00))
							{
								Return(0x01)
							}
						}
						If(LNotEqual(WOBF(0x02), 0x00))
						{
							Return(0x01)
						}
						Store(EC68, Local0)
						Store(0x00, Local1)
						While(Local0)
						{
							If(LNotEqual(WOBF(0x02), 0x00))
							{
								Return(0x01)
							}
							Store(EC68, Index(LBUF, Local1))
							Increment(Local1)
							Decrement(Local0)
						}
						Return(LBUF)
					}
					Method (NCMD, 2, Serialized)
					{
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBE(0x02), 0x00))
						{
							Return(0x01)
						}
						Store(Arg0, EC6C)
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						If(LAnd(LNotEqual(Arg1, 0x00), LNotEqual(Arg1, 0xFF)))
						{
							Store(Arg1, EC68)
							If(LNotEqual(WIBE(0x02), 0x00))
							{
								Return(0x01)
							}
						}
						Return(0x00)
					}
					Method (SCMD, 2, Serialized)
					{
						Name(LBUF, Buffer(0x1E)
						{
							0x00
						})
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBE(0x01), 0x00))
						{
							Return(0x01)
						}
						Store(Arg0, EC66)
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						If(LAnd(LNotEqual(Arg1, 0x00), LNotEqual(Arg1, 0xFF)))
						{
							Store(Arg1, EC62)
							If(LNotEqual(WIBE(0x01), 0x00))
							{
								Return(0x01)
							}
						}
						If(LNotEqual(WOBF(0x01), 0x00))
						{
							Return(0x01)
						}
						Store(EC62, Local0)
						Store(0x00, Local1)
						While(Local0)
						{
							If(LNotEqual(WOBF(0x01), 0x00))
							{
								Return(0x01)
							}
							Store(EC62, Index(LBUF, Local1))
							Increment(Local1)
							Decrement(Local0)
						}
						Return(LBUF)
					}
					Method (TCMD, 2, Serialized)
					{
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBE(0x01), 0x00))
						{
							Return(0x01)
						}
						Store(Arg0, EC66)
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						If(LAnd(LNotEqual(Arg1, 0x00), LNotEqual(Arg1, 0xFF)))
						{
							Store(Arg1, EC62)
							If(LNotEqual(WIBE(0x01), 0x00))
							{
								Return(0x01)
							}
						}
						Return(0x00)
					}
					Method (LRAM, 2, Serialized)
					{
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBE(0x02), 0x00))
						{
							Return(0x01)
						}
						Store(0x7E, EC6C)
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						Store(Arg0, EC68)
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						Store(Arg1, EC68)
						If(LNotEqual(WIBE(0x02), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBF(0x02), 0x00))
						{
							Return(0x01)
						}
						Return(EC68)
					}
					Method (SRAM, 2, Serialized)
					{
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBE(0x01), 0x00))
						{
							Return(0x01)
						}
						Store(0x7E, EC66)
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						Store(Arg0, EC62)
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						Store(Arg1, EC62)
						If(LNotEqual(WIBE(0x01), 0x00))
						{
							Return(0x01)
						}
						If(LNotEqual(WOBF(0x01), 0x00))
						{
							Return(0x01)
						}
						Return(EC62)
					}
					Device (BAT0)
					{
						Name(_HID, EISAID("PNP0C0A"))
						Name(_UID, 0x01)
						Name(_PCL, Package(1) {_SB})
						Name(PBIF, Package(13)
						{
							0x00, 0xFFFFFFFF, 0xFFFFFFFF, 0x01, 0xFFFFFFFF, 0x00, 0x00, 0x64,
							0x00, "LCFC", "BAT20101001", "LiP", "LENOVO"
						})
						Name(XBIF, Package(21)
						{
							0x01, 0x00, 0xFFFFFFFF, 0xFFFFFFFF, 0x01, 0xFFFFFFFF, 0x00, 0x00,
							0x00, 0x00017318, 0xFFFFFFFF, 0xFFFFFFFF, 0x03E8, 0x03E8, 0x64, 0x00,
							"LCFC", "BAT20101001", "LiP", "LENOVO", 0x01
						})
						Name(PBST, Package(4) {0x01, 0x0A90, 0x1000, 0x2A30})
						Method (_STA, 0, NotSerialized)
						{
							If(LEqual(ECON, 0x01))
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										Store(BA1P, Local0)
										Release(LFCM)
									}
								}
								If(And(Local0, 0x01))
								{
									Return(0x1F)
								}
								Else
								{
									Return(0x0F)
								}
							}
							Else
							{
								Return(0x00)
							}
						}
						Method (_BIF, 0, NotSerialized)
						{
							If(LEqual(ECAV, 0x01))
							{
								If(LEqual(Acquire(LFCM, 0xA000), 0x00))
								{
									Store(B1DC, Local0)
									Multiply(Local0, 0x0A, Local0)
									Store(Local0, Index(PBIF, 0x01))
									Store(B1FC, Local0)
									Multiply(Local0, 0x0A, Local0)
									Store(Local0, Index(PBIF, 0x02))
									Store(B1DV, Index(PBIF, 0x04))
									If(B1FC)
									{
										Store(Divide(Multiply(B1FC, 0x0A), 0x0A, , ), Index(PBIF, 0x05))
										Store(Divide(Multiply(B1DC, 0x0A), 0x64, , ), Index(PBIF, 0x07))
									}
									Store("", Index(PBIF, 0x09))
									Store("", Index(PBIF, 0x0A))
									Store("", Index(PBIF, 0x0B))
									Store("", Index(PBIF, 0x0C))
									Name(BDNT, Buffer(0x09)
									{
										0x00
									})
									Store(BDN0, BDNT)
									Store(ShiftLeft(BDNT, Ones), Index(PBIF, 0x09))
									Store(B1SN, Local0)
									Name(SERN, Buffer(0x06)
									{
										0x20, 0x20, 0x20, 0x20, 0x20, 0x00
									})
									Store(0x04, Local2)
									While(Local0)
									{
										Divide(Local0, 0x0A, Local1, Local0)
										Add(Local1, 0x30, Index(SERN, Local2))
										Decrement(Local2)
									}
									Store(SERN, Index(PBIF, 0x0A))
									Name(DCH0, Buffer(0x0A)
									{
										0x00
									})
									Name(DCH1, "LION")
									Name(DCH2, "LiP")
									If(LEqual(B1TY, 0x01))
									{
										Store(DCH1, DCH0)
										Store(ShiftLeft(DCH0, Ones), Index(PBIF, 0x0B))
									}
									Else
									{
										Store(DCH2, DCH0)
										Store(ShiftLeft(DCH0, Ones), Index(PBIF, 0x0B))
									}
									Name(BMNT, Buffer(0x0A)
									{
										0x00
									})
									Store(BMN0, BMNT)
									Store(ShiftLeft(BMNT, Ones), Index(PBIF, 0x0C))
									Release(LFCM)
								}
							}
							Return(PBIF)
						}
						Method (_BIX, 0, NotSerialized)
						{
							If(LEqual(ECAV, 0x01))
							{
								If(LEqual(Acquire(LFCM, 0xA000), 0x00))
								{
									Store(B1DC, Local0)
									Multiply(Local0, 0x0A, Local0)
									Store(Local0, Index(XBIF, 0x02))
									Store(B1FC, Local0)
									Multiply(Local0, 0x0A, Local0)
									Store(Local0, Index(XBIF, 0x03))
									Store(B1DV, Index(XBIF, 0x05))
									If(B1FC)
									{
										Store(Divide(Multiply(B1FC, 0x0A), 0x0A, , ), Index(XBIF, 0x06))
										Store(Divide(Multiply(B1DC, 0x0A), 0x64, , ), Index(XBIF, 0x0E))
									}
									Store(B1CT, Index(XBIF, 0x08))
									Store("", Index(XBIF, 0x10))
									Store("", Index(XBIF, 0x11))
									Store("", Index(XBIF, 0x12))
									Store("", Index(XBIF, 0x13))
									Name(BDNT, Buffer(0x09)
									{
										0x00
									})
									Store(BDN0, BDNT)
									Store(ShiftLeft(BDNT, Ones), Index(XBIF, 0x10))
									Store(B1SN, Local0)
									Name(SERN, Buffer(0x06)
									{
										0x20, 0x20, 0x20, 0x20, 0x20, 0x00
									})
									Store(0x04, Local2)
									While(Local0)
									{
										Divide(Local0, 0x0A, Local1, Local0)
										Add(Local1, 0x30, Index(SERN, Local2))
										Decrement(Local2)
									}
									Store(SERN, Index(XBIF, 0x11))
									Name(DCH0, Buffer(0x0A)
									{
										0x00
									})
									Name(DCH1, "LION")
									Name(DCH2, "LiP")
									If(LEqual(B1TY, 0x01))
									{
										Store(DCH1, DCH0)
										Store(ShiftLeft(DCH0, Ones), Index(XBIF, 0x12))
									}
									Else
									{
										Store(DCH2, DCH0)
										Store(ShiftLeft(DCH0, Ones), Index(XBIF, 0x12))
									}
									Name(BMNT, Buffer(0x0A)
									{
										0x00
									})
									Store(BMN0, BMNT)
									Store(ShiftLeft(BMNT, Ones), Index(XBIF, 0x13))
									Release(LFCM)
								}
							}
							Return(XBIF)
						}
						Name(OBST, 0x00)
						Name(OBAC, 0x00)
						Name(OBPR, 0x00)
						Name(OBRC, 0x00)
						Name(OBPV, 0x00)
						Method (_BST, 0, Serialized)
						{
							Name(_T_0, Zero)
							If(LEqual(ECAV, 0x01))
							{
								If(LEqual(Acquire(LFCM, 0xA000), 0x00))
								{
									Sleep(0x10)
									Store(B1ST, Local0)
									Store(DerefOf(Index(PBST, 0x00)), Local1)
									While(One)
									{
										Store(And(Local0, 0x07), _T_0)
										If(LEqual(_T_0, 0x00))
										{
											Store(And(Local1, 0xF8), OBST)
										}
										Else
										{
											If(LEqual(_T_0, 0x01))
											{
												Store(Or(0x01, And(Local1, 0xF8)), OBST)
											}
											Else
											{
												If(LEqual(_T_0, 0x02))
												{
													Store(Or(0x02, And(Local1, 0xF8)), OBST)
												}
												Else
												{
													If(LEqual(_T_0, 0x04))
													{
														Store(Or(0x04, And(Local1, 0xF8)), OBST)
													}
												}
											}
										}
										Break
									}
									Sleep(0x10)
									Store(B1AC, OBAC)
									If(And(OBST, 0x01))
									{
										If(LNotEqual(OBAC, Zero))
										{
											Store(And(Not(OBAC), 0x7FFF), OBAC)
										}
									}
									Else
									{
										If(LNotEqual(FBFG, 0x01))
										{
											If(And(OBAC, 0x8000))
											{
												Store(0x00, OBAC)
											}
										}
									}
									Sleep(0x10)
									Store(B1RC, OBRC)
									Sleep(0x10)
									Store(B1FV, OBPV)
									Multiply(OBRC, 0x0A, OBRC)
									Store(Divide(Multiply(OBAC, OBPV), 0x03E8, , ), OBPR)
									Store(OBST, Index(PBST, 0x00))
									Store(OBPR, Index(PBST, 0x01))
									Store(OBRC, Index(PBST, 0x02))
									Store(OBPV, Index(PBST, 0x03))
									Release(LFCM)
								}
							}
							Return(PBST)
						}
					}
					Scope (\_SB.PCI0.LPC0.EC0)
					{
						Device (VPC0)
						{
							Name(_HID, "VPC2004")
							Name(_UID, 0x00)
							Name(_VPC, 0xFE0D0018)
							Name(VPCD, 0x00)
							Method (_STA, 0, NotSerialized)
							{
								Return(0x0F)
							}
							Method (_CFG, 0, NotSerialized)
							{
								Return(_VPC)
							}
							Method (VPCR, 1, Serialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										If(LEqual(Arg0, 0x01))
										{
											Store(VCMD, VPCD)
										}
										Else
										{
											Store(VDAT, VPCD)
										}
										Release(LFCM)
									}
								}
								Return(VPCD)
							}
							Method (VPCW, 2, Serialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										If(LEqual(Arg0, 0x01))
										{
											Store(Arg1, VCMD)
										}
										Else
										{
											Store(Arg1, VDAT)
										}
										Release(LFCM)
									}
								}
								Return(0x00)
							}
							Method (SVCR, 1, Serialized)
							{
							}
							Method (HALS, 0, NotSerialized)
							{
								Store(Zero, Local0)
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										Or(Local0, 0x40, Local0)
										If(LEqual(One, UCHE))
										{
											Or(Local0, 0x80, Local0)
										}
										Or(Local0, 0x0200, Local0)
										If(HKDB)
										{
											Or(Local0, 0x0400, Local0)
										}
										Or(Local0, 0x0800, Local0)
										If(ITMD)
										{
											Or(Local0, 0x2000, Local0)
										}
										Or(Local0, 0x4000, Local0)
										If(LEqual(One, CIBM))
										{
											Or(Local0, 0x8000, Local0)
										}
										Release(LFCM)
									}
								}
								Return(Local0)
							}
							Method (SALS, 1, Serialized)
							{
								Store(ToInteger(Arg0), Local0)
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										If(LEqual(Local0, 0x08))
										{
											Store(0x01, KBLO)
											Release(LFCM)
											Return(0x00)
										}
										If(LEqual(Local0, 0x09))
										{
											Store(0x00, KBLO)
											Release(LFCM)
											Return(0x00)
										}
										If(LEqual(Local0, 0x0A))
										{
											Store(0x01, UCHE)
											Store(0x32, SMBB)
											Store(0xCA, SMBA)
											Release(LFCM)
											Return(0x00)
										}
										If(LEqual(Local0, 0x0B))
										{
											Store(0x00, UCHE)
											Store(0x33, SMBB)
											Store(0xCA, SMBA)
											Release(LFCM)
											Return(0x00)
										}
										If(LEqual(Local0, 0x0E))
										{
											Store(0x01, HKDB)
											Store(0x31, SMBB)
											Store(0xCA, SMBA)
											Release(LFCM)
											Return(0x00)
										}
										If(LEqual(Local0, 0x0F))
										{
											Store(0x00, HKDB)
											Store(0x30, SMBB)
											Store(0xCA, SMBA)
											Release(LFCM)
											Return(0x00)
										}
										If(LEqual(Local0, 0x12))
										{
											Store(0x00, CIBM)
											Store(0x34, SMBB)
											Store(0xCA, SMBA)
											Release(LFCM)
											Return(0x00)
										}
										If(LEqual(Local0, 0x13))
										{
											Store(0x01, CIBM)
											Store(0x35, SMBB)
											Store(0xCA, SMBA)
											Release(LFCM)
											Return(0x00)
										}
										Release(LFCM)
									}
								}
								Return(Zero)
							}
							Method (GBMD, 0, NotSerialized)
							{
								Store(0x10000000, Local0)
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										If(LEqual(One, CDMB))
										{
											Or(Local0, One, Local0)
										}
										If(LEqual(0x01, QCBX))
										{
											If(LEqual(One, QCHO))
											{
												Or(Local0, 0x04, Local0)
											}
										}
										If(LEqual(One, BBAD))
										{
											Or(Local0, 0x08, Local0)
										}
										If(LEqual(One, BTSM))
										{
											Or(Local0, 0x20, Local0)
										}
										If(LEqual(One, BLEG))
										{
											Or(Local0, 0x80, Local0)
										}
										If(LEqual(One, BATF))
										{
											Or(Local0, 0x0100, Local0)
										}
										If(LEqual(Zero, BTSM))
										{
											Or(Local0, 0x0200, Local0)
										}
										If(LEqual(One, BUSG))
										{
											Or(Local0, 0x0800, Local0)
										}
										If(LEqual(0x00, ADPI))
										{
											And(Local0, 0xFFFE7FFF, Local0)
										}
										If(LEqual(0x01, ADPI))
										{
											Or(Local0, 0x8000, Local0)
										}
										If(LEqual(0x02, ADPI))
										{
											Or(Local0, 0x00010000, Local0)
										}
										If(LEqual(0x01, QCBX))
										{
											Or(Local0, 0x00020000, Local0)
										}
										Or(Local0, 0x00040000, Local0)
										If(LEqual(One, ESMC))
										{
											Or(Local0, 0x00400000, Local0)
										}
										Release(LFCM)
									}
								}
								Return(Local0)
							}
							Name(VBST, 0x00)
							Name(VBAC, 0x00)
							Name(VBPR, 0x00)
							Name(VBRC, 0x00)
							Name(VBPV, 0x00)
							Name(VBFC, 0x00)
							Name(VBCT, 0x00)
							Method (SMTF, 1, NotSerialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										If(LEqual(Arg0, 0x00))
										{
											If(LEqual(B1FV, Zero))
											{
												Release(LFCM)
												Return(0xFFFF)
											}
											If(LEqual(B1AC, Zero))
											{
												Release(LFCM)
												Return(0xFFFF)
											}
											Store(B1FC, Local0)
											Multiply(Local0, 0x0A, Local0)
											Store(Local0, VBFC)
											Store(B1RC, Local1)
											Multiply(Local1, 0x0A, Local1)
											Store(Local1, VBRC)
											If(LGreater(VBFC, VBRC))
											{
												Store(B1FV, VBPV)
												Store(B1AC, VBAC)
												Subtract(Local0, Local1, Local0)
												Store(Multiply(VBAC, VBPV), Local1)
												Store(Multiply(Local0, 0x03E8), Local3)
												Store(Multiply(Local3, 0x3C), Local3)
												Store(Divide(Local3, Local1, , ), VBCT)
												Release(LFCM)
												Return(VBCT)
											}
											Else
											{
												Release(LFCM)
												Return(0xFFFF)
											}
										}
										If(LEqual(Arg0, 0x01))
										{
											Release(LFCM)
											Return(0xFFFF)
										}
										Release(LFCM)
									}
								}
								Return(0xFFFF)
							}
							Name(QBST, 0x00)
							Name(QBAC, 0x00)
							Name(QBPR, 0x00)
							Name(QBRC, 0x00)
							Name(QBPV, 0x00)
							Name(QBFC, 0x00)
							Name(QBCT, 0x00)
							Method (SMTE, 1, NotSerialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										If(LEqual(Arg0, 0x00))
										{
											If(LEqual(B1FV, Zero))
											{
												Release(LFCM)
												Return(0xFFFF)
											}
											If(LEqual(B1AC, Zero))
											{
												Release(LFCM)
												Return(0xFFFF)
											}
											Store(B1RC, Local0)
											Multiply(Local0, 0x0A, Local0)
											Store(Local0, QBRC)
											Store(B1FC, Local1)
											Multiply(Local1, 0x0A, Local1)
											Store(Local1, QBFC)
											If(LGreater(QBFC, QBRC))
											{
												Store(B1FV, QBPV)
												If(LEqual(And(B1AC, 0x8000), Zero))
												{
													Store(B1AC, QBAC)
												}
												Else
												{
													Store(Subtract(0xFFFF, B1AC), QBAC)
												}
												Store(Multiply(QBAC, QBPV), Local1)
												Store(Multiply(Local0, 0x03E8), Local3)
												Store(Multiply(Local3, 0x3C), Local3)
												Store(Divide(Local3, Local1, , ), QBCT)
												Release(LFCM)
												Return(QBCT)
											}
											Else
											{
												Release(LFCM)
												Return(0xFFFF)
											}
										}
										If(LEqual(Arg0, 0x01))
										{
											Release(LFCM)
											Return(0xFFFF)
										}
										Release(LFCM)
									}
								}
								Return(0xFFFF)
							}
							Method (SBMC, 1, NotSerialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										If(LEqual(Arg0, Zero))
										{
											Store(0x00, CDMB)
											Store(One, EDCC)
											Release(LFCM)
											Return(Zero)
										}
										If(LEqual(Arg0, One))
										{
											Store(One, CDMB)
											Release(LFCM)
											Return(Zero)
										}
										If(LEqual(Arg0, 0x03))
										{
											Store(One, BTSM)
											Release(LFCM)
											Return(Zero)
										}
										If(LEqual(Arg0, 0x05))
										{
											Store(0x00, BTSM)
											Release(LFCM)
											Return(Zero)
										}
										If(LEqual(0x01, QCBX))
										{
											If(LEqual(Arg0, 0x07))
											{
												Store(One, QCHO)
												Store(Zero, BTSM)
												Release(LFCM)
												Return(Zero)
											}
											If(LEqual(Arg0, 0x08))
											{
												Store(Zero, QCHO)
												Release(LFCM)
												Return(Zero)
											}
										}
										If(LEqual(Arg0, 0x09))
										{
											Store(One, ESMC)
											Release(LFCM)
											Return(Zero)
										}
										If(LEqual(Arg0, 0x10))
										{
											Store(Zero, ESMC)
											Release(LFCM)
											Return(Zero)
										}
										Release(LFCM)
									}
								}
								Return(Zero)
							}
							Method (MHCF, 1, NotSerialized)
							{
								Store(0x78, P80H)
								Store(Arg0, Local0)
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										And(Local0, 0x20, Local0)
										ShiftRight(Local0, 0x05, Local0)
										Store(Local0, RMBT)
										Sleep(0x14)
										Release(LFCM)
									}
								}
								Return(Local0)
							}
							Method (MHPF, 1, NotSerialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										Name(BFWB, Buffer(0x25){})
										CreateByteField(BFWB,Zero,FB0)
										CreateByteField(BFWB,One,FB1)
										CreateByteField(BFWB,0x02,FB2)
										CreateByteField(BFWB,0x03,FB3)
										CreateField(BFWB,0x20,0x0100,FB4)
										CreateByteField(BFWB,0x24,FB5)
										If(LLessEqual(SizeOf(Arg0), 0x25))
										{
											If(LNotEqual(SMPR, Zero))
											{
												Store(SMST, FB1)
											}
											Else
											{
												Store(Arg0, BFWB)
												Store(FB2, SMAD)
												Store(FB3, SMCM)
												Store(FB5, BCNT)
												Store(FB0, Local0)
												If(LEqual(And(Local0, One), Zero))
												{
													Store(FB4, SMDA)
												}
												Store(0x00, SMST)
												Store(FB0, SMPR)
												Store(0x03E8, Local1)
												While(Local1)
												{
													Sleep(One)
													Decrement(Local1)
													If(LOr(LAnd(SMST, 0x80), LEqual(SMPR, 0x00)))
													{
														Break
													}
												}
												Store(FB0, Local0)
												If(LNotEqual(And(Local0, One), Zero))
												{
													Store(SMDA, FB4)
												}
												Store(SMST, FB1)
												If(LOr(LEqual(Local1, 0x00), LNot(LAnd(SMST, 0x80))))
												{
													Store(0x00, SMPR)
													Store(0x92, FB1)
												}
											}
											Release(LFCM)
											Return(BFWB)
										}
										Release(LFCM)
									}
								}
							}
							Method (MHIF, 1, NotSerialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										Store(0x50, P80H)
										If(LEqual(Arg0, 0x00))
										{
											Name(RETB, Buffer(0x0A){})
											Name(BUF1, Buffer(0x08){})
											Store(FWBT, BUF1)
											CreateByteField(BUF1,0x00,FW0)
											CreateByteField(BUF1,0x01,FW1)
											CreateByteField(BUF1,0x02,FW2)
											CreateByteField(BUF1,0x03,FW3)
											CreateByteField(BUF1,0x04,FW4)
											CreateByteField(BUF1,0x05,FW5)
											CreateByteField(BUF1,0x06,FW6)
											CreateByteField(BUF1,0x07,FW7)
											Store(FUSL, Index(RETB, Zero))
											Store(FUSH, Index(RETB, One))
											Store(FW0, Index(RETB, 0x02))
											Store(FW1, Index(RETB, 0x03))
											Store(FW2, Index(RETB, 0x04))
											Store(FW3, Index(RETB, 0x05))
											Store(FW4, Index(RETB, 0x06))
											Store(FW5, Index(RETB, 0x07))
											Store(FW6, Index(RETB, 0x08))
											Store(FW7, Index(RETB, 0x09))
											Release(LFCM)
											Return(RETB)
										}
										Release(LFCM)
									}
								}
							}
							Method (GSBI, 1, NotSerialized)
							{
								Name(BIFB, Buffer(0x53)
								{
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
									0xFF, 0xFF, 0xFF
								})
								CreateWordField(BIFB, 0x00, DCAP)
								CreateWordField(BIFB, 0x02, FCAP)
								CreateWordField(BIFB, 0x04, RCAP)
								CreateWordField(BIFB, 0x06, ATTE)
								CreateWordField(BIFB, 0x08, ATTF)
								CreateWordField(BIFB, 0x0A, BTVT)
								CreateWordField(BIFB, 0x0C, BTCT)
								CreateWordField(BIFB, 0x0E, BTMP)
								CreateWordField(BIFB, 0x10, MDAT)
								CreateWordField(BIFB, 0x12, FUDT)
								CreateWordField(BIFB, 0x14, DVLT)
								CreateField(BIFB,0xB0,0x50,DCHE)
								CreateField(BIFB,0x0100,0x40,DNAM)
								CreateField(BIFB,0x0140,0x60,MNAM)
								CreateField(BIFB,0x01A0,0xB8,BRNB)
								CreateQWordField(BIFB, 0x4B, BFW0)
								If(LOr(LEqual(Arg0, 0x00), LEqual(Arg0, 0x01)))
								{
									If(ECAV)
									{
										If(LEqual(Acquire(LFCM, 0xA000), 0x00))
										{
											Store(B1DC, Local0)
											Multiply(Local0, 0x0A, Local0)
											Store(Local0, DCAP)
											Store(B1FC, Local0)
											Multiply(Local0, 0x0A, Local0)
											Store(Local0, FCAP)
											Store(B1RC, Local0)
											Multiply(Local0, 0x0A, Local0)
											Store(Local0, RCAP)
											Store(SMTE(0x00), ATTE)
											Store(SMTF(0x00), ATTF)
											Store(B1FV, BTVT)
											Store(B1AC, BTCT)
											Store(B1AT, Local0)
											Add(Local0, 0x0111, Local0)
											Multiply(Local0, 0x0A, Local0)
											Store(Local0, BTMP)
											Store(B1DA, MDAT)
											If(LNotEqual(BFUD, 0x00))
											{
												Store(BFUD, FUDT)
											}
											Store(B1DV, DVLT)
											Name(DCH0, Buffer(0x0A)
											{
												0x00
											})
											Name(DCH1, "LION")
											Name(DCH2, "LiP")
											If(LEqual(B1TY, 0x01))
											{
												Store(DCH1, DCH0)
												Store(DCH0, DCHE)
											}
											Else
											{
												Store(DCH2, DCH0)
												Store(DCH0, DCHE)
											}
											Name(BDNT, Buffer(0x08)
											{
												0x00
											})
											Store(BDN0, BDNT)
											Store(BDNT, DNAM)
											Name(BMNT, Buffer(0x0C)
											{
												0x00
											})
											Store(BMN0, BMNT)
											Store(BMNT, MNAM)
											Name(BRN0, Buffer(0x17)
											{
												0x00
											})
											Store(BAR1, BRN0)
											Store(BRN0, BRNB)
											Store(FWBT, BFW0)
											Release(LFCM)
										}
									}
									Return(BIFB)
								}
								If(LEqual(Arg0, 0x02))
								{
									Return(BIFB)
								}
								Return(Zero)
							}
							Method (HODD, 0, NotSerialized)
							{
							}
							Method (SODD, 1, Serialized)
							{
							}
							Method (GBID, 0, Serialized)
							{
								Name(GBUF, Package(4)
								{
									Buffer(0x02)
									{
										0x00, 0x00
									}, 
									Buffer(0x02)
									{
										0x00, 0x00
									}, 
									Buffer(0x08)
									{
										0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
									}, 
									Buffer(0x08)
									{
										0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
									}
								})
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										Store(B1CT, Index(DerefOf(Index(GBUF, Zero)), Zero))
										Store(0x00, Index(DerefOf(Index(GBUF, 0x01)), Zero))
										Name(BUF1, Buffer(0x08){})
										Store(FWBT, BUF1)
										CreateByteField(BUF1,0x00,FW0)
										CreateByteField(BUF1,0x01,FW1)
										CreateByteField(BUF1,0x02,FW2)
										CreateByteField(BUF1,0x03,FW3)
										CreateByteField(BUF1,0x04,FW4)
										CreateByteField(BUF1,0x05,FW5)
										CreateByteField(BUF1,0x06,FW6)
										CreateByteField(BUF1,0x07,FW7)
										Store(FW0, Index(DerefOf(Index(GBUF, 0x02)), Zero))
										Store(FW1, Index(DerefOf(Index(GBUF, 0x02)), 0x01))
										Store(FW2, Index(DerefOf(Index(GBUF, 0x02)), 0x02))
										Store(FW3, Index(DerefOf(Index(GBUF, 0x02)), 0x03))
										Store(FW4, Index(DerefOf(Index(GBUF, 0x02)), 0x04))
										Store(FW5, Index(DerefOf(Index(GBUF, 0x02)), 0x05))
										Store(FW6, Index(DerefOf(Index(GBUF, 0x02)), 0x06))
										Store(FW7, Index(DerefOf(Index(GBUF, 0x02)), 0x07))
										Store(0x00, Index(DerefOf(Index(GBUF, 0x03)), Zero))
										Release(LFCM)
									}
								}
								Return(GBUF)
							}
							Name(APDT, 0x00)
							Method (APPC, 1, Serialized)
							{
								Store(Arg0, APDT)
								Return(0x00)
							}
							Method (DBSL, 0, NotSerialized)
							{
								Return(Package(16)
								{
									0xC9, 0xAE, 0x95, 0x7E, 0x69, 0x56, 0x45, 0x36, 0x29, 0x1E, 0x15,
									0x0E, 0x09, 0x06, 0x05, 0x00
								})
							}
							Method (SBSL, 1, Serialized)
							{
								If(ECAV)
								{
									If(LEqual(Acquire(LFCM, 0xA000), 0x00))
									{
										Store(Arg0, Local0)
										If(LEqual(Local0, One))
										{
											Store(0x0E, LCBV)
										}
										If(LEqual(Local0, 0x02))
										{
											Store(0x07, LCBV)
										}
										Release(LFCM)
									}
								}
								Return(0x00)
							}
							Method (STHT, 1, Serialized)
							{
								Return(0x00)
							}
							Name(NITS, 0x3E)
							Name(SPL1, 0x2EE0)
							Name(SPL2, 0x61A8)
							Name(SPL3, 0x2EE0)
							Name(SPL7, 0x55F0)
							Name(SPL8, 0x3A98)
							Name(SPL9, 0x4E20)
							Name(SPP1, 0x2EE0)
							Name(SPP2, 0x927C)
							Name(SPP3, 0x3A98)
							Name(SPP7, 0x55F0)
							Name(SPP8, 0x3A98)
							Name(SPP9, 0x4E20)
							Name(FPP1, 0x2EE0)
							Name(FPP2, 0xA410)
							Name(FPP3, 0x4E20)
							Name(FPP7, 0x9C40)
							Name(FPP8, 0x4E20)
							Name(FPP9, 0x7530)
							Name(TDC1, 0x88B8)
							Name(TDC2, 0xABE0)
							Name(TDC3, 0x88B8)
							Name(TDC7, 0xABE0)
							Name(TDC8, 0x88B8)
							Name(TDC9, 0x88B8)
							Name(EDC1, 0xAFC8)
							Name(EDC2, 0x00011170)
							Name(EDC3, 0xAFC8)
							Name(EDC7, 0x00011170)
							Name(EDC8, 0xAFC8)
							Name(EDC9, 0xAFC8)
							Name(SPT1, 0x05)
							Name(SPT2, 0x0F)
							Name(SPT3, 0x05)
							Name(SPT7, 0x05)
							Name(SPT8, 0x05)
							Name(SPT9, 0x05)
							Name(STC1, 0xC8)
							Name(STC2, 0x01F4)
							Name(STC3, 0xC8)
							Name(STC7, 0xC8)
							Name(STC8, 0xC8)
							Name(STC9, 0xC8)
							Name(TCL2, 0x62)
							Name(TCL3, 0x5F)
							Name(TCL7, 0x5F)
							Name(TCL8, 0x5F)
							Name(TCL9, 0x5F)
							Name(SPL4, 0x3A98)
							Name(SPP4, 0x3A98)
							Name(FPP4, 0x4E20)
							Name(SPL5, 0x4E20)
							Name(SPP5, 0x7530)
							Name(FPP5, 0x9C40)
							Name(SPL6, 0x3A98)
							Name(SPP6, 0x4650)
							Name(FPP6, 0x4E20)
							Method (DYTC, 1, Serialized)
							{
								Name(_T_2, Zero)
								Name(_T_1, Zero)
								Name(_T_0, Zero)
								Store(Arg0, Local0)
								Store(Local0, DYTP)
								Store(0x00, Local1)
								Name(XX11, Buffer(0x07){})
								CreateWordField(XX11, 0x00, SSZE)
								CreateByteField(XX11,0x02,SMUF)
								CreateDWordField(XX11, 0x03, SMUD)
								Store(0x07, SSZE)
								While(One)
								{
									Store(ToInteger(And(Local0, 0x01FF)), _T_0)
									If(LEqual(_T_0, 0x00))
									{
										Store(0x0100, Local1)
										Or(Local1, 0x40000000, Local1)
										Or(Local1, 0x00, Local1)
										Or(Local1, 0x01, Local1)
									}
									Else
									{
										If(LEqual(_T_0, 0x01))
										{
											And(ShiftRight(Local0, 0x0C), 0x0F, Local2)
											And(ShiftRight(Local0, 0x10), 0x0F, Local3)
											And(ShiftRight(Local0, 0x14), 0x01, Local4)
											While(One)
											{
												Store(Local2, _T_1)
												If(LEqual(_T_1, 0x04))
												{
													If(LNotEqual(Local3, 0x0F))
													{
														Store(0x0A, Local1)
														Return(Local1)
													}
													If(LEqual(Local4, 0x00))
													{
														Store(0x00, VSTP)
													}
													Else
													{
														Store(0x01, VSTP)
													}
												}
												Else
												{
													If(LEqual(_T_1, 0x05))
													{
														If(LNotEqual(Local3, 0x0F))
														{
															Store(0x0A, Local1)
															Return(Local1)
														}
														If(LEqual(Local4, 0x00))
														{
															Store(0x00, VAPM)
														}
														Else
														{
															Store(0x01, VAPM)
														}
													}
													Else
													{
														If(LEqual(_T_1, 0x06))
														{
															If(LNotEqual(Local3, 0x0F))
															{
																Store(0x0A, Local1)
																Return(Local1)
															}
															If(LEqual(Local4, 0x00))
															{
																Store(0x00, VAQM)
															}
															Else
															{
																Store(0x01, VAQM)
															}
														}
														Else
														{
															If(LEqual(_T_1, 0x0B))
															{
																While(One)
																{
																	Store(Local3, _T_2)
																	If(LEqual(_T_2, 0x02))
																	{
																		If(LNotEqual(Local4, 0x01))
																		{
																			Store(0x0A, Local1)
																			Return(Local1)
																		}
																	}
																	Else
																	{
																		If(LEqual(_T_2, 0x03))
																		{
																			If(LNotEqual(Local4, 0x01))
																			{
																				Store(0x0A, Local1)
																				Return(Local1)
																			}
																		}
																		Else
																		{
																			If(LEqual(_T_2, 0x0F))
																			{
																				If(LNotEqual(Local4, 0x00))
																				{
																					Store(0x0A, Local1)
																					Return(Local1)
																				}
																			}
																			Else
																			{
																				Store(0x0A, Local1)
																				Return(Local1)
																			}
																		}
																	}
																	Break
																}
																If(LEqual(Local4, 0x00))
																{
																	If(LEqual(Local3, 0x0F))
																	{
																		Store(0x00, VMMC)
																		Store(0x0F, SMMC)
																	}
																	Else
																	{
																		Store(0x00, VMMC)
																		Store(0x00, SMMC)
																	}
																}
																Else
																{
																	Store(0x01, VMMC)
																	Store(Local3, SMMC)
																}
															}
															Else
															{
																If(LEqual(_T_1, 0x00))
																{
																	If(LNotEqual(Local3, 0x0F))
																	{
																		Store(0x0A, Local1)
																		Return(Local1)
																	}
																}
																Else
																{
																	Store(0x02, Local1)
																	Return(Local1)
																}
															}
														}
													}
												}
												Break
											}
											If(LEqual(VSTP, 0x01))
											{
												Store(0x04, CICF)
												Store(0x05, FCMO)
												Store(0x05, SMUF)
												Store(SPL1, SMUD)
												ALIB(0x0C, XX11)
												Store(0x07, SMUF)
												Store(SPP1, SMUD)
												ALIB(0x0C, XX11)
												Store(0x06, SMUF)
												Store(FPP1, SMUD)
												ALIB(0x0C, XX11)
												Store(0x0B, SMUF)
												Store(TDC1, SMUD)
												ALIB(0x0C, XX11)
												Store(0x0C, SMUF)
												Store(EDC1, SMUD)
												ALIB(0x0C, XX11)
												Store(0x08, SMUF)
												Store(SPT1, SMUD)
												ALIB(0x0C, XX11)
												Store(0x01, SMUF)
												Store(STC1, SMUD)
												ALIB(0x0C, XX11)
												Store(0x2E, SMUF)
												Store(0x2EE0, SMUD)
												ALIB(0x0C, XX11)
											}
											Else
											{
												If(LAnd(LEqual(VMMC, 0x01), LEqual(SMMC, 0x02)))
												{
													Store(0x0B, CICF)
													Store(0x01, SPMO)
													Store(0x01, FCMO)
													Store(0x05, SMUF)
													If(LEqual(PSYS, 0x01))
													{
														Store(SPL5, SMUD)
													}
													Else
													{
														If(LEqual(LBPR, 0x01))
														{
															Store(SPL6, SMUD)
														}
														Else
														{
															If(LEqual(OVLD, 0x01))
															{
																Store(SPL4, SMUD)
															}
															Else
															{
																Store(SPL2, SMUD)
															}
														}
													}
													ALIB(0x0C, XX11)
													Store(0x07, SMUF)
													If(LEqual(PSYS, 0x01))
													{
														Store(SPP5, SMUD)
													}
													Else
													{
														If(LEqual(LBPR, 0x01))
														{
															Store(SPP6, SMUD)
														}
														Else
														{
															If(LEqual(OVLD, 0x01))
															{
																Store(SPP4, SMUD)
															}
															Else
															{
																Store(SPP2, SMUD)
															}
														}
													}
													ALIB(0x0C, XX11)
													Store(0x06, SMUF)
													If(LEqual(PSYS, 0x01))
													{
														Store(FPP5, SMUD)
													}
													Else
													{
														If(LEqual(LBPR, 0x01))
														{
															Store(FPP6, SMUD)
														}
														Else
														{
															If(LEqual(OVLD, 0x01))
															{
																Store(FPP4, SMUD)
															}
															Else
															{
																Store(FPP2, SMUD)
															}
														}
													}
													ALIB(0x0C, XX11)
													Store(0x0B, SMUF)
													Store(TDC2, SMUD)
													ALIB(0x0C, XX11)
													Store(0x0C, SMUF)
													Store(EDC2, SMUD)
													ALIB(0x0C, XX11)
													Store(0x08, SMUF)
													Store(SPT2, SMUD)
													ALIB(0x0C, XX11)
													Store(0x01, SMUF)
													Store(STC2, SMUD)
													ALIB(0x0C, XX11)
													Store(0x03, SMUF)
													Store(TCL2, SMUD)
													ALIB(0x0C, XX11)
													Store(0x20, SMUF)
													Store(0x199A, SMUD)
													ALIB(0x0C, XX11)
													Store(0x22, SMUF)
													Store(0x3000, SMUD)
													ALIB(0x0C, XX11)
													Store(0x24, SMUF)
													Store(0x0148, SMUD)
													ALIB(0x0C, XX11)
													Store(0x25, SMUF)
													Store(0x2666, SMUD)
													ALIB(0x0C, XX11)
													Store(0x26, SMUF)
													Store(0x01EF, SMUD)
													ALIB(0x0C, XX11)
													Store(0x27, SMUF)
													Store(0x0430, SMUD)
													ALIB(0x0C, XX11)
													Store(0x2C, SMUF)
													Store(0xB06D, SMUD)
													ALIB(0x0C, XX11)
													Store(0x2E, SMUF)
													Store(0x61A8, SMUD)
													ALIB(0x0C, XX11)
												}
												Else
												{
													If(LAnd(LEqual(VMMC, 0x01), LEqual(SMMC, 0x03)))
													{
														Store(0x0B, CICF)
														Store(0x02, SPMO)
														Store(0x02, FCMO)
														Store(0x05, SMUF)
														Store(SPL3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x07, SMUF)
														Store(SPP3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x06, SMUF)
														Store(FPP3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x0B, SMUF)
														Store(TDC3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x0C, SMUF)
														Store(EDC3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x08, SMUF)
														Store(SPT3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x01, SMUF)
														Store(STC3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x03, SMUF)
														Store(TCL3, SMUD)
														ALIB(0x0C, XX11)
														Store(0x20, SMUF)
														Store(0x199A, SMUD)
														ALIB(0x0C, XX11)
														Store(0x22, SMUF)
														Store(0x2C00, SMUD)
														ALIB(0x0C, XX11)
														Store(0x24, SMUF)
														Store(0x0148, SMUD)
														ALIB(0x0C, XX11)
														Store(0x25, SMUF)
														Store(0x2666, SMUD)
														ALIB(0x0C, XX11)
														Store(0x26, SMUF)
														Store(0x011C, SMUD)
														ALIB(0x0C, XX11)
														Store(0x27, SMUF)
														Store(0x040B, SMUD)
														ALIB(0x0C, XX11)
														Store(0x2C, SMUF)
														Store(0xC936, SMUD)
														ALIB(0x0C, XX11)
														Store(0x2E, SMUF)
														Store(0x2EE0, SMUD)
														ALIB(0x0C, XX11)
													}
													Else
													{
														If(LEqual(VAPM, 0x01))
														{
															Store(0x05, CICF)
															Store(0x03, FCMO)
															Store(0x05, SMUF)
															If(LEqual(PSYS, 0x01))
															{
																Store(SPL5, SMUD)
															}
															Else
															{
																If(LEqual(LBPR, 0x01))
																{
																	Store(SPL6, SMUD)
																}
																Else
																{
																	If(LEqual(OVLD, 0x01))
																	{
																		Store(SPL4, SMUD)
																	}
																	Else
																	{
																		Store(SPL7, SMUD)
																	}
																}
															}
															ALIB(0x0C, XX11)
															Store(0x07, SMUF)
															If(LEqual(PSYS, 0x01))
															{
																Store(SPP5, SMUD)
															}
															Else
															{
																If(LEqual(LBPR, 0x01))
																{
																	Store(SPP6, SMUD)
																}
																Else
																{
																	If(LEqual(OVLD, 0x01))
																	{
																		Store(SPP4, SMUD)
																	}
																	Else
																	{
																		Store(SPP7, SMUD)
																	}
																}
															}
															ALIB(0x0C, XX11)
															Store(0x06, SMUF)
															If(LEqual(PSYS, 0x01))
															{
																Store(FPP5, SMUD)
															}
															Else
															{
																If(LEqual(LBPR, 0x01))
																{
																	Store(FPP6, SMUD)
																}
																Else
																{
																	If(LEqual(OVLD, 0x01))
																	{
																		Store(FPP4, SMUD)
																	}
																	Else
																	{
																		Store(FPP7, SMUD)
																	}
																}
															}
															ALIB(0x0C, XX11)
															Store(0x0B, SMUF)
															Store(TDC7, SMUD)
															ALIB(0x0C, XX11)
															Store(0x0C, SMUF)
															Store(EDC7, SMUD)
															ALIB(0x0C, XX11)
															Store(0x08, SMUF)
															Store(SPT7, SMUD)
															ALIB(0x0C, XX11)
															Store(0x01, SMUF)
															Store(STC7, SMUD)
															ALIB(0x0C, XX11)
															Store(0x03, SMUF)
															Store(TCL7, SMUD)
															ALIB(0x0C, XX11)
															Store(0x20, SMUF)
															Store(0x199A, SMUD)
															ALIB(0x0C, XX11)
															Store(0x22, SMUF)
															Store(0x2F00, SMUD)
															ALIB(0x0C, XX11)
															Store(0x24, SMUF)
															Store(0xC5, SMUD)
															ALIB(0x0C, XX11)
															Store(0x25, SMUF)
															Store(0x2666, SMUD)
															ALIB(0x0C, XX11)
															Store(0x26, SMUF)
															Store(0x023E, SMUD)
															ALIB(0x0C, XX11)
															Store(0x27, SMUF)
															Store(0x0239, SMUD)
															ALIB(0x0C, XX11)
															Store(0x2C, SMUF)
															Store(0xEED2, SMUD)
															ALIB(0x0C, XX11)
															Store(0x2E, SMUF)
															Store(0x4E20, SMUD)
															ALIB(0x0C, XX11)
														}
														Else
														{
															If(LEqual(VAQM, 0x01))
															{
																Store(0x06, CICF)
																Store(0x04, FCMO)
																Store(0x05, SMUF)
																Store(SPL8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x07, SMUF)
																Store(SPP8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x06, SMUF)
																Store(FPP8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x0B, SMUF)
																Store(TDC8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x0C, SMUF)
																Store(EDC8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x08, SMUF)
																Store(SPT8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x01, SMUF)
																Store(STC8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x03, SMUF)
																Store(TCL8, SMUD)
																ALIB(0x0C, XX11)
																Store(0x20, SMUF)
																Store(0x199A, SMUD)
																ALIB(0x0C, XX11)
																Store(0x22, SMUF)
																Store(0x2D00, SMUD)
																ALIB(0x0C, XX11)
																Store(0x24, SMUF)
																Store(0x0148, SMUD)
																ALIB(0x0C, XX11)
																Store(0x25, SMUF)
																Store(0x2666, SMUD)
																ALIB(0x0C, XX11)
																Store(0x26, SMUF)
																Store(0x011C, SMUD)
																ALIB(0x0C, XX11)
																Store(0x27, SMUF)
																Store(0x040B, SMUD)
																ALIB(0x0C, XX11)
																Store(0x2C, SMUF)
																Store(0xC936, SMUD)
																ALIB(0x0C, XX11)
																Store(0x2E, SMUF)
																Store(0x2EE0, SMUD)
																ALIB(0x0C, XX11)
															}
															Else
															{
																If(LAnd(LEqual(VMMC, 0x00), LEqual(SMMC, 0x0F)))
																{
																	Store(0x0B, CICF)
																	Store(0x00, SPMO)
																	Store(0x00, FCMO)
																	Store(0x05, SMUF)
																	If(LEqual(LBPR, 0x01))
																	{
																		Store(SPL6, SMUD)
																	}
																	Else
																	{
																		If(LEqual(OVLD, 0x01))
																		{
																			Store(SPL4, SMUD)
																		}
																		Else
																		{
																			Store(SPL9, SMUD)
																		}
																	}
																	ALIB(0x0C, XX11)
																	Store(0x07, SMUF)
																	If(LEqual(LBPR, 0x01))
																	{
																		Store(SPP6, SMUD)
																	}
																	Else
																	{
																		If(LEqual(OVLD, 0x01))
																		{
																			Store(SPP4, SMUD)
																		}
																		Else
																		{
																			Store(SPP9, SMUD)
																		}
																	}
																	ALIB(0x0C, XX11)
																	Store(0x06, SMUF)
																	If(LEqual(LBPR, 0x01))
																	{
																		Store(FPP6, SMUD)
																	}
																	Else
																	{
																		If(LEqual(OVLD, 0x01))
																		{
																			Store(FPP4, SMUD)
																		}
																		Else
																		{
																			Store(FPP9, SMUD)
																		}
																	}
																	ALIB(0x0C, XX11)
																	Store(0x0B, SMUF)
																	Store(TDC9, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x0C, SMUF)
																	Store(EDC9, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x08, SMUF)
																	Store(SPT9, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x01, SMUF)
																	Store(STC9, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x03, SMUF)
																	Store(TCL9, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x20, SMUF)
																	Store(0x199A, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x22, SMUF)
																	Store(0x2E00, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x24, SMUF)
																	Store(0x0148, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x25, SMUF)
																	Store(0x2666, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x26, SMUF)
																	Store(0x0145, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x27, SMUF)
																	Store(0x043D, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x2C, SMUF)
																	Store(0xC003, SMUD)
																	ALIB(0x0C, XX11)
																	Store(0x2E, SMUF)
																	Store(0x4650, SMUD)
																	ALIB(0x0C, XX11)
																}
																Else
																{
																	Store(0x00, CICF)
																}
															}
														}
													}
												}
											}
											Store(VSTD, Local5)
											Or(ShiftLeft(VFBC, 0x02), Local5, Local5)
											Or(ShiftLeft(VMYH, 0x03), Local5, Local5)
											Or(ShiftLeft(VSTP, 0x04), Local5, Local5)
											Or(ShiftLeft(VAPM, 0x05), Local5, Local5)
											Or(ShiftLeft(VAQM, 0x06), Local5, Local5)
											Or(ShiftLeft(VAAA, 0x0A), Local5, Local5)
											Or(ShiftLeft(VMMC, 0x0B), Local5, Local5)
											Store(ShiftLeft(CICF, 0x08), Local1)
											If(LEqual(CICF, 0x03))
											{
												Store(SMYH, CICM)
											}
											Else
											{
												If(LEqual(CICF, 0x0B))
												{
													Store(SMMC, CICM)
												}
												Else
												{
													Store(0x0F, CICM)
												}
											}
											Or(ShiftLeft(CICM, 0x0C), Local1, Local1)
											Or(ShiftLeft(Local5, 0x10), Local1, Local1)
											Or(Local1, 0x01, Local1)
										}
										Else
										{
											If(LEqual(_T_0, 0x02))
											{
												Store(VSTD, Local5)
												Or(ShiftLeft(VFBC, 0x02), Local5, Local5)
												Or(ShiftLeft(VMYH, 0x03), Local5, Local5)
												Or(ShiftLeft(VSTP, 0x04), Local5, Local5)
												Or(ShiftLeft(VAPM, 0x05), Local5, Local5)
												Or(ShiftLeft(VAQM, 0x06), Local5, Local5)
												Or(ShiftLeft(VAAA, 0x0A), Local5, Local5)
												Or(ShiftLeft(VMMC, 0x0B), Local5, Local5)
												Store(ShiftLeft(CICF, 0x08), Local1)
												If(LEqual(CICF, 0x03))
												{
													Store(SMYH, CICM)
												}
												Else
												{
													If(LEqual(CICF, 0x0B))
													{
														Store(SMMC, CICM)
													}
													Else
													{
														Store(0x0F, CICM)
													}
												}
												Or(ShiftLeft(CICM, 0x0C), Local1, Local1)
												Or(ShiftLeft(Local5, 0x10), Local1, Local1)
												Or(Local1, 0x01, Local1)
											}
											Else
											{
												If(LEqual(_T_0, 0x03))
												{
													Store(ShiftLeft(FCAP, 0x10), Local1)
													Or(Local1, 0x01, Local1)
												}
												Else
												{
													If(LEqual(_T_0, 0x04))
													{
														Store(ShiftLeft(MYHC, 0x10), Local1)
														Or(Local1, 0x01, Local1)
													}
													Else
													{
														If(LEqual(_T_0, 0x06))
														{
															And(ShiftRight(Local0, 0x09), 0x0F, Local2)
															If(LNotEqual(Local2, 0x01))
															{
																Store(ShiftLeft(MMCC, 0x10), Local1)
															}
															Else
															{
																Store(0x0200, Local1)
															}
															Or(Local1, 0x01, Local1)
														}
														Else
														{
															If(LEqual(_T_0, 0x07))
															{
																Store(ShiftLeft(SMMC, 0x10), Local1)
																Or(Local1, 0x01, Local1)
															}
															Else
															{
																If(LEqual(_T_0, 0x0100))
																{
																	Store(0x10010000, Local1)
																	Or(Local1, 0x01, Local1)
																}
																Else
																{
																	If(LEqual(_T_0, 0x09))
																	{
																		If(LOr(LOr(LEqual(PAID, 0x238D), LEqual(PAID, 0x08D5)), LEqual(PAID, 0x15F5)))
																		{
																			Store(0x42, NITS)
																		}
																		Else
																		{
																			Store(0x3E, NITS)
																		}
																		Store(ShiftLeft(NITS, 0x10), Local1)
																		Or(Local1, 0x01, Local1)
																	}
																	Else
																	{
																		If(LEqual(_T_0, 0x01FF))
																		{
																			Store(0x00, SPMO)
																			Store(0x00, FCMO)
																			Store(0x05, SMUF)
																			If(LEqual(LBPR, 0x01))
																			{
																				Store(SPL6, SMUD)
																			}
																			Else
																			{
																				If(LEqual(OVLD, 0x01))
																				{
																					Store(SPL4, SMUD)
																				}
																				Else
																				{
																					Store(SPL9, SMUD)
																				}
																			}
																			ALIB(0x0C, XX11)
																			Store(0x07, SMUF)
																			If(LEqual(LBPR, 0x01))
																			{
																				Store(SPP6, SMUD)
																			}
																			Else
																			{
																				If(LEqual(OVLD, 0x01))
																				{
																					Store(SPP4, SMUD)
																				}
																				Else
																				{
																					Store(SPP9, SMUD)
																				}
																			}
																			ALIB(0x0C, XX11)
																			Store(0x06, SMUF)
																			If(LEqual(LBPR, 0x01))
																			{
																				Store(FPP6, SMUD)
																			}
																			Else
																			{
																				If(LEqual(OVLD, 0x01))
																				{
																					Store(FPP4, SMUD)
																				}
																				Else
																				{
																					Store(FPP9, SMUD)
																				}
																			}
																			ALIB(0x0C, XX11)
																			Store(0x0B, SMUF)
																			Store(TDC9, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x0C, SMUF)
																			Store(EDC9, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x08, SMUF)
																			Store(SPT9, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x01, SMUF)
																			Store(STC9, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x03, SMUF)
																			Store(TCL9, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x20, SMUF)
																			Store(0x199A, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x22, SMUF)
																			Store(0x2E00, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x24, SMUF)
																			Store(0x0148, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x25, SMUF)
																			Store(0x2666, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x26, SMUF)
																			Store(0x0145, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x27, SMUF)
																			Store(0x043D, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x2C, SMUF)
																			Store(0xC003, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x2E, SMUF)
																			Store(0x4650, SMUD)
																			ALIB(0x0C, XX11)
																			Store(0x00, VFBC)
																			Store(0x00, VMYH)
																			Store(0x00, VSTP)
																			Store(0x00, VAPM)
																			Store(0x00, VAQM)
																			Store(0x00, VAAA)
																			Store(0x00, VMMC)
																			Store(0x00, SMYH)
																			Store(0x00, SMMC)
																			Store(0x00, CICF)
																			Store(0x0F, CICM)
																			Store(VSTD, Local5)
																			Or(ShiftLeft(VFBC, 0x02), Local5, Local5)
																			Or(ShiftLeft(VMYH, 0x03), Local5, Local5)
																			Or(ShiftLeft(VSTP, 0x04), Local5, Local5)
																			Or(ShiftLeft(VAPM, 0x05), Local5, Local5)
																			Or(ShiftLeft(VAQM, 0x06), Local5, Local5)
																			Or(ShiftLeft(VAAA, 0x0A), Local5, Local5)
																			Or(ShiftLeft(VMMC, 0x0B), Local5, Local5)
																			Store(ShiftLeft(CICF, 0x08), Local1)
																			Or(ShiftLeft(CICM, 0x0C), Local1, Local1)
																			Or(ShiftLeft(Local5, 0x10), Local1, Local1)
																			Or(Local1, 0x01, Local1)
																		}
																		Else
																		{
																			Store(0x04, Local1)
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
									Break
								}
								Return(Local1)
							}
							Scope (^^EC0)
							{
								Device (ITSD)
								{
									Name(_HID, "IDEA2004")
									Method (_STA, 0, NotSerialized)
									{
										Return(0x0F)
									}
								}
							}
						}
					}
					Method (_REG, 2, NotSerialized)
					{
						If(LEqual(Arg0, 0x03))
						{
							Store(Arg1, ECAV)
						}
						If(LAnd(LEqual(Arg0, 0x03), LEqual(Arg1, 0x01)))
						{
							If(LEqual(TPOS, 0x40))
							{
								Store(0x01, Local0)
							}
							If(LEqual(TPOS, 0x80))
							{
								Store(0x02, Local0)
							}
							If(LEqual(TPOS, 0x50))
							{
								Store(0x03, Local0)
							}
							If(LEqual(TPOS, 0x60))
							{
								Store(0x04, Local0)
							}
							If(LEqual(TPOS, 0x61))
							{
								Store(0x05, Local0)
							}
							If(LEqual(TPOS, 0x70))
							{
								Store(0x06, Local0)
							}
							If(LEqual(Acquire(LFCM, 0xA000), 0x00))
							{
								Store(Local0, OSTY)
								Release(LFCM)
							}
						}
						If(LEqual(SPMO, 0x01))
						{
							Store(0x05, SMUF)
							If(LEqual(PSYS, 0x01))
							{
								Store(SPL5, SMUD)
							}
							Else
							{
								If(LEqual(LBPR, 0x01))
								{
									Store(SPL6, SMUD)
								}
								Else
								{
									If(LEqual(OVLD, 0x01))
									{
										Store(SPL4, SMUD)
									}
									Else
									{
										Store(SPL2, SMUD)
									}
								}
							}
							ALIB(0x0C, XX11)
							Store(0x07, SMUF)
							If(LEqual(PSYS, 0x01))
							{
								Store(SPP5, SMUD)
							}
							Else
							{
								If(LEqual(LBPR, 0x01))
								{
									Store(SPP6, SMUD)
								}
								Else
								{
									If(LEqual(OVLD, 0x01))
									{
										Store(SPP4, SMUD)
									}
									Else
									{
										Store(SPP2, SMUD)
									}
								}
							}
							ALIB(0x0C, XX11)
							Store(0x06, SMUF)
							If(LEqual(PSYS, 0x01))
							{
								Store(FPP5, SMUD)
							}
							Else
							{
								If(LEqual(LBPR, 0x01))
								{
									Store(FPP6, SMUD)
								}
								Else
								{
									If(LEqual(OVLD, 0x01))
									{
										Store(FPP4, SMUD)
									}
									Else
									{
										Store(FPP2, SMUD)
									}
								}
							}
							ALIB(0x0C, XX11)
							Store(0x0B, SMUF)
							Store(TDC2, SMUD)
							ALIB(0x0C, XX11)
							Store(0x0C, SMUF)
							Store(EDC2, SMUD)
							ALIB(0x0C, XX11)
							Store(0x08, SMUF)
							Store(SPT2, SMUD)
							ALIB(0x0C, XX11)
							Store(0x01, SMUF)
							Store(STC2, SMUD)
							ALIB(0x0C, XX11)
							Store(0x03, SMUF)
							Store(TCL2, SMUD)
							ALIB(0x0C, XX11)
							Store(0x20, SMUF)
							Store(0x199A, SMUD)
							ALIB(0x0C, XX11)
							Store(0x22, SMUF)
							Store(0x3000, SMUD)
							ALIB(0x0C, XX11)
							Store(0x24, SMUF)
							Store(0x0148, SMUD)
							ALIB(0x0C, XX11)
							Store(0x25, SMUF)
							Store(0x2666, SMUD)
							ALIB(0x0C, XX11)
							Store(0x26, SMUF)
							Store(0x01EF, SMUD)
							ALIB(0x0C, XX11)
							Store(0x27, SMUF)
							Store(0x0430, SMUD)
							ALIB(0x0C, XX11)
							Store(0x2C, SMUF)
							Store(0xB06D, SMUD)
							ALIB(0x0C, XX11)
							Store(0x2E, SMUF)
							Store(0x61A8, SMUD)
							ALIB(0x0C, XX11)
						}
						Else
						{
							If(LEqual(SPMO, 0x02))
							{
								Store(0x05, SMUF)
								Store(SPL3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x07, SMUF)
								Store(SPP3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x06, SMUF)
								Store(FPP3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x0B, SMUF)
								Store(TDC3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x0C, SMUF)
								Store(EDC3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x08, SMUF)
								Store(SPT3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x01, SMUF)
								Store(STC3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x03, SMUF)
								Store(TCL3, SMUD)
								ALIB(0x0C, XX11)
								Store(0x20, SMUF)
								Store(0x199A, SMUD)
								ALIB(0x0C, XX11)
								Store(0x22, SMUF)
								Store(0x2C00, SMUD)
								ALIB(0x0C, XX11)
								Store(0x24, SMUF)
								Store(0x0148, SMUD)
								ALIB(0x0C, XX11)
								Store(0x25, SMUF)
								Store(0x2666, SMUD)
								ALIB(0x0C, XX11)
								Store(0x26, SMUF)
								Store(0x011C, SMUD)
								ALIB(0x0C, XX11)
								Store(0x27, SMUF)
								Store(0x040B, SMUD)
								ALIB(0x0C, XX11)
								Store(0x2C, SMUF)
								Store(0xC936, SMUD)
								ALIB(0x0C, XX11)
								Store(0x2E, SMUF)
								Store(0x2EE0, SMUD)
								ALIB(0x0C, XX11)
							}
							Else
							{
								Store(0x05, SMUF)
								If(LEqual(LBPR, 0x01))
								{
									Store(SPL6, SMUD)
								}
								Else
								{
									If(LEqual(OVLD, 0x01))
									{
										Store(SPL4, SMUD)
									}
									Else
									{
										Store(SPL9, SMUD)
									}
								}
								ALIB(0x0C, XX11)
								Store(0x07, SMUF)
								If(LEqual(LBPR, 0x01))
								{
									Store(SPP6, SMUD)
								}
								Else
								{
									If(LEqual(OVLD, 0x01))
									{
										Store(SPP4, SMUD)
									}
									Else
									{
										Store(SPP9, SMUD)
									}
								}
								ALIB(0x0C, XX11)
								Store(0x06, SMUF)
								If(LEqual(LBPR, 0x01))
								{
									Store(FPP6, SMUD)
								}
								Else
								{
									If(LEqual(OVLD, 0x01))
									{
										Store(FPP4, SMUD)
									}
									Else
									{
										Store(FPP9, SMUD)
									}
								}
								ALIB(0x0C, XX11)
								Store(0x0B, SMUF)
								Store(TDC9, SMUD)
								ALIB(0x0C, XX11)
								Store(0x0C, SMUF)
								Store(EDC9, SMUD)
								ALIB(0x0C, XX11)
								Store(0x08, SMUF)
								Store(SPT9, SMUD)
								ALIB(0x0C, XX11)
								Store(0x01, SMUF)
								Store(STC9, SMUD)
								ALIB(0x0C, XX11)
								Store(0x03, SMUF)
								Store(TCL9, SMUD)
								ALIB(0x0C, XX11)
								Store(0x20, SMUF)
								Store(0x199A, SMUD)
								ALIB(0x0C, XX11)
								Store(0x22, SMUF)
								Store(0x2E00, SMUD)
								ALIB(0x0C, XX11)
								Store(0x24, SMUF)
								Store(0x0148, SMUD)
								ALIB(0x0C, XX11)
								Store(0x25, SMUF)
								Store(0x2666, SMUD)
								ALIB(0x0C, XX11)
								Store(0x26, SMUF)
								Store(0x0145, SMUD)
								ALIB(0x0C, XX11)
								Store(0x27, SMUF)
								Store(0x043D, SMUD)
								ALIB(0x0C, XX11)
								Store(0x2C, SMUF)
								Store(0xC003, SMUD)
								ALIB(0x0C, XX11)
								Store(0x2E, SMUF)
								Store(0x4650, SMUD)
								ALIB(0x0C, XX11)
							}
						}
					}
					Method (CMFC, 0, Serialized)
					{
						Name(EDXX, Buffer(0x80){})
						CreateField(EDXX,0x00,0x50,EDI1)
						CreateField(EDXX,0x50,0x10,EDI2)
						CreateField(EDXX,0x60,0x03A0,EDI3)
						Store(HEAD, EDI1)
						Store(PAID, EDI2)
						Store(REST, EDI3)
						Return(EDXX)
					}
					Method (LFCI, 2, Serialized)
					{
						Return(OKRB)
					}
					Method (_Q11, 0, NotSerialized)
					{
						If(LEqual(^^^GP17.VGA.BRIL, 0x00))
						{
							Store(0x01, BKLT)
						}
						Store(0x11, P80H)
						Notify(^^^GP17.VGA.LCD, 0x87)
						Notify(VPC0, 0x80)
					}
					Method (_Q12, 0, NotSerialized)
					{
						If(LEqual(BKLT, 0x01))
						{
							Store(0x00, BKLT)
						}
						Else
						{
							Store(0x12, P80H)
							Notify(^^^GP17.VGA.LCD, 0x86)
							Notify(VPC0, 0x80)
						}
					}
					Method (_Q15, 0, NotSerialized)
					{
						Store(0x15, P80H)
						If(ECAV)
						{
							If(LEqual(Acquire(LFCM, 0xA000), 0x00))
							{
								Release(LFCM)
							}
						}
						Notify(LID, 0x80)
					}
					Method (_Q16, 0, NotSerialized)
					{
						Store(0x16, P80H)
						If(ECAV)
						{
							If(LEqual(Acquire(LFCM, 0xA000), 0x00))
							{
								Release(LFCM)
							}
						}
						Notify(LID, 0x80)
					}
					Method (_Q25, 0, NotSerialized)
					{
						Store(0x25, P80H)
						Notify(ADP0, 0x80)
						Notify(BAT0, 0x80)
						Notify(BAT0, 0x81)
					}
					Method (_Q37, 0, NotSerialized)
					{
						Store(0x37, P80H)
						Sleep(0x012C)
						Notify(ADP0, 0x80)
						Notify(BAT0, 0x80)
					}
					Method (_Q38, 0, NotSerialized)
					{
						Store(0x38, P80H)
						Sleep(0x012C)
						Notify(ADP0, 0x80)
						Notify(BAT0, 0x80)
					}
					Method (_Q32, 0, NotSerialized)
					{
						Store(0x32, P80H)
						Notify(PWRB, 0x80)
					}
					Method (_Q44, 0, NotSerialized)
					{
						Store(0x44, P80H)
						Notify(VPC0, 0x80)
					}
					Method (_Q86, 0, NotSerialized)
					{
						Store(0x86, P80H)
						Sleep(0x05)
						^VPC0.DYTC(0x001F4001)
					}
					Method (_Q87, 0, NotSerialized)
					{
						Store(0x87, P80H)
						Sleep(0x05)
						^VPC0.DYTC(0x000F4001)
					}
					Method (_Q79, 0, NotSerialized)
					{
						Store(0x79, P80H)
						^VPC0.DYTC(0x001F0001)
					}
					Method (_Q80, 0, NotSerialized)
					{
						Store(0x80, P80H)
						^VPC0.DYTC(0x001F0001)
					}
					Method (_Q81, 0, NotSerialized)
					{
						Store(0x81, P80H)
						^VPC0.DYTC(0x001F0001)
					}
					Method (_Q66, 0, NotSerialized)
					{
						Store(0xCC, SMBA)
					}
					Method (_Q67, 0, NotSerialized)
					{
						Store(0xCD, SMBA)
					}
					Scope (\)
					{
						Name(LSKD, 0x00)
					}
					Method (_QDF, 0, NotSerialized)
					{
						Store(0xDF, P80H)
						If(LEqual(Acquire(LFCM, 0xA000), 0x00))
						{
							If(LNotEqual(LSKV, 0x00))
							{
								If(LLess(LSKV, 0x06))
								{
									Store(LSKV, LSKD)
								}
								If(LEqual(LSKV, 0x04))
								{
									If(LEqual(HKDB, 0x01))
									{
										Store(0xA4, ^^^SMB.GP62)
									}
									Else
									{
										Store(0xC5, ^^^SMB.GP62)
									}
								}
								If(LEqual(LSKV, 0x01))
								{
									Notify(WMIL, 0xD0)
								}
								Store(0x00, LSKV)
							}
							Release(LFCM)
						}
						Notify(WMIU, 0xD0)
					}
				}
				Scope (\_SB)
				{
					Device (ADP0)
					{
						Name(_HID, "ACPI0003")
						Name(XX00, Buffer(0x03){})
						Method (_STA, 0, NotSerialized)
						{
							If(LEqual(ECON, 0x01))
							{
								Return(0x0F)
							}
							Return(0x00)
						}
						Name(ACDC, 0xFF)
						Method (_PSR, 0, NotSerialized)
						{
							If(^^PCI0.LPC0.EC0.ECAV)
							{
								If(LEqual(Acquire(^^PCI0.LPC0.EC0.LFCM, 0xA000), 0x00))
								{
									Store(0x01, Local0)
									Store(^^PCI0.LPC0.EC0.ADPT, Local0)
									CreateWordField(XX00, 0x00, SSZE)
									CreateByteField(XX00,0x02,ACST)
									Store(0x03, SSZE)
									If(LNotEqual(Local0, ACDC))
									{
										If(Local0)
										{
											Store(0xECAC, P80H)
											^^PCI0.GP17.VGA.AFN4(0x01)
											Store(0x00, ACST)
										}
										Else
										{
											Store(0xECDC, P80H)
											^^PCI0.GP17.VGA.AFN4(0x02)
											Store(0x01, ACST)
										}
										ALIB(0x01, XX00)
										Store(Local0, ACDC)
									}
									Release(^^PCI0.LPC0.EC0.LFCM)
									Return(Local0)
								}
							}
						}
						Method (_PCL, 0, NotSerialized)
						{
							Return(Package(1) {_SB})
						}
					}
					Device (LID)
					{
						Name(_HID, EISAID("PNP0C0D"))
						Method (_STA, 0, NotSerialized)
						{
							If(LEqual(ECON, 0x01))
							{
								Return(0x0F)
							}
							Return(0x00)
						}
						Method (_LID, 0, NotSerialized)
						{
							Store(0x00, Local0)
							If(LEqual(Acquire(^^PCI0.LPC0.EC0.LFCM, 0xA000), 0x00))
							{
								Store(^^PCI0.LPC0.EC0.LSTE, Local0)
								Release(^^PCI0.LPC0.EC0.LFCM)
							}
							Return(Local0)
						}
					}
					Device (PWRB)
					{
						Name(_HID, EISAID("PNP0C0C"))
						Method (_STA, 0, NotSerialized)
						{
							If(LEqual(ECON, 0x01))
							{
								Return(0x0F)
							}
							Return(0x00)
						}
					}
					Device (WMI4)
					{
						Name(_HID, EISAID("PNP0C14"))
						Name(_UID, 0x04)
						Mutex(MWMI, 0)
						Name(_WDG, Buffer(0x28)
						{
							0x76, 0x37, 0xA0, 0xC3, 0xAC, 0x51, 0xAA, 0x49, 
							0xAD, 0x0F, 0xF2, 0xF7, 0xD6, 0x2C, 0x3F, 0x3C, 
							0x41, 0x44, 0x03, 0x05, 0x21, 0x12, 0x90, 0x05, 
							0x66, 0xD5, 0xD1, 0x11, 0xB2, 0xF0, 0x00, 0xA0, 
							0xC9, 0x06, 0x29, 0x10, 0x42, 0x44, 0x01, 0x00
						})
						Name(ITEM, Package(3)
						{
							Package(3) {0x00, 0x00, "BAT0 BatMaker"}, 
							Package(3) {0x00, 0x01, "BAT0 HwId "}, 
							Package(3) {0x00, 0x02, "BAT0 MfgDate "}
						})
						Method (WQAD, 1, NotSerialized)
						{
							If(^^PCI0.LPC0.EC0.ECAV)
							{
								If(LEqual(Acquire(^^PCI0.LPC0.EC0.LFCM, 0xA000), 0x00))
								{
									Store(PSAG(Arg0), Local0)
									Store(DerefOf(Index(ITEM, Local0)), Local1)
									Store(DerefOf(Index(Local1, 0x00)), Local2)
									Store(DerefOf(Index(Local1, 0x01)), Local3)
									Store(DerefOf(Index(Local1, 0x02)), Local4)
									Store(BATD(Local2, Local3), Local5)
									Concatenate(Local4, ",", Local6)
									Concatenate(Local6, Local5, Local7)
									Release(^^PCI0.LPC0.EC0.LFCM)
								}
							}
							Return(Local7)
						}
						Method (PSAG, 1, NotSerialized)
						{
							Return(Arg0)
						}
						Method (BATD, 2, NotSerialized)
						{
							Name(STRB, Buffer(0x0A)
							{
								0x00
							})
							Name(BUFR, Buffer(0x08){})
							Store(^^PCI0.LPC0.EC0.FWBT, BUFR)
							CreateWordField(BUFR, 0x00, MID0)
							CreateWordField(BUFR, 0x02, HID0)
							CreateWordField(BUFR, 0x04, FIR0)
							CreateWordField(BUFR, 0x06, DAT0)
							If(LEqual(Arg0, 0x00))
							{
								If(LEqual(Arg1, 0x00))
								{
									Store(ToHexString(MID0), STRB)
								}
								If(LEqual(Arg1, 0x01))
								{
									Store(ToHexString(HID0), STRB)
								}
								If(LEqual(Arg1, 0x02))
								{
									Store(^^PCI0.LPC0.EC0.B1DA, Local0)
									Name(DATB, Buffer(0x09)
									{
										0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 
										0x00
									})
									Store(0x07, Local3)
									Store(And(Local0, 0x1F), Local1)
									While(Local1)
									{
										Divide(Local1, 0x0A, Local2, Local1)
										Add(Local2, 0x30, Index(DATB, Local3))
										Decrement(Local3)
									}
									Store(0x05, Local3)
									Store(ShiftRight(And(Local0, 0x01E0), 0x05), Local1)
									While(Local1)
									{
										Divide(Local1, 0x0A, Local2, Local1)
										Add(Local2, 0x30, Index(DATB, Local3))
										Decrement(Local3)
									}
									Store(0x03, Local3)
									Store(Add(ShiftRight(And(Local0, 0xFE00), 0x09), 0x07BC), Local1)
									While(Local1)
									{
										Divide(Local1, 0x0A, Local2, Local1)
										Add(Local2, 0x30, Index(DATB, Local3))
										Decrement(Local3)
									}
									Store(DATB, STRB)
								}
							}
							Return(ShiftLeft(STRB, Ones))
						}
						Name(WQBD, Buffer(0x0275)
						{
							0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
							0x65, 0x02, 0x00, 0x00, 0xF8, 0x05, 0x00, 0x00, 
							0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
							0x18, 0xD1, 0x82, 0x00, 0x01, 0x06, 0x18, 0x42, 
							0x10, 0x05, 0x10, 0x8A, 0x0D, 0x21, 0x02, 0x0B, 
							0x83, 0x50, 0x50, 0x18, 0x14, 0xA0, 0x45, 0x41, 
							0xC8, 0x05, 0x14, 0x95, 0x02, 0x21, 0xC3, 0x02, 
							0x14, 0x0B, 0x70, 0x2E, 0x40, 0xBA, 0x00, 0xE5, 
							0x28, 0x72, 0x0C, 0x22, 0x02, 0xF7, 0xEF, 0x0F, 
							0x31, 0xD0, 0x18, 0xA8, 0x50, 0x08, 0x89, 0x00, 
							0xA6, 0x42, 0xE0, 0x08, 0x41, 0xBF, 0x02, 0x10, 
							0x3A, 0x14, 0x20, 0x53, 0x80, 0x41, 0x01, 0x4E, 
							0x11, 0x44, 0x10, 0xA5, 0x65, 0x01, 0xBA, 0x05, 
							0xF8, 0x16, 0xA0, 0x1D, 0x42, 0x68, 0x91, 0x9A, 
							0x9F, 0x04, 0x81, 0x6A, 0x5B, 0x80, 0x45, 0x01, 
							0xB2, 0x41, 0x08, 0xA0, 0xC7, 0xC1, 0x44, 0x0E, 
							0x02, 0x25, 0x66, 0x10, 0x28, 0x9D, 0x73, 0x90, 
							0x4D, 0x60, 0xE1, 0x9F, 0x4C, 0x94, 0xF3, 0x88, 
							0x92, 0xE0, 0xA8, 0x0E, 0x22, 0x42, 0xF0, 0x72, 
							0x05, 0x48, 0x9E, 0x80, 0x34, 0x4F, 0x4C, 0xD6, 
							0x07, 0xA1, 0x21, 0xB0, 0x11, 0xF0, 0x88, 0x12, 
							0x40, 0x58, 0xA0, 0x75, 0x2A, 0x14, 0x0C, 0xCA, 
							0x03, 0x88, 0xE4, 0x8C, 0x15, 0x05, 0x6C, 0xAF, 
							0x13, 0x91, 0xC9, 0x81, 0x52, 0x49, 0x70, 0xA8, 
							0x61, 0x5A, 0xE2, 0xEC, 0x34, 0xB2, 0x13, 0x39, 
							0xB6, 0xA6, 0x87, 0x2C, 0x48, 0x26, 0x6D, 0x28, 
							0xA8, 0xB1, 0x7B, 0x5A, 0x27, 0xE5, 0x99, 0x46, 
							0x3C, 0x28, 0xC3, 0x24, 0xF0, 0x28, 0x18, 0x1A, 
							0x27, 0x28, 0x0B, 0x42, 0x0E, 0x06, 0x8A, 0x02, 
							0x3C, 0x09, 0xCF, 0xB1, 0x78, 0x01, 0xC2, 0x67, 
							0x4C, 0xA6, 0x1D, 0x23, 0x81, 0xCF, 0x04, 0x1E, 
							0xE6, 0x31, 0x63, 0x47, 0x14, 0x2E, 0xE0, 0xF9, 
							0x1C, 0x43, 0xE4, 0xB8, 0x87, 0x1A, 0xE3, 0x28, 
							0x22, 0x3F, 0x08, 0x60, 0x05, 0x1D, 0x04, 0x90, 
							0x38, 0xFF, 0xFF, 0xE3, 0x89, 0x76, 0xDA, 0xC1, 
							0x42, 0xC7, 0x39, 0xBF, 0xD0, 0x18, 0xD1, 0xE3, 
							0x40, 0xC9, 0x80, 0x90, 0x47, 0x01, 0x56, 0x61, 
							0x35, 0x91, 0x04, 0xBE, 0x07, 0x74, 0x76, 0x12, 
							0xD0, 0xA5, 0x21, 0x46, 0x6F, 0x08, 0xD2, 0x26, 
							0xC0, 0x96, 0x00, 0x6B, 0x02, 0x8C, 0xDD, 0x06, 
							0x08, 0xCA, 0xD1, 0x36, 0x87, 0x22, 0x84, 0x28, 
							0x21, 0xE2, 0x86, 0xAC, 0x11, 0x45, 0x10, 0x95, 
							0x41, 0x08, 0x35, 0x50, 0xD8, 0x28, 0xF1, 0x8D, 
							0x13, 0x22, 0x48, 0x02, 0x8F, 0x1C, 0x77, 0x04, 
							0xF0, 0xD8, 0x0E, 0xE8, 0x04, 0x4F, 0xE9, 0x71, 
							0xC1, 0x04, 0x9E, 0xF7, 0xC1, 0x1D, 0xEA, 0x21, 
							0x1C, 0x70, 0xD4, 0x18, 0xC7, 0xF1, 0x4C, 0x40, 
							0x16, 0x2E, 0x0D, 0x20, 0x8A, 0x04, 0x8F, 0x3A, 
							0x32, 0xF8, 0x70, 0xE0, 0x41, 0x7A, 0x9E, 0x9E, 
							0x40, 0x90, 0x43, 0x38, 0x82, 0xC7, 0x86, 0xA7, 
							0x02, 0x8F, 0x81, 0x5D, 0x17, 0x7C, 0x0E, 0xF0, 
							0x31, 0x01, 0xEF, 0x1A, 0x50, 0xA3, 0x7E, 0x3A, 
							0x60, 0x93, 0x0E, 0x87, 0x19, 0xAE, 0x87, 0x1D, 
							0xEE, 0x04, 0x1E, 0x0E, 0x1E, 0x33, 0xF8, 0x91, 
							0xC3, 0x83, 0xC3, 0xCD, 0xF0, 0x64, 0x8E, 0xAC, 
							0x54, 0x01, 0x66, 0x4F, 0x08, 0x3A, 0x4D, 0xF8, 
							0xCC, 0xC1, 0x6E, 0x00, 0xE7, 0xD3, 0x33, 0x24, 
							0x91, 0x3F, 0x08, 0xD4, 0xC8, 0x0C, 0xED, 0x69, 
							0xBF, 0x7A, 0x18, 0xF2, 0xA1, 0xE0, 0xB0, 0x98, 
							0xD8, 0xB3, 0x07, 0x1D, 0x0F, 0xF8, 0xAF, 0x24, 
							0x0F, 0x1B, 0x9E, 0xBE, 0xE7, 0x6B, 0x82, 0x91, 
							0x07, 0x8E, 0x1E, 0x88, 0xA1, 0x9F, 0x38, 0x0E, 
							0xE3, 0x34, 0x7C, 0x09, 0xF1, 0x39, 0xE0, 0xFF, 
							0x1F, 0x24, 0xC6, 0x31, 0x79, 0x70, 0x3C, 0xD8, 
							0xC8, 0xE9, 0x51, 0xC5, 0x47, 0x0A, 0x7E, 0xBE, 
							0xF0, 0x91, 0x82, 0x5D, 0x10, 0x9E, 0x1C, 0x0C, 
							0x71, 0x38, 0x67, 0xE5, 0x13, 0x85, 0x0F, 0x2A, 
							0xB8, 0x13, 0x05, 0x5C, 0x85, 0xE8, 0xE4, 0x36, 
							0x61, 0xB4, 0x67, 0x81, 0xC7, 0x09, 0x98, 0x07, 
							0x01, 0xF0, 0x8D, 0xDF, 0x07, 0x19, 0xB0, 0x4D, 
							0x09, 0x3B, 0x24, 0x78, 0x47, 0x19, 0xE0, 0x71, 
							0x32, 0xC1, 0x1D, 0x27, 0x3C, 0x04, 0x3E, 0x80, 
							0x87, 0x90, 0x93, 0xB4, 0xD2, 0xA9, 0x21, 0xCF, 
							0x3C, 0x60, 0x1B, 0x06, 0x57, 0x68, 0xD3, 0xA7, 
							0x46, 0xA3, 0x56, 0x0D, 0xCA, 0xD4, 0x28, 0xD3, 
							0xA0, 0x56, 0x9F, 0x4A, 0x8D, 0x19, 0xFB, 0xE1, 
							0x58, 0xDC, 0xBB, 0x40, 0x07, 0x03, 0x0B, 0x7B, 
							0x21, 0xE8, 0x88, 0xE0, 0x58, 0x20, 0x34, 0x08, 
							0x9D, 0x40, 0xFC, 0xFF, 0x07
						})
					}
					Device (WMIL)
					{
						Name(_HID, "PNP0C14")
						Name(_UID, "LSK")
						Name(_WDG, Buffer(0x3C)
						{
							0xB9, 0xEC, 0x18, 0x7F, 0xE6, 0xED, 0x4F, 0x4A, 
							0xA7, 0xCA, 0xB8, 0xDC, 0xF1, 0x5F, 0xA1, 0xD3, 
							0x53, 0x4B, 0x01, 0x02, 0x73, 0x9C, 0x64, 0x1F, 
							0xC5, 0xD9, 0x5A, 0x47, 0xA8, 0xC9, 0x34, 0x73, 
							0x06, 0xCD, 0x33, 0x29, 0xD0, 0x00, 0x01, 0x08, 
							0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, 
							0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, 
							0x44, 0x46, 0x01, 0x00
						})
						Method (_WED, 1, NotSerialized)
						{
							If(LEqual(Arg0, 0xD0))
							{
								Return(0x01)
							}
						}
						Name(WQDF, Buffer(0x04D4)
						{
							0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
							0xC4, 0x04, 0x00, 0x00, 0xA8, 0x12, 0x00, 0x00, 
							0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
							0x28, 0x43, 0x89, 0x00, 0x01, 0x06, 0x18, 0x42, 
							0x10, 0x05, 0x10, 0x8A, 0x28, 0x81, 0x42, 0x04, 
							0x0A, 0x40, 0xA4, 0x50, 0x30, 0x28, 0x0D, 0x20, 
							0x92, 0x03, 0x21, 0x17, 0x4C, 0x4C, 0x80, 0x08, 
							0x08, 0x79, 0x15, 0x60, 0x53, 0x80, 0x49, 0x10, 
							0xF5, 0xEF, 0x0F, 0x51, 0x12, 0x1C, 0x4A, 0x08, 
							0x84, 0x24, 0x0A, 0x30, 0x2F, 0x40, 0xB7, 0x00, 
							0xC3, 0x02, 0x6C, 0x0B, 0x30, 0x2D, 0xC0, 0x31, 
							0x24, 0x95, 0x06, 0x4E, 0x09, 0x2C, 0x05, 0x42, 
							0x42, 0x05, 0x28, 0x17, 0xE0, 0x5B, 0x80, 0x76, 
							0x44, 0x49, 0x16, 0x60, 0x19, 0x46, 0x04, 0x1E, 
							0x45, 0x64, 0xA3, 0x71, 0x68, 0xEC, 0x30, 0x2C, 
							0x13, 0x4C, 0x83, 0x38, 0x8C, 0xB2, 0x91, 0x45, 
							0xE0, 0x09, 0x75, 0x2A, 0x40, 0xAE, 0x00, 0x61, 
							0x02, 0xC4, 0xA3, 0x0A, 0xA3, 0x39, 0x28, 0x32, 
							0x87, 0xD0, 0x18, 0x31, 0x63, 0x22, 0xB0, 0x9D, 
							0x63, 0x6B, 0x14, 0xA7, 0x51, 0xB8, 0x00, 0xE9, 
							0x18, 0x1A, 0xC1, 0x71, 0x1D, 0x83, 0xC1, 0x82, 
							0x1C, 0x8A, 0x21, 0x0A, 0x1A, 0x82, 0xAC, 0x0E, 
							0x47, 0x16, 0x05, 0x28, 0x85, 0x91, 0x4B, 0x34, 
							0x0D, 0x30, 0xC8, 0x21, 0x19, 0xDE, 0x08, 0x61, 
							0xA2, 0x05, 0x0D, 0xEC, 0x01, 0x24, 0xF0, 0x80, 
							0x8E, 0x04, 0x23, 0x03, 0x42, 0x9E, 0x05, 0x58, 
							0x1F, 0x22, 0x21, 0xB0, 0x7B, 0x01, 0xC6, 0x04, 
							0x68, 0x14, 0xA0, 0x6D, 0x52, 0x1A, 0x54, 0x87, 
							0x02, 0xBC, 0x09, 0x70, 0x26, 0xC0, 0xD6, 0x88, 
							0x04, 0x63, 0x6B, 0x28, 0xC2, 0x8A, 0x14, 0xA4, 
							0x41, 0x14, 0x41, 0x14, 0x07, 0x25, 0xB0, 0x28, 
							0x11, 0x63, 0x19, 0xE3, 0x04, 0x63, 0x47, 0x0A, 
							0x1B, 0x25, 0x42, 0x65, 0x68, 0xB2, 0x3F, 0x08, 
							0x22, 0xCA, 0xC1, 0x81, 0x80, 0x45, 0x1A, 0x0D, 
							0xEA, 0x10, 0x90, 0xE0, 0xA1, 0xC0, 0x07, 0x82, 
							0x93, 0x3A, 0xAF, 0xA3, 0x3A, 0xE9, 0x20, 0x27, 
							0x7A, 0x60, 0x75, 0x9E, 0x06, 0xC8, 0xB8, 0xD9, 
							0xD4, 0xCC, 0xAE, 0xE3, 0x01, 0x04, 0xD7, 0xF3, 
							0x24, 0x04, 0xFF, 0xFF, 0xA7, 0x02, 0x0F, 0x33, 
							0x1C, 0x66, 0x88, 0x1E, 0xAC, 0x27, 0x70, 0x88, 
							0x0C, 0xD0, 0x93, 0x7A, 0x20, 0xC0, 0xCE, 0xEB, 
							0x64, 0x9E, 0x06, 0x4A, 0x15, 0x60, 0x76, 0xEC, 
							0x84, 0xE0, 0x78, 0x7C, 0x0C, 0xF0, 0x7C, 0x4E, 
							0x38, 0x81, 0xE5, 0x0F, 0x02, 0x35, 0x32, 0x43, 
							0x7B, 0xA8, 0xA7, 0xF5, 0x36, 0xE0, 0x03, 0x80, 
							0x09, 0x2C, 0xF6, 0x2C, 0x41, 0xC7, 0x03, 0x7E, 
							0xC5, 0xC7, 0x03, 0x21, 0xBC, 0x32, 0x78, 0xBE, 
							0x3E, 0x51, 0xE8, 0x68, 0xA1, 0xF1, 0xE0, 0x4E, 
							0x15, 0xBE, 0x20, 0x60, 0xC0, 0x8F, 0xF6, 0x7D, 
							0x21, 0xCC, 0x7B, 0x40, 0xDC, 0x83, 0xB7, 0xD6, 
							0x1B, 0x04, 0x21, 0x70, 0x6C, 0x08, 0x7D, 0x35, 
							0x2C, 0x6A, 0xF0, 0xF4, 0x60, 0xC1, 0xCF, 0x14, 
							0x0C, 0x98, 0x8F, 0xE7, 0xB4, 0x7C, 0xF4, 0xF0, 
							0xF0, 0xE0, 0x9F, 0x1B, 0x70, 0x07, 0x0A, 0x60, 
							0x32, 0x40, 0x7E, 0xA5, 0xC0, 0x8E, 0x1C, 0x7C, 
							0x58, 0x81, 0x31, 0xFF, 0x7F, 0x60, 0x0F, 0xDD, 
							0x7E, 0x05, 0x20, 0x04, 0x3F, 0xA7, 0x47, 0x83, 
							0x23, 0x8A, 0x70, 0x58, 0x46, 0x7F, 0x84, 0xE8, 
							0x73, 0xE2, 0x82, 0x88, 0x76, 0x58, 0x98, 0x59, 
							0xC5, 0x38, 0x8C, 0x48, 0x31, 0xA2, 0x45, 0xF4, 
							0x4C, 0x12, 0x14, 0x39, 0x56, 0xF4, 0x20, 0x38, 
							0xDE, 0x39, 0x1C, 0x52, 0xCC, 0xF8, 0xE1, 0xA3, 
							0x9C, 0xC7, 0x31, 0xF9, 0x94, 0x62, 0x84, 0xB3, 
							0x7B, 0x38, 0x79, 0x58, 0xB1, 0xE6, 0x49, 0xE9, 
							0xF4, 0x71, 0x5A, 0x0F, 0x21, 0x6C, 0xE4, 0x87, 
							0x80, 0x39, 0x5C, 0x78, 0x08, 0x7C, 0x3E, 0x98, 
							0x89, 0xE1, 0xCE, 0x33, 0xFC, 0x54, 0x82, 0x1D, 
							0x00, 0x97, 0x66, 0x03, 0x84, 0xC9, 0x7F, 0x1B, 
							0x48, 0xDE, 0x23, 0x81, 0xC2, 0xF8, 0x84, 0x03, 
							0xB8, 0x12, 0x7C, 0x82, 0x00, 0xD1, 0xD9, 0x00, 
							0x36, 0xF8, 0xD1, 0x3F, 0x1A, 0x84, 0x78, 0x7B, 
							0x08, 0x7F, 0x30, 0x47, 0xF3, 0x0C, 0xE1, 0x03, 
							0x0E, 0xFF, 0xFF, 0x1F, 0x70, 0x60, 0x9E, 0x69, 
							0x1E, 0x70, 0x9E, 0x70, 0xDE, 0x6B, 0x8E, 0xE0, 
							0x6D, 0xA0, 0xC2, 0x8B, 0x0D, 0x41, 0x39, 0x85, 
							0x10, 0xEF, 0x35, 0x0F, 0x38, 0x9E, 0x43, 0x88, 
							0x80, 0x0F, 0x38, 0x06, 0x0D, 0xF8, 0x8A, 0x63, 
							0xC8, 0xB0, 0x01, 0xC3, 0xC4, 0xF6, 0x39, 0x27, 
							0x46, 0xA8, 0x20, 0x6F, 0x38, 0x3E, 0xE0, 0xB0, 
							0x80, 0xE7, 0x01, 0x1D, 0x44, 0x7C, 0xC0, 0x01, 
							0xF8, 0x71, 0x2E, 0x01, 0x0E, 0x87, 0x05, 0x4E, 
							0xE0, 0x73, 0x09, 0xFC, 0xFF, 0xFF, 0xB9, 0x04, 
							0x3C, 0x91, 0x4D, 0x1C, 0x09, 0x98, 0x76, 0x0A, 
							0xD9, 0x58, 0xAD, 0x4F, 0x05, 0x34, 0xD3, 0x8A, 
							0xE5, 0x11, 0x57, 0x98, 0x4F, 0x41, 0x58, 0xF4, 
							0x43, 0x67, 0x29, 0x00, 0x75, 0x8C, 0xE3, 0xFA, 
							0x29, 0xA4, 0x8C, 0x46, 0x23, 0x32, 0x9C, 0xB5, 
							0xC0, 0x08, 0xCE, 0x20, 0x06, 0x74, 0x50, 0x08, 
							0x39, 0x39, 0x0E, 0xA0, 0x7E, 0x75, 0x9A, 0x92, 
							0x66, 0xC1, 0x20, 0x5E, 0x77, 0x18, 0xC1, 0x54, 
							0x57, 0x23, 0x3A, 0x47, 0x5F, 0x07, 0xF8, 0x2D, 
							0xC5, 0x07, 0x04, 0x83, 0xFB, 0x48, 0xF1, 0xF6, 
							0x01, 0x96, 0xD1, 0x06, 0xF1, 0x75, 0xC1, 0x07, 
							0x02, 0x6F, 0xF2, 0x44, 0x30, 0x6A, 0x4E, 0x4C, 
							0xA8, 0x69, 0xF8, 0x72, 0xF0, 0x5A, 0x63, 0x02, 
							0xEB, 0xBA, 0x23, 0x40, 0x3F, 0x80, 0x78, 0x14, 
							0xBE, 0x9E, 0x99, 0xA0, 0xBE, 0x33, 0x02, 0x28, 
							0x80, 0x7C, 0x21, 0xF0, 0xFD, 0xE0, 0xA1, 0x80, 
							0x8D, 0xE1, 0x15, 0xC1, 0x68, 0x46, 0xE7, 0x22, 
							0x27, 0x8F, 0x92, 0x35, 0x79, 0x0A, 0xE2, 0xC9, 
							0x3B, 0xF2, 0xE4, 0xD1, 0x17, 0x0A, 0x1F, 0x09, 
							0x38, 0x81, 0x23, 0x8E, 0x9D, 0xDE, 0x3F, 0xF0, 
							0x93, 0x3D, 0xB5, 0xC7, 0x04, 0x23, 0xFF, 0xFF, 
							0x43, 0xBC, 0x20, 0x79, 0xF0, 0xE0, 0x38, 0x57, 
							0xC1, 0x19, 0x0B, 0x47, 0x79, 0x5B, 0xC0, 0x0E, 
							0xC6, 0x17, 0x00, 0x3E, 0x0E, 0x5F, 0x00, 0xF8, 
							0xF8, 0x7C, 0xE9, 0x80, 0x7F, 0x02, 0xC0, 0x12, 
							0x14, 0x78, 0x03, 0x00, 0x39, 0x3C, 0x26, 0xDE, 
							0xA8, 0xA8, 0xAC, 0x71, 0xA1, 0x06, 0xEB, 0xAB, 
							0x11, 0xC3, 0x7E, 0xC2, 0xB0, 0xE8, 0xB1, 0xEA, 
							0x32, 0xF1, 0xA6, 0x86, 0x81, 0xF5, 0xF0, 0x39, 
							0xAC, 0xD1, 0xC2, 0x1E, 0xF5, 0xBB, 0x89, 0x0F, 
							0x36, 0x9E, 0x99, 0x31, 0xC2, 0xFA, 0x08, 0xE0, 
							0xDB, 0xC7, 0x23, 0x00, 0x98, 0x4F, 0x6A, 0xB0, 
							0xAE, 0x08, 0x18, 0x41, 0x6F, 0x05, 0xDD, 0x46, 
							0xF8, 0x38, 0x2C, 0x79, 0x5D, 0xBA, 0x8D, 0xB0, 
							0x09, 0xB0, 0xCB, 0x0F, 0x4E, 0xE6, 0xC9, 0x81, 
							0x42, 0x58, 0xE0, 0x7D, 0xCB, 0x07, 0x08, 0x94, 
							0x20, 0x38, 0x0A, 0xE2, 0x03, 0x84, 0xC3, 0x0A, 
							0xF8, 0xFF, 0xDF, 0x89, 0xB0, 0x07, 0x08, 0x7C, 
							0xB8, 0x03, 0x04, 0x28, 0x2E, 0x32, 0xF8, 0xE1, 
							0x82, 0x6B, 0x78, 0xB8, 0xD3, 0x03, 0x3C, 0x02, 
							0x5F, 0x90, 0xC0, 0x77, 0x7A, 0x00, 0x1E, 0xA1, 
							0x4E, 0x0F, 0xA0, 0x3B, 0x05, 0xF8, 0xF4, 0x00, 
							0xAE, 0xF1, 0x03, 0x0F, 0x8D, 0x2F, 0x03, 0xDD, 
							0x8A, 0x70, 0x8A, 0xD7, 0x26, 0xE8, 0xB7, 0x22, 
							0x98, 0x1A, 0x01, 0x75, 0x2B, 0x62, 0xFF, 0x7F, 
							0x82, 0xEA, 0x60, 0x94, 0xFF, 0xE4, 0x80, 0x4A, 
							0x7C, 0x72, 0xA0, 0x20, 0x1E, 0xAD, 0x6F, 0x45, 
							0x80, 0xCF, 0x98, 0xA7, 0x1F, 0x28, 0xB7, 0xB4, 
							0xF3, 0xC6, 0xC4, 0x9A, 0x22, 0xF4, 0x9B, 0x25, 
							0x6E, 0x8A, 0xE0, 0x1A, 0x09, 0x6E, 0x8C, 0xB0, 
							0x6E, 0x03, 0xBE, 0x48, 0x01, 0xDF, 0xFF, 0x3F, 
							0x81, 0xC5, 0xDD, 0x17, 0x50, 0x72, 0xEE, 0x0B, 
							0x14, 0xC4, 0xF7, 0x06, 0x47, 0x9D, 0x3B, 0x1A, 
							0xDA, 0x67, 0x1B, 0xDF, 0x57, 0x7C, 0x6F, 0x01, 
							0x2E, 0x73, 0xC7, 0x1F, 0x7A, 0xD8, 0x81, 0x0E, 
							0x73, 0x6F, 0x81, 0x37, 0x32, 0x5F, 0xA2, 0x80, 
							0xF7, 0xB5, 0xC3, 0xF7, 0x16, 0x70, 0xC1, 0xF2, 
							0x7B, 0x0B, 0x78, 0xC0, 0xDE, 0x5B, 0xC0, 0x78, 
							0x04, 0xC0, 0x5F, 0x7B, 0x3C, 0xA2, 0xB7, 0x88, 
							0x28, 0xAF, 0x92, 0x6F, 0x2F, 0xBE, 0xB5, 0xB0, 
							0x33, 0xBD, 0x2F, 0x28, 0xEC, 0xFF, 0x7F, 0x6C, 
							0xC1, 0x29, 0xB4, 0xE9, 0x53, 0xA3, 0x51, 0xAB, 
							0x06, 0x65, 0x6A, 0x94, 0x69, 0x50, 0xAB, 0x4F, 
							0xA5, 0xC6, 0x8C, 0x19, 0x39, 0x84, 0xFB, 0x21, 
							0xA0, 0xE1, 0x39, 0x10, 0x08, 0x8D, 0x48, 0x21, 
							0x10, 0x47, 0xFE, 0x5D, 0x08, 0xC4, 0x82, 0x3D, 
							0x80, 0x30, 0x29, 0x07, 0x47, 0x01, 0x5B, 0xD7, 
							0xD1, 0x91, 0x6A, 0x55, 0x01, 0xC4, 0x94, 0x83, 
							0x08, 0xC8, 0x29, 0x7E, 0x22, 0x02, 0x72, 0x26, 
							0x10, 0x01, 0x39, 0x95, 0x0E, 0x20, 0x16, 0x11, 
							0x44, 0xC7, 0x48, 0xE2, 0x03, 0x88, 0x05, 0x01, 
							0x11, 0x90, 0x43, 0x3D, 0x0B, 0x04, 0x48, 0x40, 
							0x04, 0xE4, 0xFF, 0x3F
						})
					}
					Device (WMIU)
					{
						Name(_HID, "PNP0C14")
						Name(_UID, "LSK20")
						Name(_WDG, Buffer(0x3C)
						{
							0x74, 0x09, 0x6C, 0xCE, 0x07, 0x04, 0x50, 0x4F, 
							0x88, 0xBA, 0x4F, 0xC3, 0xB6, 0x55, 0x9A, 0xD8, 
							0x53, 0x4B, 0x01, 0x02, 0x0C, 0xDE, 0xC0, 0x8F, 
							0xE4, 0xB4, 0xFD, 0x43, 0xB0, 0xF3, 0x88, 0x71, 
							0x71, 0x1C, 0x12, 0x94, 0xD0, 0x00, 0x01, 0x08, 
							0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, 
							0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, 
							0x44, 0x41, 0x01, 0x00
						})
						Method (WMSK, 3, NotSerialized)
						{
							If(LEqual(Arg1, 0x01))
							{
								If(LEqual(ToInteger(Arg2), 0x01))
								{
									Return(0x02)
								}
								Else
								{
									If(LEqual(ToInteger(Arg2), 0x02))
									{
										Return(0x00)
									}
									Else
									{
										If(LEqual(ToInteger(Arg2), 0x03))
										{
											Return(0x01)
										}
										Else
										{
											If(LEqual(ToInteger(Arg2), 0x04))
											{
												Return(0x01)
											}
											Else
											{
												Return(0x00)
											}
										}
									}
								}
							}
						}
						Method (_WED, 1, NotSerialized)
						{
							If(LEqual(Arg0, 0xD0))
							{
								If(LEqual(0x01, LSKD))
								{
									Return(0x01)
								}
								Else
								{
									If(LEqual(0x02, LSKD))
									{
										Return(0x05)
									}
									Else
									{
										If(LEqual(0x03, LSKD))
										{
											Return(0x06)
										}
										Else
										{
											If(LEqual(0x04, LSKD))
											{
												If(LEqual(Acquire(^^PCI0.LPC0.EC0.LFCM, 0xA000), 0x00))
												{
													If(LEqual(^^PCI0.LPC0.EC0.HKDB, 0x01))
													{
														Return(0x02)
													}
													Else
													{
														Return(0x03)
													}
													Release(^^PCI0.LPC0.EC0.LFCM)
												}
											}
											Else
											{
												If(LEqual(0x05, LSKD))
												{
													Return(0x04)
												}
												Else
												{
													Return(0x00)
												}
											}
										}
									}
								}
							}
						}
						Name(WQDA, Buffer(0x0418)
						{
							0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, 
							0x08, 0x04, 0x00, 0x00, 0x5E, 0x0C, 0x00, 0x00, 
							0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, 
							0xA8, 0x40, 0x86, 0x00, 0x01, 0x06, 0x18, 0x42, 
							0x10, 0x05, 0x10, 0x8A, 0x28, 0x81, 0x42, 0x04, 
							0x8A, 0x40, 0xA4, 0x50, 0x30, 0x28, 0x0D, 0x20, 
							0x92, 0x03, 0x21, 0x17, 0x4C, 0x4C, 0x80, 0x08, 
							0x08, 0x79, 0x15, 0x60, 0x53, 0x80, 0x49, 0x10, 
							0xF5, 0xEF, 0x0F, 0x51, 0x12, 0x1C, 0x4A, 0x08, 
							0x84, 0x24, 0x0A, 0x30, 0x2F, 0x40, 0xB7, 0x00, 
							0xC3, 0x02, 0x6C, 0x0B, 0x30, 0x2D, 0xC0, 0x31, 
							0x24, 0x95, 0x06, 0x4E, 0x09, 0x2C, 0x05, 0x42, 
							0x42, 0x05, 0x28, 0x17, 0xE0, 0x5B, 0x80, 0x76, 
							0x44, 0x49, 0x16, 0x60, 0x19, 0x46, 0x04, 0x1E, 
							0x45, 0x64, 0xA3, 0x71, 0x68, 0xEC, 0x30, 0x2C, 
							0x13, 0x4C, 0x83, 0x38, 0x8C, 0xB2, 0x91, 0x45, 
							0xE0, 0x09, 0x75, 0x2A, 0x40, 0xAE, 0x00, 0x61, 
							0x02, 0xC4, 0xA3, 0x0A, 0xA3, 0x39, 0x28, 0x22, 
							0x1A, 0x1A, 0x25, 0x66, 0x4C, 0x04, 0xB6, 0x73, 
							0x6C, 0x8D, 0xE2, 0x34, 0x0A, 0x17, 0x20, 0x1D, 
							0x43, 0x23, 0x38, 0xAE, 0x63, 0x30, 0x58, 0x90, 
							0x43, 0x31, 0x44, 0x41, 0x02, 0xAC, 0xA2, 0x91, 
							0x61, 0x84, 0x08, 0x72, 0x7C, 0x81, 0xBA, 0xC4, 
							0x13, 0x88, 0xC7, 0xE4, 0x01, 0x18, 0x21, 0x4C, 
							0x8B, 0xB0, 0x82, 0x36, 0x62, 0x02, 0xC3, 0x1E, 
							0x0A, 0xE6, 0x07, 0x20, 0x01, 0x9E, 0x05, 0x58, 
							0x1F, 0x23, 0x21, 0xB0, 0x7B, 0x01, 0xE2, 0x04, 
							0x68, 0x1E, 0x8D, 0x46, 0x75, 0x9C, 0xC6, 0x88, 
							0xD2, 0x96, 0x00, 0xC5, 0x23, 0x13, 0x4C, 0x88, 
							0x28, 0x21, 0x3A, 0xC3, 0x13, 0x5A, 0x28, 0xC3, 
							0x45, 0x89, 0x13, 0x25, 0x70, 0x84, 0xDE, 0x04, 
							0x18, 0x83, 0x20, 0x08, 0x81, 0x43, 0x54, 0x36, 
							0x48, 0xA1, 0xB6, 0x3F, 0x08, 0x22, 0xC9, 0xC1, 
							0x89, 0x80, 0x45, 0x1A, 0x0D, 0xEA, 0x14, 0x90, 
							0xE0, 0xA9, 0xC0, 0x27, 0x82, 0x93, 0x3A, 0xAF, 
							0xA3, 0x3A, 0xEB, 0x20, 0xC1, 0x4F, 0xA4, 0xCE, 
							0xE3, 0x00, 0x19, 0x38, 0x9B, 0x9A, 0xD9, 0x75, 
							0x3E, 0x80, 0xE0, 0x1A, 0x50, 0xFF, 0xFF, 0x79, 
							0x3E, 0x16, 0xB0, 0x61, 0x86, 0xC3, 0x0C, 0xD1, 
							0x83, 0xF5, 0x04, 0x0E, 0x91, 0x01, 0x7A, 0x62, 
							0x4F, 0x04, 0x58, 0x87, 0x93, 0xD1, 0x71, 0xA0, 
							0x54, 0x01, 0x66, 0xC7, 0xAD, 0x49, 0x27, 0x38, 
							0x1E, 0x9F, 0x03, 0x3C, 0x9F, 0x13, 0x4E, 0x60, 
							0xF9, 0x83, 0x40, 0x8D, 0xCC, 0xD0, 0x36, 0x38, 
							0x2D, 0x1D, 0x04, 0x7C, 0x00, 0x30, 0x81, 0xC5, 
							0x1E, 0x26, 0xE8, 0x78, 0xC0, 0x7F, 0x00, 0x78, 
							0x3E, 0x88, 0xF0, 0xCE, 0xE0, 0xF9, 0x7A, 0x10, 
							0x3A, 0x5B, 0xC8, 0xC9, 0x78, 0x50, 0xC7, 0x0A, 
							0x5F, 0x10, 0x30, 0xE0, 0x47, 0xFB, 0xC2, 0x10, 
							0xE6, 0xA5, 0x21, 0xEE, 0xC1, 0x5B, 0xEB, 0x15, 
							0x82, 0x10, 0x38, 0x34, 0x84, 0xFE, 0x1A, 0x16, 
							0x35, 0x78, 0x7A, 0xB2, 0xE0, 0x87, 0x0A, 0x06, 
							0xCC, 0xC7, 0x73, 0x5A, 0x3E, 0x7B, 0x78, 0x78, 
							0xF0, 0x4F, 0x14, 0xC0, 0xE2, 0x3C, 0x81, 0xBB, 
							0x1C, 0xB0, 0x13, 0x05, 0x7E, 0xE0, 0xF0, 0x2F, 
							0x15, 0x86, 0xF5, 0x45, 0xE2, 0x1D, 0x22, 0x81, 
							0xB1, 0x02, 0x63, 0xFE, 0xFF, 0xC0, 0x1E, 0xB9, 
							0xFD, 0x0A, 0x40, 0x08, 0x7E, 0x4A, 0x4F, 0x06, 
							0xCF, 0x20, 0x11, 0x8E, 0xCA, 0xE8, 0x4F, 0x10, 
							0x7D, 0xCE, 0x5B, 0x10, 0xD1, 0x8E, 0xEA, 0x1C, 
							0x8E, 0x22, 0x54, 0x88, 0xB3, 0x30, 0x50, 0xB8, 
							0x60, 0x01, 0x8D, 0x93, 0xC0, 0x22, 0x87, 0x8A, 
							0x1E, 0x04, 0x07, 0x3C, 0x87, 0x43, 0x0A, 0x7A, 
							0x10, 0x27, 0x13, 0xE5, 0x3C, 0x8E, 0xC9, 0xA7, 
							0x14, 0x23, 0x1C, 0xD3, 0xC3, 0xC9, 0x53, 0x87, 
							0x6F, 0x1B, 0x07, 0x7F, 0x5E, 0xC7, 0x7A, 0x88, 
							0x6C, 0xE0, 0x87, 0x80, 0x39, 0x5B, 0x78, 0x08, 
							0x7C, 0x00, 0x07, 0x74, 0x8A, 0x56, 0x3A, 0x31, 
							0xE4, 0x79, 0x86, 0x8F, 0x19, 0x3B, 0x00, 0xAE, 
							0xCA, 0x03, 0x08, 0x13, 0xFF, 0x34, 0x90, 0xB4, 
							0x37, 0x02, 0x85, 0xF1, 0x09, 0x07, 0x70, 0x05, 
							0xF4, 0x00, 0x01, 0x9E, 0xB3, 0x01, 0x5C, 0xEC, 
							0x93, 0x8F, 0x12, 0xE2, 0xED, 0x21, 0xFA, 0xB9, 
							0x9C, 0xCC, 0x2B, 0x84, 0x8F, 0x37, 0x98, 0xFF, 
							0xFF, 0xF1, 0x06, 0xD6, 0x05, 0xC6, 0xDA, 0xAE, 
							0x37, 0x64, 0x4A, 0xCF, 0x34, 0xEF, 0x36, 0x46, 
							0x39, 0x2C, 0xC3, 0x3C, 0xDE, 0xF8, 0x76, 0xD0, 
							0x1A, 0x8C, 0xEE, 0x36, 0xEC, 0x3C, 0x72, 0x12, 
							0xA1, 0x18, 0xEE, 0x83, 0x44, 0x9C, 0xD8, 0xE1, 
							0x22, 0xC4, 0x7E, 0xE4, 0x30, 0xDE, 0xE3, 0x0D, 
							0x8B, 0x77, 0x1C, 0xD0, 0x31, 0xC4, 0xC7, 0x1B, 
							0x80, 0x1F, 0xA7, 0x83, 0xC7, 0x12, 0xF0, 0x9F, 
							0x15, 0xF8, 0xA9, 0x04, 0x4C, 0xFF, 0xFF, 0x53, 
							0x09, 0xFC, 0xC4, 0x0F, 0x02, 0x9D, 0x75, 0x9C, 
							0x16, 0x44, 0x36, 0x16, 0x6B, 0x02, 0xC9, 0x82, 
							0x50, 0xCE, 0x05, 0xCB, 0x23, 0xAE, 0x30, 0x8F, 
							0x27, 0xF2, 0x39, 0x44, 0x7E, 0xA9, 0x88, 0x70, 
							0x06, 0xC7, 0x10, 0xE9, 0xB4, 0x62, 0x1C, 0xD8, 
							0x2B, 0x87, 0xEF, 0x01, 0x4F, 0x16, 0x3C, 0x11, 
							0xB0, 0x0E, 0x72, 0x3C, 0x0B, 0x85, 0x94, 0xD1, 
							0x68, 0x54, 0x1E, 0x84, 0xB5, 0xC0, 0x08, 0xCE, 
							0x20, 0x06, 0x74, 0x50, 0x08, 0x1D, 0x90, 0x70, 
							0x4A, 0x40, 0x34, 0xAD, 0xF7, 0x21, 0x76, 0xEA, 
							0xF1, 0xFD, 0xC8, 0x04, 0x53, 0xDD, 0x8D, 0xE8, 
							0x3C, 0x7D, 0x23, 0xE0, 0xF7, 0x14, 0x9F, 0x11, 
							0x0C, 0x6E, 0x85, 0xF7, 0x0F, 0xD0, 0x8C, 0x38, 
							0x88, 0x6F, 0x0C, 0x3E, 0x13, 0x78, 0xA3, 0x27, 
							0x82, 0x51, 0x73, 0x64, 0x42, 0x4D, 0xC3, 0x53, 
							0x7D, 0xB1, 0x31, 0x81, 0x75, 0x5D, 0x86, 0x40, 
							0xA6, 0xEF, 0x98, 0x00, 0x0A, 0x20, 0x5F, 0x0A, 
							0x7C, 0xD2, 0x79, 0x30, 0x60, 0x63, 0x78, 0xD8, 
							0x31, 0x9A, 0xD1, 0xB9, 0xE0, 0xC9, 0xA3, 0x24, 
							0x4E, 0x9E, 0x82, 0x78, 0xF2, 0x8E, 0x3F, 0x79, 
							0xF4, 0x9D, 0xC2, 0x87, 0x2B, 0x4E, 0xE0, 0xB8, 
							0x63, 0xA7, 0x57, 0x10, 0xFC, 0x64, 0xFF, 0xFF, 
							0xA7, 0xF6, 0xA8, 0xE0, 0x59, 0xF8, 0xD2, 0x82, 
							0x1B, 0x3C, 0xDC, 0x5B, 0xC6, 0x91, 0x87, 0x79, 
							0xA7, 0xF2, 0xE9, 0xCA, 0x60, 0x41, 0xC2, 0xBC, 
							0x2F, 0xE0, 0x80, 0xDE, 0xEE, 0x5E, 0x1C, 0x0E, 
							0x37, 0xC4, 0xF9, 0x1E, 0x7A, 0x04, 0x1F, 0x3F, 
							0x7C, 0x66, 0xC0, 0x0D, 0x89, 0x5D, 0x03, 0xF8, 
							0x68, 0x7C, 0x0D, 0xE0, 0xA3, 0xF4, 0x1D, 0x0B, 
							0x7C, 0x02, 0xEF, 0x01, 0x20, 0x87, 0xC7, 0x84, 
							0x1F, 0x15, 0xBD, 0x67, 0x78, 0x5C, 0x7C, 0xC8, 
							0xBE, 0x22, 0x31, 0xEC, 0x67, 0x0D, 0x5F, 0xD2, 
							0x4E, 0xF0, 0x95, 0xE2, 0x85, 0x0D, 0x03, 0xEB, 
							0x43, 0x00, 0x87, 0x35, 0x5A, 0xD8, 0x43, 0x7E, 
							0x49, 0xF1, 0x09, 0xC7, 0x33, 0x33, 0x46, 0x58, 
							0x1F, 0x04, 0x1C, 0xE6, 0x20, 0x00, 0x9A, 0x03, 
							0x1B, 0xFE, 0x06, 0xE0, 0x4B, 0x40, 0x90, 0x37, 
							0x91, 0xD3, 0x7D, 0xF2, 0x31, 0x2A, 0xBF, 0x11, 
							0xF0, 0xF3, 0x08, 0x16, 0x28, 0x88, 0x6F, 0x18, 
							0x1E, 0xDB, 0x81, 0xC4, 0x86, 0x73, 0x2D, 0xC1, 
							0xFE, 0xFF, 0x09, 0x2A, 0xB4, 0xE9, 0x53, 0xA3, 
							0x51, 0xAB, 0x06, 0x65, 0x6A, 0x94, 0x69, 0x50, 
							0xAB, 0x4F, 0xA5, 0xC6, 0x8C, 0x99, 0xB8, 0xF0, 
							0xF9, 0x15, 0xA1, 0x11, 0x3B, 0x12, 0x08, 0x8D, 
							0x48, 0x21, 0x10, 0x07, 0xFE, 0x71, 0x08, 0xC4, 
							0x72, 0xEF, 0x61, 0xBA, 0x16, 0x11, 0x5A, 0x19, 
							0x01, 0x91, 0x36, 0x10, 0x01, 0x59, 0xBB, 0x0A, 
							0x20, 0x96, 0x04, 0x44, 0x40, 0xFE, 0xFF, 0x03
						})
					}
				}
			}
		}
	}
	Scope (\)
	{
		Name(HPDT, Package(9)
		{
			"LEGACYHP", 0x80000000, 0x80000000, "NATIVEHP", 0x80000000, 0x80000000,
			"THERMALX", 0x80000000, 0x80000000
		})
		Name(DDB0, 0x00)
		Name(DDB1, 0x00)
		Name(DDB2, 0x00)
	}
	Scope (_GPE)
	{
		Method (XL08, 0, NotSerialized)
		{
			TPST(0x3908)
			Notify(\_SB.PCI0.GP17, 0x02)
			Notify(\_SB.PCI0.GP18, 0x02)
		}
		Method (XL0E, 0, NotSerialized)
		{
			TPST(0x390E)
			Notify(\_SB.PCI0.GPP4, 0x02)
		}
		Method (XL19, 0, NotSerialized)
		{
			TPST(0x3919)
			Notify(\_SB.PCI0.GP17.XHC0, 0x02)
			Notify(\_SB.PCI0.GP17.XHC1, 0x02)
		}
	}
	Name(TSOS, 0x75)
	If(CondRefOf(\_OSI))
	{
		If(_OSI("Windows 2009"))
		{
			Store(0x50, TSOS)
		}
		If(_OSI("Windows 2015"))
		{
			Store(0x70, TSOS)
		}
	}
	Scope (_SB)
	{
		Name(D0S0, 0x01)
		Name(D3S0, 0x01)
		Name(D0S1, 0x01)
		Name(D3S1, 0x01)
		PowerResource(P0S0, 0, 0)
		{
			Method (_STA, 0, NotSerialized)
			{
				Return(D0S0)
			}
			Method (_ON, 0, NotSerialized)
			{
				Store(0x01, D0S0)
			}
			Method (_OFF, 0, NotSerialized)
			{
				Store(0x00, D0S0)
			}
		}
		PowerResource(P3S0, 0, 0)
		{
			Method (_STA, 0, NotSerialized)
			{
				Return(D3S0)
			}
			Method (_ON, 0, NotSerialized)
			{
				Store(0x01, D3S0)
			}
			Method (_OFF, 0, NotSerialized)
			{
				Store(0x00, D3S0)
			}
		}
		PowerResource(P0S1, 0, 0)
		{
			Method (_STA, 0, NotSerialized)
			{
				Return(D0S1)
			}
			Method (_ON, 0, NotSerialized)
			{
				Store(0x01, D0S1)
			}
			Method (_OFF, 0, NotSerialized)
			{
				Store(0x00, D0S1)
			}
		}
		PowerResource(P3S1, 0, 0)
		{
			Method (_STA, 0, NotSerialized)
			{
				Return(D3S1)
			}
			Method (_ON, 0, NotSerialized)
			{
				Store(0x01, D3S1)
			}
			Method (_OFF, 0, NotSerialized)
			{
				Store(0x00, D3S1)
			}
		}
		OperationRegion(SMIC, SystemMemory, 0xFED80000, 0x00800000)
		Field(SMIC, ByteAcc, NoLock, Preserve)
		{
			Offset(0x36A),	//Offset(874),
			SMIB, 8,
		}
		OperationRegion(SSMI, SystemIO, SMIB, 0x02)
		Field(SSMI, AnyAcc, NoLock, Preserve)
		{
			SMIW, 16,
		}
		OperationRegion(ECMC, SystemIO, 0x72, 0x02)
		Field(ECMC, AnyAcc, NoLock, Preserve)
		{
			ECMI, 8,
			ECMD, 8,
		}
		IndexField(ECMI, ECMD, ByteAcc, NoLock, Preserve)
		{
			Offset(0x8),	//Offset(8),
			FRTB, 32,
		}
		OperationRegion(FRTP, SystemMemory, FRTB, 0x0100)
		Field(FRTP, AnyAcc, NoLock, Preserve)
		{
			PEBA, 32,
			, 5,
			IC0E, 1,
			IC1E, 1,
			IC2E, 1,
			IC3E, 1,
			IC4E, 1,
			IC5E, 1,
			UT0E, 1,
			UT1E, 1,
			, 1,
			, 1,
			ST_E, 1,
			UT2E, 1,
			, 1,
			EMMD, 2,
			, 3,
			XHCE, 1,
			, 1,
			, 1,
			UT3E, 1,
			ESPI, 1,
			EMME, 1,
			HFPE, 1,
			, 2,
			PCEF, 1,
			, 4,
			IC0D, 1,
			IC1D, 1,
			IC2D, 1,
			IC3D, 1,
			IC4D, 1,
			IC5D, 1,
			UT0D, 1,
			UT1D, 1,
			, 1,
			, 1,
			ST_D, 1,
			UT2D, 1,
			, 1,
			EHCD, 1,
			, 4,
			XHCD, 1,
			SD_D, 1,
			, 1,
			UT3D, 1,
			, 1,
			EMD3, 1,
			, 2,
			S03D, 1,
			FW00, 16,
			FW01, 32,
			FW02, 16,
			FW03, 32,
			SDS0, 8,
			SDS1, 8,
			CZFG, 1,
			Offset(0x20),	//Offset(32),
			SD10, 32,
			EH10, 32,
			XH10, 32,
			STBA, 32,
		}
		OperationRegion(FCFG, SystemMemory, PEBA, 0x01000000)
		Field(FCFG, DWordAcc, NoLock, Preserve)
		{
			Offset(0xA3044),	//Offset(667716),
			IPDE, 32,
			IMPE, 32,
			Offset(0xA3078),	//Offset(667768),
			, 2,
			LDQ0, 1,
			Offset(0xA30CB),	//Offset(667851),
			, 7,
			AUSS, 1,
		}
		OperationRegion(IOMX, SystemMemory, 0xFED80D00, 0x0100)
		Field(IOMX, AnyAcc, NoLock, Preserve)
		{
			Offset(0x15),	//Offset(21),
			IM15, 8,
			IM16, 8,
			Offset(0x1F),	//Offset(31),
			IM1F, 8,
			IM20, 8,
			Offset(0x44),	//Offset(68),
			IM44, 8,
			, 8,
			IM46, 8,
			Offset(0x4A),	//Offset(74),
			IM4A, 8,
			IM4B, 8,
			Offset(0x57),	//Offset(87),
			IM57, 8,
			IM58, 8,
			Offset(0x68),	//Offset(104),
			IM68, 8,
			IM69, 8,
			IM6A, 8,
			IM6B, 8,
			, 8,
			IM6D, 8,
		}
		OperationRegion(FACR, SystemMemory, 0xFED81E00, 0x0100)
		Field(FACR, AnyAcc, NoLock, Preserve)
		{
			Offset(0x80),	//Offset(128),
			Offset(0x83),	//Offset(131),
			, 4,
			RD28, 1,
			, 1,
			RQTY, 1,
			, 1,
			Offset(0x87),	//Offset(135),
			, 4,
			SD28, 1,
			, 1,
			Offset(0xA0),	//Offset(160),
			PG1A, 1,
		}
		OperationRegion(EMMX, SystemMemory, 0xFEDD5800, 0x0130)
		Field(EMMX, AnyAcc, NoLock, Preserve)
		{
			Offset(0xD0),	//Offset(208),
			Offset(0xD2),	//Offset(210),
			, 1,
			FC18, 1,
			FC33, 1,
			, 7,
			CD_T, 1,
			WP_T, 1,
		}
		OperationRegion(EMMB, SystemMemory, 0xFEDD5800, 0x0130)
		Field(EMMB, AnyAcc, NoLock, Preserve)
		{
			Offset(0xA4),	//Offset(164),
			E0A4, 32,
			E0A8, 32,
			Offset(0xB0),	//Offset(176),
			E0B0, 32,
			Offset(0xD0),	//Offset(208),
			E0D0, 32,
			Offset(0x116),	//Offset(278),
			E116, 32,
		}
		Name(SVBF, Buffer(0x0100)
		{
			0x00
		})
		CreateDWordField(SVBF, 0x00, S0A4)
		CreateDWordField(SVBF, 0x04, S0A8)
		CreateDWordField(SVBF, 0x08, S0B0)
		CreateDWordField(SVBF, 0x0C, S0D0)
		CreateDWordField(SVBF, 0x10, S116)
		Method (SECR, 0, Serialized)
		{
			Store(E116, S116)
			Store(Zero, RQTY)
			Store(One, RD28)
			Store(SD28, Local0)
			While(Local0)
			{
				Store(SD28, Local0)
			}
		}
		Method (RECR, 0, Serialized)
		{
			Store(S116, E116)
		}
		OperationRegion(LUIE, SystemMemory, 0xFEDC0020, 0x04)
		Field(LUIE, AnyAcc, NoLock, Preserve)
		{
			IER0, 1,
			IER1, 1,
			IER2, 1,
			IER3, 1,
			UOL0, 1,
			UOL1, 1,
			UOL2, 1,
			UOL3, 1,
			WUR0, 2,
			WUR1, 2,
			WUR2, 2,
			WUR3, 2,
		}
		Method (FRUI, 2, Serialized)
		{
			If(LEqual(Arg0, 0x00))
			{
				Store(IUA0, Arg1)
			}
			If(LEqual(Arg0, 0x01))
			{
				Store(IUA1, Arg1)
			}
			If(LEqual(Arg0, 0x02))
			{
				Store(IUA2, Arg1)
			}
			If(LEqual(Arg0, 0x03))
			{
				Store(IUA3, Arg1)
			}
		}
		Method (SRAD, 2, Serialized)
		{
			ShiftLeft(Arg0, 0x01, Local0)
			Add(Local0, 0xFED81E40, Local0)
			OperationRegion(ADCR, SystemMemory, Local0, 0x02)
			Field(ADCR, ByteAcc, NoLock, Preserve)
			{
				ADTD, 2,
				ADPS, 1,
				ADPD, 1,
				ADSO, 1,
				ADSC, 1,
				ADSR, 1,
				ADIS, 1,
				ADDS, 3,
			}
			Store(One, ADIS)
			Store(Zero, ADSR)
			Stall(Arg1)
			Store(One, ADSR)
			Store(Zero, ADIS)
			Stall(Arg1)
		}
		Method (DSAD, 2, Serialized)
		{
			ShiftLeft(Arg0, 0x01, Local0)
			Add(Local0, 0xFED81E40, Local0)
			OperationRegion(ADCR, SystemMemory, Local0, 0x02)
			Field(ADCR, ByteAcc, NoLock, Preserve)
			{
				ADTD, 2,
				ADPS, 1,
				ADPD, 1,
				ADSO, 1,
				ADSC, 1,
				ADSR, 1,
				ADIS, 1,
				ADDS, 3,
			}
			If(LNotEqual(Arg0, ADTD))
			{
				If(LEqual(Arg1, 0x00))
				{
					Store(0x00, ADTD)
					Store(One, ADPD)
					Store(ADDS, Local0)
					While(LNotEqual(Local0, 0x07))
					{
						Store(ADDS, Local0)
					}
				}
				If(LEqual(Arg1, 0x03))
				{
					Store(Zero, ADPD)
					Store(ADDS, Local0)
					While(LNotEqual(Local0, 0x00))
					{
						Store(ADDS, Local0)
					}
					Store(0x03, ADTD)
				}
			}
		}
		Method (HSAD, 2, Serialized)
		{
			ShiftLeft(0x01, Arg0, Local3)
			ShiftLeft(Arg0, 0x01, Local0)
			Add(Local0, 0xFED81E40, Local0)
			OperationRegion(ADCR, SystemMemory, Local0, 0x02)
			Field(ADCR, ByteAcc, NoLock, Preserve)
			{
				ADTD, 2,
				ADPS, 1,
				ADPD, 1,
				ADSO, 1,
				ADSC, 1,
				ADSR, 1,
				ADIS, 1,
				ADDS, 3,
			}
			If(LNotEqual(Arg1, ADTD))
			{
				If(LEqual(Arg1, 0x00))
				{
					Store(One, PG1A)
					Store(0x00, ADTD)
					Store(One, ADPD)
					Store(ADDS, Local0)
					While(LNotEqual(Local0, 0x07))
					{
						Store(ADDS, Local0)
					}
					Store(One, RQTY)
					Store(One, RD28)
					Store(SD28, Local0)
					While(LNot(Local0))
					{
						Store(SD28, Local0)
					}
				}
				If(LEqual(Arg1, 0x03))
				{
					Store(Zero, RQTY)
					Store(One, RD28)
					Store(SD28, Local0)
					While(Local0)
					{
						Store(SD28, Local0)
					}
					Store(Zero, ADPD)
					Store(ADDS, Local0)
					While(LNotEqual(Local0, 0x00))
					{
						Store(ADDS, Local0)
					}
					Store(0x03, ADTD)
					Store(Zero, PG1A)
				}
			}
		}
		OperationRegion(FPIC, SystemIO, 0x0C00, 0x02)
		Field(ECMC, AnyAcc, NoLock, Preserve)
		{
			FPII, 8,
			FPID, 8,
		}
		IndexField(FPII, FPID, ByteAcc, NoLock, Preserve)
		{
			Offset(0xF4),	//Offset(244),
			IUA0, 8,
			IUA1, 8,
			Offset(0xF8),	//Offset(248),
			IUA2, 8,
			IUA3, 8,
		}
		Device (HFP1)
		{
			Name(_HID, "AMDI0060")
			Name(_UID, 0x00)
			Method (_STA, 0, NotSerialized)
			{
				If(HFPE)
				{
					Return(0x0F)
				}
				Else
				{
					Return(0x00)
				}
			}
			Method (_CRS, 0, NotSerialized)
			{
				Name(RBUF, ResourceTemplate()
				{
					Memory32Fixed(ReadWrite, 0xFEC11000, 0x00000100)
				})
				Return(RBUF)
			}
		}
		Device (GPIO)
		{
			Name(_HID, "AMDI0030")
			Name(_CID, "AMDI0030")
			Name(_UID, 0x00)
			Method (_CRS, 0, NotSerialized)
			{
				Name(RBUF, ResourceTemplate()
				{
					Interrupt(ResourceConsumer, Level, ActiveLow, Shared,,,)
					{
						0x00000007
					}
					Memory32Fixed(ReadWrite, 0xFED81500, 0x00000400)
					Memory32Fixed(ReadWrite, 0xFED81200, 0x00000100)
				})
				Return(RBUF)
			}
			Method (_STA, 0, NotSerialized)
			{
				If(LGreaterEqual(TSOS, 0x70))
				{
					Return(0x0F)
				}
				Else
				{
					Return(0x00)
				}
			}
		}
		Device (I2CC)
		{
			Name(_HID, "AMDI0010")
			Name(_UID, 0x02)
			Name(_CRS, ResourceTemplate()
			{
				IRQ(Edge, ActiveHigh, Exclusive) {4}
				Memory32Fixed(ReadWrite, 0xFEDC4000, 0x00001000)
			})
			Method (_STA, 0, NotSerialized)
			{
				Return(0x0F)
			}
			Method (RSET, 0, NotSerialized)
			{
				SRAD(0x07, 0xC8)
			}
		}
		Device (I2CD)
		{
			Name(_HID, "AMDI0010")
			Name(_UID, 0x03)
			Name(_CRS, ResourceTemplate()
			{
				IRQ(Edge, ActiveHigh, Exclusive) {6}
				Memory32Fixed(ReadWrite, 0xFEDC5000, 0x00001000)
			})
			Method (_STA, 0, NotSerialized)
			{
				Return(0x0F)
			}
			Method (RSET, 0, NotSerialized)
			{
				SRAD(0x08, 0xC8)
			}
		}
	}
	Scope (_SB.PCI0.GP18.SATA)
	{
		Name(_PR0, Package(1) {P0S0})
		Name(_PR3, Package(1) {P3S0})
		Method (_S0W, 0, NotSerialized)
		{
			If(LEqual(ST_D, One))
			{
				Return(0x04)
			}
			Else
			{
				Return(0x00)
			}
		}
		Method (_PS0, 0, NotSerialized)
		{
			If(LEqual(ST_D, One))
			{
				Store(0xD6, SMIW)
			}
		}
		Method (_PS3, 0, NotSerialized)
		{
			If(LEqual(ST_D, One))
			{
				Store(0xD5, SMIW)
			}
		}
	}
	Scope (_SB.PCI0.GP18.SAT1)
	{
		Name(_PR0, Package(1) {P0S1})
		Name(_PR3, Package(1) {P3S1})
		Method (_S0W, 0, NotSerialized)
		{
			If(LEqual(ST_D, One))
			{
				Return(0x04)
			}
			Else
			{
				Return(0x00)
			}
		}
		Method (_PS0, 0, NotSerialized)
		{
			If(LEqual(ST_D, One))
			{
				Store(0x01D6, SMIW)
			}
		}
		Method (_PS3, 0, NotSerialized)
		{
			If(LEqual(ST_D, One))
			{
				Store(0x01D5, SMIW)
			}
		}
	}
	Scope (_SB.I2CD)
	{
		Device (TPD0)
		{
			Name(_HID, "MSFT0001")
			Name(_CID, "PNP0C50")
			Method (_INI, 0, NotSerialized)
			{
				If(LEqual(TPTY, 0x04))
				{
					Store("CRQ0350", _HID)
				}
				If(LEqual(TPTY, 0x05))
				{
					Store("FTCS1003", _HID)
				}
				If(LEqual(TPTY, 0x01))
				{
					Store("ELAN0001", _HID)
				}
				If(LEqual(TPTY, 0x02))
				{
					Store("SYNA0001", _HID)
				}
				Return(Zero)
			}
			Method (_DSM, 4, Serialized)
			{
				If(LEqual(Arg0, ToUUID("3CDFF6F7-42674555-AD05B30A3D8938DE")}))
				{
					If(LEqual(Arg2, Zero))
					{
						If(LEqual(Arg1, One))
						{
							Return(Buffer(One)
							{
								0x03
							})
						}
					}
					If(LEqual(Arg2, One))
					{
						If(LOr(LEqual(TPTY, 0x01), LEqual(TPTY, 0x05)))
						{
							Return(0x01)
						}
						If(LOr(LOr(LEqual(TPTY, 0x02), LEqual(TPTY, 0x03)), LEqual(TPTY, 0x04)))
						{
							Return(0x20)
						}
					}
				}
				Return(Buffer(One)
				{
					0x00
				})
			}
			Method (_STA, 0, NotSerialized)
			{
				If(LEqual(TPTY, 0x00))
				{
					Return(0x00)
				}
				Else
				{
					Return(0x0F)
				}
			}
			Method (_CRS, 0, NotSerialized)
			{
				If(LEqual(TPTY, 0x01))
				{
					Name(SBFB, ResourceTemplate()
					{
						I2CSerialBus(0x0015, ControllerInitiated, 0x00061A80, AddressingMode7Bit, "\\_SB.I2CD", 0x00, ResourceConsumer,,)
					})
				}
				If(LOr(LOr(LEqual(TPTY, 0x02), LEqual(TPTY, 0x03)), LEqual(TPTY, 0x04)))
				{
					Name(SBFS, ResourceTemplate()
					{
						I2CSerialBus(0x002C, ControllerInitiated, 0x00061A80, AddressingMode7Bit, "\\_SB.I2CD", 0x00, ResourceConsumer,,)
					})
				}
				If(LEqual(TPTY, 0x05))
				{
					Name(SBFC, ResourceTemplate()
					{
						I2CSerialBus(0x0038, ControllerInitiated, 0x00061A80, AddressingMode7Bit, "\\_SB.I2CD", 0x00, ResourceConsumer,,)
					})
				}
				Name(SBFI, ResourceTemplate()
				{
					GpioInt(Level, ActiveLow, ExclusiveAndWake, PullUp, 0x0000, "\\_SB.GPIO", 0x00, ResourceConsumer,,)
					{
						0x0059
					}
				})
				If(LEqual(TPTY, 0x01))
				{
					Return(ConcatenateResTemplate(SBFB, SBFI))
				}
				If(LOr(LOr(LEqual(TPTY, 0x02), LEqual(TPTY, 0x03)), LEqual(TPTY, 0x04)))
				{
					Return(ConcatenateResTemplate(SBFS, SBFI))
				}
				If(LEqual(TPTY, 0x05))
				{
					Return(ConcatenateResTemplate(SBFC, SBFI))
				}
			}
			Method (TPRD, 0, Serialized)
			{
			}
			Method (TPWR, 1, Serialized)
			{
			}
		}
	}
	Scope (_SB.I2CC)
	{
		Device (TPSC)
		{
			Name(_HID, "MSFT0002")
			Name(_CID, "PNP0C50")
			If(LEqual(TPNY, 0x02))
			{
				Store("GTCH7503", _HID)
			}
			If(LEqual(TPNY, 0x01))
			{
				Store("ELAN901C", _HID)
			}
			Method (_CRS, 0, NotSerialized)
			{
				Name(SBFS, ResourceTemplate()
				{
					I2CSerialBus(0x0010, ControllerInitiated, 0x00061A80, AddressingMode7Bit, "\\_SB.I2CC", 0x00, ResourceConsumer,,)
				})
				Name(SBFI, ResourceTemplate()
				{
					GpioInt(Level, ActiveLow, ExclusiveAndWake, PullUp, 0x0000, "\\_SB.GPIO", 0x00, ResourceConsumer,,)
					{
						0x005A
					}
				})
				Return(ConcatenateResTemplate(SBFS, SBFI))
			}
			Method (_STA, 0, NotSerialized)
			{
				If(LNotEqual(TPNY, 0x00))
				{
					Return(0x0F)
				}
				Else
				{
					Return(0x00)
				}
			}
			Method (_DSM, 4, Serialized)
			{
				If(LEqual(Arg0, ToUUID("3CDFF6F7-42674555-AD05B30A3D8938DE")}))
				{
					If(LEqual(Arg2, Zero))
					{
						If(LEqual(Arg1, One))
						{
							Return(Buffer(One)
							{
								0x03
							})
						}
					}
					If(LEqual(Arg2, One))
					{
						Return(0x01)
					}
					Return(Buffer(One)
					{
						0x00
					})
				}
				Return(Buffer(One)
				{
					0x00
				})
			}
		}
	}
	Name(SPL2, 0x61A8)
	Name(SPL3, 0x2EE0)
	Name(SPL9, 0x4E20)
	Name(SPP2, 0x927C)
	Name(SPP3, 0x3A98)
	Name(SPP9, 0x4E20)
	Name(FPP2, 0xA410)
	Name(FPP3, 0x4E20)
	Name(FPP9, 0x7530)
	Name(TDC2, 0xABE0)
	Name(TDC3, 0x88B8)
	Name(TDC9, 0x88B8)
	Name(EDC2, 0x00011170)
	Name(EDC3, 0xAFC8)
	Name(EDC9, 0xAFC8)
	Name(SPT2, 0x0F)
	Name(SPT3, 0x05)
	Name(SPT9, 0x05)
	Name(STC2, 0x01F4)
	Name(STC3, 0xC8)
	Name(STC9, 0xC8)
	Name(TCL2, 0x62)
	Name(TCL3, 0x5F)
	Name(TCL9, 0x5F)
	Name(SPL4, 0x3A98)
	Name(SPP4, 0x3A98)
	Name(FPP4, 0x4E20)
	Name(SPL5, 0x4E20)
	Name(SPP5, 0x7530)
	Name(FPP5, 0x9C40)
	Name(SPL6, 0x3A98)
	Name(SPP6, 0x4650)
	Name(FPP6, 0x4E20)
	Name(SPL7, 0x55F0)
	Name(SPP7, 0x55F0)
	Name(FPP7, 0x9C40)
	Name(XX11, Buffer(0x07){})
	CreateWordField(XX11, 0x00, SSZE)
	CreateByteField(XX11,0x02,SMUF)
	CreateDWordField(XX11, 0x03, SMUD)
	Store(0x07, SSZE)
}