/*
* Intel ACPI Component Architecture
* AML Disassembler version 20061109
*
* Disassembly of dsdt-km, Thu Sep 25 21:43:51 2008
*
*
* Original Table Header:
* Signature "DSDT"
* Length 0x0000F9C8 (63944)
* Revision 0x01
* OEM ID "HP "
* OEM Table ID "nx7400"
* OEM Revision 0x00010000 (65536)
* Creator ID "MSFT"
* Creator Revision 0x0100000E (16777230)
*/
DefinitionBlock ("dsdt-km.aml", "DSDT", 1, "HP ", "nx7400", 0x00010000)
{
Name (C000, 0x00)
Processor (\_PR.CPU0, 0x01, 0x00001010, 0x06)
{
Name (C001, 0x00)
Method (CSTH, 0, NotSerialized)
{
If (LEqual (C001, 0x00))
{
Store (0x01, C001)
Store (0x00, \_SB.C002.C003.C004)
}

Store (\_SB.C002.C003.C005.C006 (), Local0)
Return (Local0)
}

Method (INI, 0, NotSerialized)
{
If (LAnd (And (\_SB.C007, 0x01000000), LEqual (C008 (), 0x04)))
{
\_SB.ISMI (0x3D, 0x00, 0x00, 0x00)
}
}

Method (PPC, 0, NotSerialized)
{
Return (C009 ())
}
}

Processor (\_PR.CPU1, 0x02, 0x00001010, 0x06)
{
Method (PPC, 0, NotSerialized)
{
Return (C009 ())
}
}

Method (C009, 0, Serialized)
{
If (LGreater (\_SB.C00A, 0x00))
{
Subtract (\_SB.C00A, 0x01, Local1)
}
Else
{
Store (0x00, Local1)
}

Acquire (\_SB.C002.C003.C005.C00B, 0xFFFF)
If (\_SB.C002.C003.C005.C00C)
{
Store (\_SB.C002.C003.C005.C00D, Local0)
Store (0x00, \_SB.C002.C003.C005.C00C)
If (LEqual (Local0, 0x00))
{
If (LLess (C000, Local1))
{
Add (C000, 0x01, C000)
}
}
Else
{
If (LEqual (Local0, 0x02))
{
If (LGreater (C000, 0x00))
{
Subtract (C000, 0x01, C000)
}
}
}
}

Store (0x00, Local3)
If (LLess (C000, Local1))
{
Or (Local3, 0x01, Local3)
}

If (LGreater (C000, 0x00))
{
Or (Local3, 0x02, Local3)
}

\_SB.C002.C003.C005.C00E (Local3, 0x14)
Release (\_SB.C002.C003.C005.C00B)
Return (C000)
}

Name (\C00F, Package (0x10)
{
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"A",
"B",
"C",
"D",
"E",
"F"
})
Method (\C010, 2, NotSerialized)
{
Store (Arg0, Local0)
Store ("", Local7)
Store (Arg1, Local4)
While (LGreater (Local4, 0x00))
{
And (Local0, 0x0F, Local1)
Store (DerefOf (Index (\C00F, Local1)), Local2)
Concatenate (Local2, Local7, Local3)
Store (Local3, Local7)
ShiftRight (Local0, 0x04, Local0)
Decrement (Local4)
}

Return (Local7)
}

Method (\C011, 2, NotSerialized)
{
Store (SizeOf (Arg0), Local7)
If (LNotEqual (Local7, SizeOf (Arg1)))
{
Return (0x00)
}

Name (C012, Buffer (Local7) {})
Name (C013, Buffer (Local7) {})
Store (Arg0, C012)
Store (Arg1, C013)
Store (0x00, Local6)
Store (0x01, Local0)
While (LAnd (LNotEqual (Local6, Local7), Local0))
{
Store (DerefOf (Index (C012, Local6)), Local2)
Store (DerefOf (Index (C013, Local6)), Local3)
Increment (Local6)
If (LNotEqual (Local2, Local3))
{
Store (0x00, Local0)
}
}

Return (Local0)
}

Name (C014, 0xFFFFFFFD)
Name (C015, Package (0x03)
{
"Microsoft Windows",
"Microsoft WindowsME: Millennium Edition",
"Microsoft Windows NT"
})
Method (\C019, 3, NotSerialized)
{
Name (C012, Buffer (0x8C) {})
Name (C013, Buffer (0x8C) {})
Store (Arg0, C012)
Store (Arg1, C013)
Store (0x00, Local6)
Store (0x01, Local0)
While (LAnd (LNotEqual (Local6, Arg2), Local0))
{
Store (DerefOf (Index (C012, Local6)), Local2)
Store (DerefOf (Index (C013, Local6)), Local3)
Increment (Local6)
If (LNotEqual (Local2, Local3))
{
Store (0x00, Local0)
}
}

Return (Local0)
}

Method (C008, 0, Serialized)
{
If (LEqual (C014, 0xFFFFFFFD))
{
Store (\_OS, Local0)
Store (SizeOf (C015), Local7)
Store (0x00, Local1)
While (LAnd (LLess (Local1, Local7), LEqual (C014, 0xFFFFFFFD)))
{
Store (\C011 (Local0, DerefOf (Index (C015, Local1))), Local2)
If (Local2)
{
Add (Local1, 0x01, C014)
}
Else
{
Increment (Local1)
}
}

If (LEqual (C014, 0xFFFFFFFD))
{
Store (0x00, C014)
}

If (LOr (LEqual (C014, 0x00), LEqual (C014, 0x03)))
{
If (CondRefOf (\_OSI, Local0))
{
If (\_OSI ("Windows 2001"))
{
Store (0x04, C014)
}

If (\_OSI ("Windows 2001 SP1"))
{
Store (0x04, C014)
}

If (\_OSI ("Windows 2001 SP2"))
{
Store (0x05, C014)
}

If (\_OSI ("Windows 2006"))
{
Store (0x06, C014)
}
}
}

Store (C014, \_SB.C008)
}

Return (C014)
}

Method (\_SB._INI, 0, NotSerialized)
{
\C008 ()
C01B ()
}

Method (C01C, 2, Serialized)
{
Store (SizeOf (Arg0), Local6)
Store (SizeOf (Arg1), Local7)
If (LEqual (Local6, 0x00))
{
Store (Arg1, Local0)
Return (Local0)
}

If (LEqual (Local7, 0x00))
{
Store (Arg0, Local0)
Return (Local0)
}

Add (Local7, Local6, Local1)
Subtract (Local1, 0x02, Local1)
Store (Buffer (Local1) {}, Local0)
Store (0x00, Local1)
While (LLess (Local1, SizeOf (Arg0)))
{
Store (DerefOf (Index (Arg0, Local1)), Index (Local0, Local1))
Increment (Local1)
}

Subtract (Local1, 0x02, Local1)
Store (0x00, Local2)
While (LLess (Local2, SizeOf (Arg1)))
{
Store (DerefOf (Index (Arg1, Local2)), Index (Local0, Local1))
Increment (Local1)
Increment (Local2)
}

Return (Local0)
}

Scope (\_SB)
{
Method (C01B, 0, Serialized)
{
If (C01D)
{
ISMI (0x47, 0x00, 0x00, 0x00)
}
}

Device (C01E)
{
Name (_HID, EisaId ("PNP0C01"))
Method (_CRS, 0, NotSerialized)
{
Name (C01F, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x000A0000, // Address Length
)
Memory32Fixed (ReadOnly,
0x000F0000, // Address Base
0x00100000, // Address Length
_Y01)
Memory32Fixed (ReadWrite,
0x00100000, // Address Base
0x00F00000, // Address Length
_Y00)
})
CreateDWordField (C01F, \_SB.C01E._CRS._Y00._LEN, C022)
CreateDWordField (C01F, \_SB.C01E._CRS._Y00._BAS, C023)
Subtract (\_SB.C024 (), C023, C022)
CreateDWordField (C01F, \_SB.C01E._CRS._Y01._LEN, C025)
CreateDWordField (C01F, \_SB.C01E._CRS._Y01._BAS, C026)
Store (ShiftLeft (\_SB.C027, 0x04), C026)
Subtract (C023, C026, C025)
Return (C01F)
}
}

Method (C024, 0, NotSerialized)
{
Store (C028, Local0)
Return (Local0)
}

Method (C029, 0, NotSerialized)
{
Store (C02A, Local0)
Return (Local0)
}

Method (C02B, 0, NotSerialized)
{
Add (C02A, 0x1040, Local0)
Return (Local0)
}

Method (C02D, 0, NotSerialized)
{
Add (C02A, 0x00014F14, Local0)
}

Method (C02E, 0, NotSerialized)
{
Add (C029 (), 0x00027EC0, Local0)
Return (Local0)
}

OperationRegion (C02F, SystemMemory, 0x000F8000, 0x2C)
Field (C02F, WordAcc, NoLock, Preserve)
{
C02A, 32,
C030, 16
}

OperationRegion (C031, SystemMemory, C029, 0x1040)
Field (C031, AnyAcc, NoLock, Preserve)
{
C032, 33280
}

OperationRegion (C033, SystemMemory, C02B, 0xD2)
Field (C033, AnyAcc, NoLock, Preserve)
{
C00A, 16,
C034, 16,
C035, 16,
C036, 16,
C037, 16,
C038, 8,
C039, 8,
Offset (0x10),
C03A, 1544
}

OperationRegion (C03B, SystemMemory, C02B, 0x41)
Field (C03B, AnyAcc, NoLock, Preserve)
{
Offset (0x18),
C03C, 8,
C03D, 160,
C03E, 160
}

OperationRegion (C03F, SystemMemory, C02E, 0x0140)
Field (C03F, AnyAcc, NoLock, Preserve)
{
C040, 32,
C041, 4,
C042, 1,
C008, 4,
C043, 5,
C044, 1,
C045, 1,
C046, 3,
C047, 1,
C048, 1,
C049, 1,
C04A, 1,
C04B, 1,
C04C, 1,
C04D, 1,
C04E, 6,
C04F, 32,
C027, 16,
C007, 32,
C01D, 8,
C050, 8,
C051, 8,
C052, 8,
C053, 8,
C054, 8,
Offset (0x1A),
C028, 32,
C055, 8,
C056, 8,
C057, 8,
C058, 8,
C059, 8,
C05A, 8,
C05B, 48,
C05C, 16,
C05D, 160,
C05E, 32,
C05F, 32,
C060, 32,
C061, 32,
C062, 32,
C063, 48,
C064, 48
}

OperationRegion (C066, SystemMemory, C02D, 0x05DA)
Field (C066, AnyAcc, NoLock, Preserve)
{
C067, 8,
C068, 328,
C069, 8,
C06A, 136,
C06B, 640,
C06C, 640,
C06D, 640,
C06E, 640,
C06F, 640,
C070, 640,
C071, 640,
C072, 640,
C073, 640,
C074, 640,
C075, 640,
C076, 640,
C077, 640,
C078, 8,
C079, 128,
C07A, 8,
C07B, 504,
C07C, 504,
C07D, 8,
C07E, 504,
C07F, 504,
C080, 32,
C081, 16
}

Method (C082, 2, Serialized)
{
Store (Arg0, Local0)
If (LEqual (Local0, 0x01))
{
Store (\_SB.C04F, Local1)
Or (Local1, Arg1, Local1)
Store (Local1, \_SB.C04F)
}
Else
{
Store (\_SB.C04F, Local1)
Not (Arg1, Local2)
And (Local1, Local2, Local1)
Store (Local1, \_SB.C04F)
}
}

Device (C002)
{
Name (_HID, EisaId ("PNP0A08"))
Name (_CID, 0x030AD041)
Name (_ADR, 0x00)
Device (C083)
{
Name (_ADR, 0x00010000)
Method (_STA, 0, NotSerialized)
{
Store (0x00, Local0)
If (C084)
{
Store (0x0F, Local0)
}

Return (Local0)
}
}

Device (C085)
{
Name (_ADR, 0x00020000)
Method (_STA, 0, NotSerialized)
{
Store (0x00, Local0)
If (C086)
{
Store (0x0F, Local0)
}

Return (Local0)
}
}

OperationRegion (C087, PCI_Config, 0x54, 0x43)
Field (C087, AnyAcc, NoLock, Preserve)
{
, 1,
C084, 1,
, 1,
C086, 1,
Offset (0x3D),
C088, 48
}

Alias (C088, \_SB.C088)
Scope (\_SB)
{
Name (C089, Package (0x0C)
{
0x4000,
0x4000,
0x4000,
0x4000,
0x4000,
0x4000,
0x4000,
0x4000,
0x4000,
0x4000,
0x4000,
0x4000
})
Method (C08A, 0, NotSerialized)
{
Acquire (C08B, 0xFFFF)
If (LEqual (C08C, 0xFFFFFFFD))
{
Store (0x00, Local0)
Store (Local0, C08C)
Store (Local0, Local2)
Store (C088, Local5)
Store (DerefOf (Index (Local5, Local0)), Local1)
Store (0x000C0000, Local4)
Store (ShiftLeft (C027, 0x04), Local3)
While (LAnd (LLessEqual (Local4, Local3), LLess (C08C, 0x06)))
{
If (LEqual (And (Local1, 0x03), 0x00))
{
If (LEqual (Local2, 0x00))
{
Store (Local4, Index (C08D, C08C))
}

Store (0x01, Local2)
}
Else
{
If (Local2)
{
Subtract (Local4, 0x01, Index (C08E, C08C))
Increment (C08C)
}

Store (0x00, Local2)
}

If (LLess (Local4, Local3))
{
Add (Local4, DerefOf (Index (C089, Local0)), Local4)
ShiftRight (Local1, 0x04, Local1)
If (And (Local0, 0x01))
{
Store (0x01, Local1)
If (LLess (Local4, Local3))
{
ShiftRight (Local0, 0x01, Local6)
Increment (Local6)
Store (DerefOf (Index (Local5, Local6)), Local1)
}
}
}
Else
{
Increment (Local4)
}

Increment (Local0)
}
}

Release (C08B)
}
}

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

Name (C08F, ResourceTemplate ()
{
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
0x0000, // Granularity
0x0000, // Range Minimum
0x00FF, // Range Maximum
0x0000, // Translation Offset
0x0100, // Length
,, )
IO (Decode16,
0x0CF8, // Range Minimum
0x0CF8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000, // Granularity
0x0000, // Range Minimum
0x0CF7, // Range Maximum
0x0000, // Translation Offset
0x0CF8, // Length
,, , TypeStatic)
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000, // Granularity
0x0D00, // Range Minimum
0xFFFF, // Range Maximum
0x0000, // Translation Offset
0xF300, // Length
,, , TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000A0000, // Range Minimum
0x000BFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00020000, // Length
,, , AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x00000000, // Range Minimum
0xFEDFFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00000000, // Length
,, _Y02, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0xFEE01000, // Range Minimum
0xFFFFFFFF, // Range Maximum
0x00000000, // Translation Offset
0x011FEFFF, // Length
,, , AddressRangeMemory, TypeStatic)
})
Scope (\_SB)
{
Name (C08D, Package (0x07) {})
Name (C08E, Package (0x07) {})
Name (C08C, 0xFFFFFFFD)
Mutex (C08B, 0x00)
}

Method (C091, 4, NotSerialized)
{
Store (Arg1, Local2)
Store (Arg3, Local4)
Add (Local4, 0x1A, Local5)
While (LLess (Local4, Local5))
{
Store (DerefOf (Index (C08F, Local4)), Index (Arg0, Local2))
Increment (Local4)
Increment (Local2)
}

Store (Arg1, Local2)
Add (Local2, 0x0A, Local2)
CreateDWordField (Arg0, Local2, C092)
Add (Local2, 0x04, Local2)
CreateDWordField (Arg0, Local2, C093)
Add (Local2, 0x08, Local2)
CreateDWordField (Arg0, Local2, C094)
Store (DerefOf (Index (C08D, Arg2)), C092)
Store (DerefOf (Index (C08E, Arg2)), C093)
Subtract (C093, C092, Local3)
Add (Local3, 0x01, C094)
Add (Local2, 0x04, Local2)
Return (Local2)
}

Method (C095, 0, NotSerialized)
{
Acquire (C08B, 0xFFFF)
Multiply (C08C, 0x1A, Local1)
Add (SizeOf (C08F), Local1, Local2)
Store (Buffer (Local2) {}, Local0)
Store (0x00, Local1)
Store (0x00, Local2)
While (LLess (Local1, SizeOf (C08F)))
{
Store (DerefOf (Index (C08F, Local1)), Index (Local0, Local2))
Increment (Local2)
Increment (Local1)
}

Store (0x00, Local1)
Subtract (Local2, 0x02, Local2)
Subtract (Local2, 0x1A, Local3)
While (LLess (Local1, C08C))
{
Store (C091 (Local0, Local2, Local1, Local3), Local2)
Increment (Local1)
}

CreateWordField (Local0, Local2, C096)
Store (0x79, C096)
Release (C08B)
Return (Local0)
}

Method (_CRS, 0, NotSerialized)
{
CreateDWordField (C08F, \_SB.C002._Y02._MIN, C092)
CreateDWordField (C08F, \_SB.C002._Y02._LEN, C094)
CreateDWordField (C08F, \_SB.C002._Y02._MAX, C093)
Store (C097 (), Local1)
Store (Local1, C092)
Subtract (C093, Local1, Local1)
Add (Local1, 0x01, C094)
Store (C095 (), Local2)
Return (Local2)
}

Method (C097, 0, Serialized)
{
Store (\_SB.C024 (), Local0)
Return (Local0)
}

Name (_S3D, 0x02)
Name (_S4D, 0x03)
Device (C098)
{
Name (_ADR, 0x001E0000)
Name (_PRW, Package (0x02)
{
0x0B,
0x05
})
OperationRegion (C099, SystemMemory, 0xFED90000, 0x4000)
Field (C099, DWordAcc, NoLock, Preserve)
{
Offset (0x3404),
C09A, 2,
, 5,
C09B, 1,
Offset (0x3418),
C09C, 32
}

Method (C09D, 0, Serialized)
{
Store (0x00, Local0)
If (C09B)
{
ShiftLeft (C09A, 0x0C, Local2)
Or (Local2, 0xFED00000, Local0)
}

Return (Local0)
}

Alias (C09D, \_SB.C09D)
Device (C09E)
{
Name (_ADR, 0x00080000)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x80))
}
}
}

Method (C09F, 1, NotSerialized)
{
Store (0x0F, Local0)
If (And (^C098.C09C, Arg0))
{
Store (0x00, Local0)
}

Return (Local0)
}

Device (C0A0)
{
Name (_ADR, 0x001E0002)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x20))
}
}

Device (C0A1)
{
Name (_ADR, 0x001E0003)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x40))
}
}

Device (C003)
{
Name (_ADR, 0x001F0000)
OperationRegion (C0A2, PCI_Config, 0x60, 0xA0)
Field (C0A2, AnyAcc, NoLock, Preserve)
{
C0A3, 8,
C0A4, 8,
C0A5, 8,
C0A6, 8,
Offset (0x08),
C0A7, 8,
C0A8, 8,
C0A9, 8,
C0AA, 8,
Offset (0x20),
C0AB, 3,
, 1,
C0AC, 3,
Offset (0x21),
C0AD, 2,
, 2,
C0AE, 1,
Offset (0x22),
C0AF, 1,
C0B0, 1,
C0B1, 1,
C0B2, 1,
Offset (0x24),
C0B3, 16,
C0B4, 8,
Offset (0x28),
C0B5, 16,
C0B6, 8,
Offset (0x40),
, 7,
C004, 1,
Offset (0x58),
C0B7, 32
}

OperationRegion (C0B8, SystemIO, 0xB2, 0x01)
Field (C0B8, AnyAcc, NoLock, Preserve)
{
C0B9, 8
}

OperationRegion (C0BA, SystemIO, 0x0800, 0x10)
Field (C0BA, ByteAcc, NoLock, Preserve)
{
Offset (0x08),
C0BB, 8
}

OperationRegion (C0BC, SystemIO, 0x1000, 0x43)
Field (C0BC, AnyAcc, NoLock, Preserve)
{
Offset (0x2A),
C0BD, 16,
, 2,
C0BE, 1,
Offset (0x30),
C0BF, 1,
C0C0, 1,
, 2,
C0C1, 1,
Offset (0x34),
, 5,
C0C2, 1,
Offset (0x38),
C0C3, 16,
C0C4, 16,
Offset (0x42),
, 1,
C0C5, 1
}

OperationRegion (C0C6, SystemIO, 0x1060, 0x14)
Field (C0C6, ByteAcc, NoLock, Preserve)
{
C0C7, 9,
Offset (0x04),
, 3,
C0C8, 1,
Offset (0x06),
, 1,
C0C9, 1,
Offset (0x08),
, 11,
C0CA, 1,
Offset (0x12),
C0CB, 10
}

OperationRegion (C0CC, SystemMemory, 0xFFBC0100, 0x01)
Field (C0CC, ByteAcc, NoLock, Preserve)
{
C0CD, 5
}

OperationRegion (C0CE, SystemIO, 0x1100, 0x3C)
Field (C0CE, AnyAcc, NoLock, Preserve)
{
Offset (0x0C),
C0CF, 32,
Offset (0x2C),
C0D0, 32,
Offset (0x38),
C0D1, 16
}

OperationRegion (C0D2, SystemIO, 0x1200, 0x06)
Field (C0D2, ByteAcc, NoLock, Preserve)
{
C0D3, 8,
Offset (0x02),
C0D4, 8,
C0D5, 8,
C0D6, 8,
C0D7, 8
}

Method (C0D8, 3, Serialized)
{
Acquire (\_GL, 0xFFFF)
Store (0x00, Local2)
Store (0xFA, Local0)
While (LAnd (And (C0D3, 0x01), LGreater (Local0, 0x00)))
{
Stall (0x64)
Decrement (Local0)
}

If (Local0)
{
Store (Arg1, C0D5)
Store (Arg0, C0D6)
If (LEqual (And (Arg0, 0x01), 0x00))
{
Store (Arg2, C0D7)
}

Store (0xFF, C0D3)
Store (0x48, C0D4)
Store (0xFA, Local0)
While (LAnd (LEqual (And (C0D3, 0x1E), 0x00), LGreater (Local0,
0x00)))
{
Stall (0x64)
Decrement (Local0)
}

And (C0D3, 0x1C, Local1)
Store (0xFF, C0D3)
If (LAnd (LEqual (Local1, 0x00), And (Arg0, 0x01)))
{
Store (C0D7, Local2)
}
}
Else
{
Store (0x01, Local1)
}

Release (\_GL)
If (And (Arg0, 0x01))
{
ShiftLeft (Local1, 0x08, Local3)
Or (Local3, Local2, Local1)
}

Return (Local1)
}

Name (C0D9, Package (0x08)
{
0x03F8,
0x02F8,
0x0220,
0x0228,
0x0238,
0x02E8,
0x0338,
0x03E8
})
Name (C0DA, Package (0x03)
{
0x0378,
0x0278,
0x03BC
})
Method (C0DB, 3, NotSerialized)
{
Store (0x00, Local1)
Store (Match (Arg0, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
If (LNotEqual (Local0, Ones))
{
ShiftLeft (Local0, Arg2, Local1)
}

Return (Local1)
}

Method (C0DC, 2, Serialized)
{
If (LEqual (Arg0, 0x00))
{
Store (0x00, C0B2)
}
Else
{
If (LEqual (Arg0, 0x01))
{
Store (0x00, C0B1)
}
Else
{
If (LEqual (Arg0, 0x02))
{
Store (0x00, C0AF)
}
Else
{
If (LEqual (Arg0, 0x03))
{
Store (0x00, C0B0)
And (C0B5, 0xFFFFFFFE, C0B5)
}
}
}
}
}

Method (C0DD, 3, Serialized)
{
If (LEqual (Arg0, 0x00))
{
Store (0x00, Local0)
If (LEqual (Arg1, 0x0370))
{
Store (0x01, Local0)
}

Store (Local0, C0AE)
Store (0x01, C0B2)
}
Else
{
If (LEqual (Arg0, 0x01))
{
Store (C0DB (C0DA, Arg1, 0x00), C0AD)
Store (0x01, C0B1)
}
Else
{
If (LEqual (Arg0, 0x02))
{
Store (C0DB (C0D9, Arg1, 0x00), C0AB)
Store (0x01, C0AF)
}
Else
{
If (LEqual (Arg0, 0x03))
{
Store (C0DB (C0D9, Arg1, 0x00), C0AC)
Store (0x01, C0B0)
Store (0x0C, C0B6)
Or (Arg2, 0x01, C0B5)
}
}
}
}
}
}

Device (C0DE)
{
OperationRegion (C0DF, PCI_Config, 0x40, 0x18)
Field (C0DF, AnyAcc, NoLock, Preserve)
{
C0E0, 16,
C0E1, 16,
C0E2, 8,
Offset (0x08),
C0E3, 8,
Offset (0x0A),
C0E4, 16,
Offset (0x14),
C0E5, 32
}

Method (C0E6, 2, Serialized)
{
If (LEqual (Arg0, 0x00))
{
Store (C0E0, Local0)
}
Else
{
Store (C0E1, Local0)
}

If (LEqual (Arg1, 0x00))
{
If (LEqual (And (Local0, 0x09), 0x00))
{
Return (0x0384)
}

If (LEqual (And (Local0, 0x09), 0x08))
{
Return (0x0384)
}

ShiftRight (And (Local0, 0x0300), 0x08, Local1)
ShiftRight (And (Local0, 0x3000), 0x0C, Local2)
Return (Multiply (0x1E, Subtract (0x09, Add (Local1, Local2))
))
}
Else
{
If (LEqual (And (Local0, 0x90), 0x00))
{
Return (0x0384)
}

If (LEqual (And (Local0, 0x90), 0x80))
{
Return (0x0384)
}

If (And (Local0, 0x4000))
{
Store (C0E2, Local0)
If (LEqual (Arg0, 0x01))
{
ShiftRight (Local0, 0x04, Local0)
}

Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Local0, 0x02
), 0x03), And (Local0, 0x03)))))
}
Else
{
ShiftRight (And (Local0, 0x0300), 0x08, Local1)
ShiftRight (And (Local0, 0x3000), 0x0C, Local2)
Return (Multiply (0x1E, Subtract (0x09, Add (Local1, Local2))
))
}
}
}

Name (C0E7, Buffer (0x05)
{
0x70, 0x49, 0x36, 0x27, 0x19
})
Method (C0E8, 2, Serialized)
{
ShiftLeft (0x01, Add (Multiply (Arg0, 0x02), Arg1), Local0)
If (And (C0E3, Local0))
{
Store (C0E5, Local1)
If (And (ShiftRight (Local1, 0x0C), Local0))
{
Return (0x11)
}

Store (And (ShiftRight (C0E4, Add (Multiply (Arg0, 0x08), Multiply (
Arg1, 0x04))), 0x03), Local2)
If (And (Local1, Local0))
{
Add (Local2, 0x02, Local2)
}

Return (DerefOf (Index (C0E7, Local2)))
}

Return (0xFFFFFFFF)
}

Method (C0E9, 1, Serialized)
{
If (LEqual (Arg0, 0x00))
{
Store (C0E0, Local0)
}
Else
{
Store (C0E1, Local0)
}

Store (ShiftRight (C0E3, Multiply (0x02, Arg0)), Local1)
Store (0x00, Local3)
If (And (Local1, 0x01))
{
Or (Local3, 0x01, Local3)
}

If (And (Local1, 0x02))
{
Or (Local3, 0x04, Local3)
}

If (And (Local0, 0x02))
{
Or (Local3, 0x02, Local3)
}

If (And (Local0, 0x20))
{
Or (Local3, 0x08, Local3)
}

Or (Local3, 0x10, Local3)
Return (Local3)
}

Method (C0EA, 5, Serialized)
{
CreateWordField (Arg4, 0x02, C0EB)
CreateWordField (Arg4, 0x04, C0EC)
CreateWordField (Arg4, 0x08, C0ED)
Store (0x0C, Local0)
Store (0x00, Local1)
Store (0x00, Local2)
Store (0x01, Local5)
If (LAnd (And (Arg3, ShiftLeft (0x02, Multiply (Arg1, 0x02)
)), And (C0EB, 0x0800)))
{
Or (Local0, 0x02, Local0)
Store (0x08, Local5)
}

If (LAnd (LLessEqual (Arg2, 0xF0), And (C0EC, 0x02)))
{
Or (And (Local0, 0xFFFFFFF7), 0x01, Local0)
If (LAnd (LLessEqual (Arg2, 0x78), And (C0ED, 0x02)))
{
Store (0x2300, Local1)
Store (0x0B, Local2)
Or (Local5, 0x04, Local5)
}
Else
{
If (LAnd (LLessEqual (Arg2, 0xB4), And (C0ED, 0x01)))
{
Store (0x2100, Local1)
Store (0x09, Local2)
Or (Local5, 0x03, Local5)
}
Else
{
Store (0x0100, Local1)
Store (0x04, Local2)
Or (Local5, 0x02, Local5)
}
}
}

If (LEqual (Arg1, 0x00))
{
Or (Local0, Local1, Local0)
Store (0x40F0, Local4)
}
Else
{
ShiftLeft (Local0, 0x04, Local0)
If (And (Arg3, 0x10))
{
Or (Local0, 0x4000, Local0)
If (LEqual (Arg0, 0x00))
{
Or (And (C0E2, 0xF0), Local2, C0E2)
}
Else
{
Or (And (C0E2, 0x0F), ShiftLeft (Local2, 0x04), C0E2)
}
}

Store (0x3F0F, Local4)
}

Or (Local0, 0x8000, Local0)
If (LEqual (Arg0, 0x00))
{
Or (And (C0E0, Local4), Local0, C0E0)
}
Else
{
Or (And (C0E1, Local4), Local0, C0E1)
}

Return (Local5)
}

Method (C0EE, 5, Serialized)
{
CreateWordField (Arg4, 0x0C, C0EF)
Store (0x00, Local0)
Store (0x00, Local1)
Store (0x00, Local2)
Add (Multiply (Arg0, 0x02), Arg1, Local3)
Store (0x00, Local4)
ShiftLeft (0x1011, Local3, Local5)
If (And (Arg3, ShiftLeft (0x01, Multiply (Arg1, 0x02))
))
{
Store (0x01, Local1)
Store (C0F0 (Arg0, Arg1), Local6)
If (LAnd (LGreaterEqual (Local6, 0x05), LAnd (LLess (Arg2, 0x19),
And (C0EF, 0x20))))
{
Store (0x01, Local0)
Store (0x45, Local2)
ShiftLeft (0x1011, Local3, Local4)
}
Else
{
If (LAnd (LGreaterEqual (Local6, 0x04), LAnd (LLess (Arg2, 0x27),
And (C0EF, 0x10))))
{
Store (0x02, Local0)
Store (0x44, Local2)
ShiftLeft (0x11, Local3, Local4)
}
Else
{
If (LAnd (LGreaterEqual (Local6, 0x03), LAnd (LLess (Arg2, 0x36),
And (C0EF, 0x08))))
{
Store (0x01, Local0)
Store (0x43, Local2)
ShiftLeft (0x11, Local3, Local4)
}
Else
{
If (LAnd (LGreaterEqual (Local6, 0x02), LAnd (LLess (Arg2, 0x49),
And (C0EF, 0x04))))
{
Store (0x02, Local0)
Store (0x42, Local2)
}
Else
{
If (LAnd (LGreaterEqual (Local6, 0x01), LAnd (LLess (Arg2, 0x70),
And (C0EF, 0x02))))
{
Store (0x01, Local0)
Store (0x41, Local2)
}
Else
{
Store (0x00, Local0)
Store (0x40, Local2)
}
}
}
}
}
}

Or (And (C0E3, Not (ShiftLeft (0x01, Local3))),
ShiftLeft (Local1, Local3), C0E3)
Multiply (Local3, 0x04, Local3)
Or (And (C0E4, Not (ShiftLeft (0x03, Local3))),
ShiftLeft (Local0, Local3), C0E4)
Or (And (C0E5, Not (Local5)), Local4, C0E5)
Return (Local2)
}

Method (C0F0, 2, NotSerialized)
{
Store (0x02, Local0)
If (LAnd (LEqual (Arg0, 0x00), LEqual (Arg1, 0x00)))
{
Store (0x05, Local0)
}

Return (Local0)
}
}

Method (C0F1, 1, Serialized)
{
Store (0x01, Local0)
Return (Local0)
}

Device (C0F3)
{
Name (_ADR, 0x001D0000)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x0100))
}

OperationRegion (C0F4, PCI_Config, 0xC4, 0x04)
Field (C0F4, AnyAcc, NoLock, Preserve)
{
C0F5, 1,
C0F6, 1
}

Method (_PSW, 1, NotSerialized)
{
Store (Arg0, Local0)
If (LEqual (Local0, 0x01))
{
Store (C0F1 (0x00), C0F5)
Store (C0F1 (0x01), C0F6)
}
Else
{
Store (0x00, C0F5)
Store (0x00, C0F6)
}
}

Device (C0F7)
{
Name (_ADR, 0x00)
Device (C0F8)
{
Name (_ADR, 0x01)
}

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

Device (C0FA)
{
Name (_ADR, 0x001D0001)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x0200))
}

OperationRegion (C0F4, PCI_Config, 0xC4, 0x04)
Field (C0F4, AnyAcc, NoLock, Preserve)
{
C0F5, 1,
C0F6, 1
}

Method (_PSW, 1, NotSerialized)
{
Store (Arg0, Local0)
If (LEqual (Local0, 0x01))
{
Store (C0F1 (0x02), C0F5)
Store (C0F1 (0x03), C0F6)
}
Else
{
Store (0x00, C0F5)
Store (0x00, C0F6)
}
}

Device (C0F7)
{
Name (_ADR, 0x00)
Device (C0F8)
{
Name (_ADR, 0x01)
}

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

Device (C0FB)
{
Name (_ADR, 0x001D0002)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x0400))
}

OperationRegion (C0F4, PCI_Config, 0xC4, 0x01)
Field (C0F4, AnyAcc, NoLock, Preserve)
{
C0F5, 1,
C0F6, 1
}

Method (_PSW, 1, NotSerialized)
{
Store (Arg0, Local0)
If (LEqual (Local0, 0x01))
{
Store (C0F1 (0x04), C0F5)
Store (C0F1 (0x05), C0F6)
}
Else
{
Store (0x00, C0F5)
Store (0x00, C0F6)
}
}

Device (C0F7)
{
Name (_ADR, 0x00)
Device (C0F8)
{
Name (_ADR, 0x01)
}

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

Device (C0FC)
{
Name (_ADR, 0x001D0003)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x0800))
}

OperationRegion (C0F4, PCI_Config, 0xC4, 0x01)
Field (C0F4, AnyAcc, NoLock, Preserve)
{
C0F5, 1,
C0F6, 1
}

Method (_PSW, 1, NotSerialized)
{
Store (Arg0, Local0)
If (LEqual (Local0, 0x01))
{
Store (C0F1 (0x06), C0F5)
Store (C0F1 (0x07), C0F6)
}
Else
{
Store (0x00, C0F5)
Store (0x00, C0F6)
}
}

Device (C0F7)
{
Name (_ADR, 0x00)
Device (C0F8)
{
Name (_ADR, 0x01)
}

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

Device (C0FD)
{
Name (_ADR, 0x001D0007)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x8000))
}

Device (C0F7)
{
Name (_ADR, 0x00)
Device (C0F8)
{
Name (_ADR, 0x01)
}

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

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

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

Device (C100)
{
Name (_ADR, 0x05)
}

Device (C101)
{
Name (_ADR, 0x06)
}

Device (C102)
{
Name (_ADR, 0x07)
}

Device (C103)
{
Name (_ADR, 0x08)
}
}
}

Device (C104)
{
Name (_ADR, 0x001C0000)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x00010000))
}

OperationRegion (C105, PCI_Config, 0x50, 0x90)
Field (C105, AnyAcc, NoLock, Preserve)
{
, 4,
C106, 1,
Offset (0x0A),
C107, 16,
Offset (0x10),
C108, 16,
C109, 1,
Offset (0x88),
C10A, 32,
, 30,
C10B, 1,
C10C, 1
}

OperationRegion (C10D, SystemMemory, 0xF80E0304, 0x02)
Field (C10D, AnyAcc, NoLock, Preserve)
{
, 15,
C10E, 1
}

Method (_PRT, 0, NotSerialized)
{
If (C10F)
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x10
},

Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x11
},

Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x12
},

Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x13
}
})
}
Else
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
C110,
0x00
},

Package (0x04)
{
0xFFFF,
0x01,
C111,
0x00
},

Package (0x04)
{
0xFFFF,
0x02,
C112,
0x00
},

Package (0x04)
{
0xFFFF,
0x03,
C113,
0x00
}
})
}
}
}

Device (C114)
{
Name (_ADR, 0x001C0001)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x00020000))
}

OperationRegion (C115, PCI_Config, 0x50, 0x90)
Field (C115, AnyAcc, NoLock, Preserve)
{
, 4,
C106, 1,
Offset (0x0A),
C107, 16,
Offset (0x10),
C108, 16,
C109, 1,
Offset (0x88),
C10A, 32,
, 30,
C10B, 1,
C10C, 1
}

OperationRegion (C116, SystemMemory, 0xF80E1304, 0x02)
Field (C116, AnyAcc, NoLock, Preserve)
{
, 15,
C10E, 1
}

Method (_PRT, 0, NotSerialized)
{
If (C10F)
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x11
},

Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x12
},

Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x13
},

Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x10
}
})
}
Else
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
C111,
0x00
},

Package (0x04)
{
0xFFFF,
0x01,
C112,
0x00
},

Package (0x04)
{
0xFFFF,
0x02,
C113,
0x00
},

Package (0x04)
{
0xFFFF,
0x03,
C110,
0x00
}
})
}
}
}

Device (C117)
{
Name (_ADR, 0x001C0002)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x00040000))
}

OperationRegion (C118, PCI_Config, 0x50, 0x90)
Field (C118, AnyAcc, NoLock, Preserve)
{
, 4,
C106, 1,
Offset (0x0A),
C107, 16,
Offset (0x10),
C108, 16,
C109, 1,
Offset (0x88),
C10A, 32,
, 30,
C10B, 1,
C10C, 1
}

OperationRegion (C119, SystemMemory, 0xF80E2304, 0x02)
Field (C119, AnyAcc, NoLock, Preserve)
{
, 15,
C10E, 1
}

Method (_PRT, 0, NotSerialized)
{
If (C10F)
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x12
},

Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x13
},

Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x10
},

Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x11
}
})
}
Else
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
C112,
0x00
},

Package (0x04)
{
0xFFFF,
0x01,
C113,
0x00
},

Package (0x04)
{
0xFFFF,
0x02,
C110,
0x00
},

Package (0x04)
{
0xFFFF,
0x03,
C111,
0x00
}
})
}
}
}

Device (C11A)
{
Name (_ADR, 0x001C0003)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x00080000))
}

OperationRegion (C11B, PCI_Config, 0x50, 0x90)
Field (C11B, AnyAcc, NoLock, Preserve)
{
, 4,
C106, 1,
Offset (0x0A),
C107, 16,
Offset (0x10),
C108, 16,
C109, 1,
Offset (0x88),
C10A, 32,
, 30,
C10B, 1,
C10C, 1
}

OperationRegion (C11C, SystemMemory, 0xF80E3304, 0x02)
Field (C11C, AnyAcc, NoLock, Preserve)
{
, 15,
C10E, 1
}

Method (_PRT, 0, NotSerialized)
{
If (C10F)
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x13
},

Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x10
},

Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x11
},

Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x12
}
})
}
Else
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
C113,
0x00
},

Package (0x04)
{
0xFFFF,
0x01,
C110,
0x00
},

Package (0x04)
{
0xFFFF,
0x02,
C111,
0x00
},

Package (0x04)
{
0xFFFF,
0x03,
C112,
0x00
}
})
}
}
}

Device (C11D)
{
Name (_ADR, 0x001C0004)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x00100000))
}

OperationRegion (C11E, PCI_Config, 0x50, 0x90)
Field (C11E, AnyAcc, NoLock, Preserve)
{
, 4,
C106, 1,
Offset (0x0A),
C107, 16,
Offset (0x10),
C108, 16,
C109, 1,
Offset (0x88),
C10A, 32,
, 30,
C10B, 1,
C10C, 1
}

OperationRegion (C11F, SystemMemory, 0xF80E4304, 0x02)
Field (C11F, AnyAcc, NoLock, Preserve)
{
, 15,
C10E, 1
}

Method (_PRT, 0, NotSerialized)
{
If (C10F)
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x10
},

Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x11
},

Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x12
},

Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x13
}
})
}
Else
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
C110,
0x00
},

Package (0x04)
{
0xFFFF,
0x01,
C111,
0x00
},

Package (0x04)
{
0xFFFF,
0x02,
C112,
0x00
},

Package (0x04)
{
0xFFFF,
0x03,
C113,
0x00
}
})
}
}
}

Device (C120)
{
Name (_ADR, 0x001C0005)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x00200000))
}

OperationRegion (C121, PCI_Config, 0x50, 0x90)
Field (C121, AnyAcc, NoLock, Preserve)
{
, 4,
C106, 1,
Offset (0x0A),
C107, 16,
Offset (0x10),
C108, 16,
C109, 1,
Offset (0x88),
C10A, 32,
, 30,
C10B, 1,
C10C, 1
}

OperationRegion (C122, SystemMemory, 0xF80E5304, 0x02)
Field (C122, AnyAcc, NoLock, Preserve)
{
, 15,
C10E, 1
}

Method (_PRT, 0, NotSerialized)
{
If (C10F)
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x11
},

Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x12
},

Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x13
},

Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x10
}
})
}
Else
{
Return (Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
C111,
0x00
},

Package (0x04)
{
0xFFFF,
0x01,
C112,
0x00
},

Package (0x04)
{
0xFFFF,
0x02,
C113,
0x00
},

Package (0x04)
{
0xFFFF,
0x03,
C110,
0x00
}
})
}
}
}

Device (C123)
{
Name (_ADR, 0x001B0000)
Method (_STA, 0, NotSerialized)
{
Return (C09F (0x10))
}
}

Method (C124, 1, Serialized)
{
Name (C125, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y03)
{}
})
CreateWordField (C125, \_SB.C002.C124._Y03._INT, C127)
Store (0x00, Local1)
Store (Arg0, Local0)
And (Local0, 0x8F, Local0)
If (LLess (Local0, 0x80))
{
And (Local0, 0x0F, Local0)
ShiftLeft (0x01, Local0, Local1)
}

Store (Local1, C127)
Return (C125)
}

Method (C128, 1, Serialized)
{
Store (Arg0, Local0)
And (Local0, 0x80, Local0)
If (LEqual (Local0, 0x00))
{
Store (0x0B, Local0)
}
Else
{
Store (0x09, Local0)
}

Return (Local0)
}

Method (C129, 1, Serialized)
{
Store (Arg0, Local0)
And (Local0, 0xF0, Local0)
Or (Local0, 0x80, Local0)
Return (Local0)
}

Method (C12A, 1, Serialized)
{
CreateWordField (Arg0, 0x01, C12B)
If (LEqual (C12B, 0x00))
{
Store (0x00, Local0)
}
Else
{
FindSetRightBit (C12B, Local0)
Decrement (Local0)
}

Return (Local0)
}

Device (C110)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x60)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0A3))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0A3), ^^C003.C0A3)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0A3)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0A3))
}
}

Device (C111)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x61)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0A4))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0A4), ^^C003.C0A4)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0A4)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0A4))
}
}

Device (C112)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x62)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0A5))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0A5), ^^C003.C0A5)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0A5)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0A5))
}
}

Device (C113)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x63)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0A6))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0A6), ^^C003.C0A6)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0A6)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0A6))
}
}

Device (C12C)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x68)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0A7))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0A7), ^^C003.C0A7)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0A7)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0A7))
}
}

Device (C12D)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x69)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0A8))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0A8), ^^C003.C0A8)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0A8)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0A8))
}
}

Device (C12E)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x6A)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0A9))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0A9), ^^C003.C0A9)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0A9)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0A9))
}
}

Device (C12F)
{
Name (_HID, EisaId ("PNP0C0F"))
Name (_UID, 0x6B)
Method (_STA, 0, NotSerialized)
{
Return (C128 (^^C003.C0AA))
}

Method (_DIS, 0, NotSerialized)
{
Store (C129 (^^C003.C0AA), ^^C003.C0AA)
}

Method (_SRS, 1, NotSerialized)
{
Store (C12A (Arg0), ^^C003.C0AA)
}

Method (_CRS, 0, NotSerialized)
{
Return (C124 (^^C003.C0AA))
}
}

Method (C130, 1, NotSerialized)
{
While (^C003.C0C2)
{
Stall (0x01)
}

Store (0xF3, ^C003.C0B9)
Stall (0x32)
While (^C003.C0C2)
{
Stall (0x01)
}
}

Mutex (C131, 0x00)
Name (C132, 0x00)
Name (C133, 0x00)
Method (C134, 0, NotSerialized)
{
Acquire (C131, 0xFFFF)
If (LEqual (C133, 0x00))
{
Store (0x00, ^C003.C0BF)
Store (0x00, ^C003.C0C0)
}

Increment (C133)
Release (C131)
}

Method (C135, 0, NotSerialized)
{
Acquire (C131, 0xFFFF)
Decrement (C133)
If (LEqual (C133, 0x00))
{
Store (0x01, ^C003.C0C0)
Store (0x01, ^C003.C0BF)
}

Release (C131)
}

Method (\_SB.ISMI, 4, NotSerialized)
{
Acquire (C136, 0xFFFF)
If (Arg3)
{
Acquire (\_GL, 0xFFFF)
}

Store (Arg0, C05E)
Store (Arg1, C05F)
Store (Arg2, C060)
Store (0x00, ^C002.C003.C0BB)
If (Arg3)
{
Release (\_GL)
}

Release (C136)
Return (C05E)
}

Scope (C085)
{
Name (C137, 0x00)
OperationRegion (C138, PCI_Config, 0x2C, 0x04)
Field (C138, DWordAcc, NoLock, Preserve)
{
C139, 32
}

OperationRegion (C13A, PCI_Config, 0x4C, 0x04)
Field (C13A, DWordAcc, NoLock, Preserve)
{
C13B, 32
}

Name (_S3D, 0x03)
Name (_S4D, 0x03)
Method (C13C, 1, Serialized)
{
Store (0x00, Local0)
If (And (C13D (0x00), Arg0))
{
Store (0x01, Local0)
If (And (C057, Arg0))
{
Store (0x1D, Local0)
If (And (C056, Arg0))
{
Store (0x1F, Local0)
}
}
}

Return (Local0)
}

Method (C13F, 1, Serialized)
{
Store (0x00, Local0)
If (And (C058, Arg0))
{
Store (0x01, Local0)
}

Return (Local0)
}

Method (C140, 2, Serialized)
{
Store (C059, Local0)
If (And (Arg1, 0x01))
{
Or (Local0, Arg0, Local0)
}
Else
{
And (Local0, Not (Arg0), Local0)
}

Store (Local0, C059)
If (And (Arg1, 0x40000000))
{
Store (Local0, C056)
}

If (LEqual (And (Arg1, 0xC0000000), 0x80000000))
{
\_SB.C141 (0xEA74, 0x01, 0x00, 0x00, 0x00)
}
}

Method (_DOS, 1, NotSerialized)
{
And (C055, 0xF8, Local0)
And (C055, 0x83, Local1)
Or (Local0, Arg0, C055)
If (CondRefOf (^C142, Local2))
{
^C142 (Arg0, Local1)
}
}

Device (C143)
{
Name (_ADR, 0x0100)
Method (_DCS, 0, NotSerialized)
{
Return (C13C (0x02))
}

Method (_DGS, 0, NotSerialized)
{
Return (C13F (0x02))
}

Method (_DSS, 1, NotSerialized)
{
C140 (0x02, Arg0)
}
}

Device (C144)
{
Name (_ADR, 0x0400)
Method (_DCS, 0, NotSerialized)
{
Return (C13C (0x01))
}

Method (_DGS, 0, NotSerialized)
{
Return (C13F (0x01))
}

Method (_DSS, 1, NotSerialized)
{
C140 (0x01, Arg0)
}

Name (C145, Package (0x0D)
{
0x64,
0x33,
0x1E,
0x25,
0x2C,
0x33,
0x3A,
0x41,
0x48,
0x4F,
0x56,
0x5D,
0x64
})
Method (_BCL, 0, Serialized)
{
Return (C145)
}

Name (C146, 0x64)
Method (_BCM, 1, Serialized)
{
Store (0x00, Local0)
If (LGreater (\C008 (), 0x05))
{
Or (C055, 0x40, C055)
Store (0x01, Local0)
}

Store (Arg0, C146)
Store (Match (C145, MGE, Arg0, MTR, 0x00, 0x02), Local1)
If (Local0)
{
\_SB.C141 (0xEA74, 0x04, Local1, 0x00, 0x00)
}
}

Method (_BCQ, 0, Serialized)
{
Store (C146, Local0)
Return (Local0)
}
}

Device (C147)
{
Name (_ADR, 0x0200)
Method (_DCS, 0, NotSerialized)
{
Return (C13C (0x04))
}

Method (_DGS, 0, NotSerialized)
{
Return (C13F (0x04))
}

Method (_DSS, 1, NotSerialized)
{
C140 (0x04, Arg0)
}
}

Device (C148)
{
Name (_ADR, 0x0300)
Method (_DCS, 0, NotSerialized)
{
Return (C13C (0x08))
}

Method (_DGS, 0, NotSerialized)
{
Return (C13F (0x08))
}

Method (_DSS, 1, NotSerialized)
{
C140 (0x08, Arg0)
}
}

Name (C149, 0xFFFFFFFD)
Method (C13D, 1, Serialized)
{
If (LAnd (Arg0, LEqual (C149, 0xFFFFFFFD)))
{
Store (0x07, Local0)
If (LEqual (And (\_SB.C002.C003.C0D0, 0x80), 0x00))
{
Or (Local0, 0x08, Local0)
}

Store (Local0, C149)
}

Return (C149)
}

Method (_DOD, 0, NotSerialized)
{
Return (Package (0x04)
{
0x00010100,
0x00010400,
0x00010200,
0x00010300
})
}

Method (C142, 2, NotSerialized)
{
If (LNotEqual (Arg0, Arg1))
{
And (\_SB.C002.C003.C0B7, 0xF3FFFFFF, Local0)
If (LEqual (Arg0, 0x00))
{
Or (Local0, 0x04000000, Local0)
}

Store (Local0, \_SB.C002.C003.C0B7)
}
}
}

Method (\C130, 1, NotSerialized)
{
\_SB.C002.C130 (Arg0)
}

Method (\C134, 0, NotSerialized)
{
\_SB.C002.C134 ()
}

Method (\C135, 0, NotSerialized)
{
\_SB.C002.C135 ()
}

Method (C003.C14A, 5, Serialized)
{
If (LEqual (Arg1, 0x00))
{
^C0DC (Arg0, Arg2)
}
Else
{
^C0DD (Arg0, Arg1, Arg2)
}
}

Method (\_SB.C14B, 5, Serialized)
{
^C002.C003.C14A (Arg0, Arg1, Arg2, Arg3, Arg4)
}

Method (\_SB.C14C, 0, NotSerialized)
{
Store (0x01, Local1)
Return (Local1)
}

Scope (C003)
{
Device (C005)
{
Name (_HID, EisaId ("PNP0C09"))
Name (_GPE, 0x16)
Method (_STA, 0, NotSerialized)
{
Return (0x0F)
}

Name (_CRS, ResourceTemplate ()
{
IO (Decode16,
0x0062, // Range Minimum
0x0062, // Range Maximum
0x01, // Alignment
0x01, // Length
)
IO (Decode16,
0x0066, // Range Minimum
0x0066, // Range Maximum
0x01, // Alignment
0x01, // Length
)
})
Mutex (C14D, 0x00)
Name (C14E, 0x00)
Name (C14F, 0x00)
Method (C150, 0, Serialized)
{
C151 (0x07, 0xFF)
Store (C152 (), Local0)
C153 ()
C154 (Local0, 0x81)
C155 ()
}

Method (_REG, 2, NotSerialized)
{
If (LEqual (Arg0, 0x03))
{
Store (Arg1, C14F)
Store (LOr (LEqual (\C008 (), 0x01), LEqual (\C008 (), 0x02)), Local1)
If (LAnd (Arg1, LNot (Local1)))
{
C150 ()
}
}
}

OperationRegion (C156, EmbeddedControl, 0x00, 0xFF)
Field (C156, ByteAcc, NoLock, Preserve)
{
Offset (0x80),
Offset (0x81),
, 4,
C157, 4,
, 1,
, 1,
C158, 1,
, 1,
, 1,
, 1,
, 1,
C159, 1,
C15A, 1,
, 1,
, 1,
, 1,
, 1,
C15B, 1,
C15C, 1,
C15D, 1,
C15E, 1,
C15F, 2,
C160, 1,
C161, 4,
C162, 1,
Offset (0x86),
C163, 4,
Offset (0x87),
C164, 8,
C165, 8,
C166, 16,
Offset (0x8D),
C167, 16,
Offset (0x91),
C168, 1,
Offset (0x92),
C169, 16,
Offset (0x95),
C16A, 16,
C16B, 16,
C16C, 4,
Offset (0x9D),
C16D, 16,
C16E, 16,
C16F, 16,
C170, 16,
C171, 16,
C172, 16,
C173, 16,
C174, 16,
C175, 16,
Offset (0xB1),
C145, 16,
Offset (0xB5),
C176, 8,
Offset (0xB7),
C177, 16,
C178, 8,
Offset (0xBD),
C179, 8,
Offset (0xC1),
C17A, 64,
C17B, 16,
C17C, 16,
C17D, 8,
Offset (0xD1),
C17E, 32,
C17F, 8,
C180, 8,
C181, 8,
C182, 8,
C183, 8,
C184, 8,
C185, 8,
C186, 8,
C187, 4,
C188, 4,
C189, 16,
C18A, 16,
Offset (0xE3),
C18B, 4,
Offset (0xE4),
Offset (0xE5),
C18C, 1,
C18D, 1,
Offset (0xE6),
C18E, 8,
C18F, 1
}

Method (_INI, 0, NotSerialized)
{
If (LOr (LEqual (\C008 (), 0x01), LEqual (\C008 (), 0x02)))
{
C150 ()
}
}

OperationRegion (C190, SystemIO, 0x0500, 0x02)
Field (C190, ByteAcc, NoLock, Preserve)
{
C191, 8,
C192, 8
}

IndexField (C191, C192, ByteAcc, NoLock, Preserve)
{
Offset (0x92),
C193, 8,
Offset (0x9D),
C194, 8
}

Method (C195, 2, NotSerialized)
{
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (Arg1, C17F)
Store (Arg0, C180)
}

Release (C14D)
}

Method (C196, 1, NotSerialized)
{
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (Arg0, C180)
}

Release (C14D)
}

Method (C197, 1, NotSerialized)
{
Store (0x14, Local0)
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (C180, Local0)
}

Release (C14D)
Return (Local0)
}

Method (C198, 1, Serialized)
{
Multiply (Arg0, 0x40, Local1)
Divide (Local1, 0x64, Local2, Local0)
Subtract (0x40, Local0, Local0)
And (C193, 0x80, Local1)
If (LEqual (Local0, 0x40))
{
Or (Local1, 0x01, Local1)
}
Else
{
ShiftLeft (Local0, 0x01, Local0)
Or (Local0, Local1, Local1)
}

Store (Local1, C193)
}

Method (C199, 0, Serialized)
{
And (C193, 0x7F, Local0)
If (And (Local0, 0x01))
{
Store (0x00, Local1)
}
Else
{
ShiftRight (Local0, 0x01, Local0)
Subtract (0x40, Local0, Local0)
Multiply (Local0, 0x64, Local0)
Divide (Add (Local0, 0x20), 0x40, Local2, Local1)
Increment (Local1)
}

Return (Local1)
}

Method (C19A, 0, Serialized)
{
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (C18E, Local0)
}

Release (C14D)
Return (Local0)
}

Method (C19B, 1, Serialized)
{
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (Arg0, C18E)
}

Release (C14D)
}

Method (C19C, 1, Serialized)
{
Store (0x00, Local0)
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (Arg0, C18F)
Store (0x01, Local0)
}

Release (C14D)
\_SB.C13E (Or (0xA100, Or (ShiftLeft (Local0, 0x04), Arg0)
))
Return (Local0)
}

Name (C19D, 0xFF)
Name (C19E, 0xFF)
Name (C19F, 0x07)
Name (C1A0, 0x01)
Name (C1A1, 0x00)
Name (C1A2, 0x00)
Name (C1A3, 0x01)
Name (C1A4, 0x00)
Name (C1A5, 0x05)
Name (C1A6, 0x01)
Mutex (C1A7, 0x00)
Name (C1A8, Package (0x08)
{
"Unknown",
"NiMH",
"LiIon"
})
Method (C1A9, 0, Serialized)
{
Acquire (C1A7, 0xFFFF)
If (And (C19F, 0x01))
{
And (C19F, 0x06, C19F)
Release (C1A7)
Store (0x01, Local0)
Store (0x00, Local1)
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (C15E, Local0)
Store (C15F, Local1)
}

Release (C14D)
Store (Local0, C1A0)
Store (Local1, C1A1)
}
Else
{
Release (C1A7)
}
}

Method (C006, 0, Serialized)
{
C1A9 ()
Return (C1A0)
}

Method (C1AA, 0, Serialized)
{
C1A9 ()
Return (C1A1)
}

Method (C152, 0, Serialized)
{
Acquire (C1A7, 0xFFFF)
If (And (C19F, 0x02))
{
And (C19F, 0x05, C19F)
Release (C1A7)
Acquire (C14D, 0xFFFF)
If (C14F)
{
Store (C161, C1A2)
}