NetBSD Problem Report #41882

From dhgutteridge@sympatico.ca  Wed Aug 12 23:16:19 2009
Return-Path: <dhgutteridge@sympatico.ca>
Received: from mail.netbsd.org (mail.netbsd.org [204.152.190.11])
	by www.NetBSD.org (Postfix) with ESMTP id 91CCC63C284
	for <gnats-bugs@gnats.netbsd.org>; Wed, 12 Aug 2009 23:16:19 +0000 (UTC)
Message-Id: <BLU0-SMTP48CCBD0FC7981B848F5AA1B7040@phx.gbl>
Date: Wed, 12 Aug 2009 19:16:13 -0400
From: "David H. Gutteridge" <dhgutteridge@sympatico.ca>
Reply-To: gutteridge@netbsd.org
To: gnats-bugs@netbsd.org
Subject: ACPI errors encountered on NetBSD 5 on an LG X110

>Number:         41882
>Category:       kern
>Synopsis:       ACPI errors encountered on NetBSD 5 on an LG X110
>Confidential:   no
>Severity:       non-critical
>Priority:       low
>Responsible:    kern-bug-people
>State:          open
>Class:          sw-bug
>Submitter-Id:   net
>Arrival-Date:   Wed Aug 12 23:20:01 +0000 2009
>Last-Modified:  Mon Jan 21 02:30:31 +0000 2019
>Originator:     David H. Gutteridge
>Release:        NetBSD 5.0_STABLE
>Organization:

>Environment:
 NetBSD arcusvii.nonus-porta.net 5.0_STABLE NetBSD 5.0_STABLE  
 (ARCUSVII) #0: Sun Jul 26 19:04:57 EDT 2009  disciple@arcusvii.nonus- 
 porta.net:/home/disciple/netbsd-5/usr/src/sys/arch/i386/compile/obj/ 
 ARCUSVII i386
 Architecture: i386
 Machine: i386

>Description:
 Hello,

 I'm seeing ACPI errors reported when I boot a 5.0-ish kernel with ACPI
 enabled on my LG X110 netbook (one of many incarnations of the MSI
 Wind).  Also, ACPI-related functions like screen brightness don't work,
 which I understood from previous inquiries is to be expected.

 Here's the relevant excerpt from the dmesg:

 NetBSD 5.0_STABLE (ARCUSVII) #0: Sun Jul 26 19:04:57 EDT 2009
 	disciple@arcusvii.nonus-porta.net:/home/disciple/netbsd-5/usr/src/ 
 sys/arch/i386/compile/obj/ARCUSVII
 total memory = 1013 MB
 avail memory = 984 MB
 timecounter: Timecounters tick every 10.000 msec
 timecounter: Timecounter "i8254" frequency 1193182 Hz quality 100
 LG Electronics X110-L.A7B1A9 (Ver.001)
 mainbus0 (root)
 cpu0 at mainbus0 apid 0: Intel 686-class, 1600MHz, id 0x106c2
 cpu0: Enhanced SpeedStep (1324 mV) 1600 MHz
 cpu0: Enhanced SpeedStep frequencies available (MHz): 1600 1467 1333  
 1200 1067 933 800
 cpu1 at mainbus0 apid 1: Intel 686-class, 1600MHz, id 0x106c2
 ioapic0 at mainbus0 apid 2: pa 0xfec00000, version 20, 24 pins
 acpi0 at mainbus0: Intel ACPICA 20080321
 acpi0: X/RSDT: OemId <   LGE,    LGPC,06222004>, AslId <MSFT,00010013>
 ACPI Error (evregion-0427): No handler for Region [EC__] (0xc1f02840)  
 [EmbeddedControl] [20080321]
 ACPI Error (exfldio-0390): Region EmbeddedControl(3) has no handler  
 [20080321]
 ACPI Error (psparse-0627): Method parse/execution failed  
 [\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
 ACPI Error (uteval-0306): Method execution failed  
 [\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
 acpi0: SCI interrupting at int 9
 acpi0: fixed-feature power button present
 timecounter: Timecounter "ACPI-Safe" frequency 3579545 Hz quality 900
 ACPI-Safe 24-bit timer
 ACPI Error (evregion-0427): No handler for Region [EC__] (0xc1f02840)  
 [EmbeddedControl] [20080321]
 ACPI Error (exfldio-0390): Region EmbeddedControl(3) has no handler  
 [20080321]
 ACPI Error (psparse-0627): Method parse/execution failed  
 [\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
 ACPI Error (uteval-0306): Method execution failed  
 [\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
 pcppi1 at acpi0 (SPKR, PNP0800): io 0x61
 midi0 at pcppi1: PC speaker (CPU-intensive output)
 sysbeep0 at pcppi1
 attimer1 at acpi0 (TMR, PNP0100): io 0x40-0x43 irq 0
 npx1 at acpi0 (COPR, PNP0C04): io 0xf0-0xff irq 13
 npx1: reported by CPUID; using exception 16
 pckbc1 at acpi0 (PS2K, PNP0303) (kbd port): io 0x60,0x64 irq 1
 pckbc2 at acpi0 (PS2M, PNP0F03) (aux port): irq 12
 acpiec0 at acpi0 (EC, PNP0C09): io 0x62,0x66
 acpiacad0 at acpi0 (ADP1, ACPI0003): ACPI AC Adapter
 acpibat0 at acpi0 (BAT1, PNP0C0A-1): ACPI Battery (Control Method)
 acpibat0: battery info: MSI Corp.
 , LION
 , MS-N021


 acpilid0 at acpi0 (LID0, PNP0C0D): ACPI Lid Switch
 SCM0 (pnp0c14) at acpi0 not configured
 hpet0 at acpi0 (HPET, PNP0103): mem 0xfed03000-0xfed033ff
 timecounter: Timecounter "hpet0" frequency 14318179 Hz quality 2000
 acpibut0 at acpi0 (PWRB, PNP0C0C): ACPI Power Button
 acpibut1 at acpi0 (SLPB, PNP0C0E): ACPI Sleep Button
 acpitz0 at acpi0 (THRM): critical 100.0C, passive cooling
 apm0 at acpi0: Power Management spec V1.2
 attimer1: attached to pcppi1

 Here is the ASL generated from acpidump(8), if this is of any use:

 /*
 RSD PTR: Checksum=72, OEMID=LGE, RsdtAddress=0x3f610f10
   */
 /*
 RSDT: Length=56, Revision=1, Checksum=230,
 	OEMID=LGE, OEM Table ID=LGPC, OEM Revision=0x6222004,
 	Creator ID=MSFT, Creator Revision=0x10013
   */
 /*
 	Entries={ 0x3f611910, 0x3f610e90, 0x3f605510, 0x3f5e8a10, 0x3f611a10 }
   */
 /*
 	DSDT=0x3f608010
 	INT_MODEL=APIC
 	SCI_INT=9
 	SMI_CMD=0xb2, ACPI_ENABLE=0xa0, ACPI_DISABLE=0xa1, S4BIOS_REQ=0x0
 	PM1a_EVT_BLK=0x400-0x403
 	PM1a_CNT_BLK=0x404-0x405
 	PM2_CNT_BLK=0x420-0x420
 	PM2_TMR_BLK=0x408-0x40b
 	PM2_GPE0_BLK=0x428-0x42f
 	P_LVL2_LAT=1ms, P_LVL3_LAT=57ms
 	FLUSH_SIZE=1024, FLUSH_STRIDE=16
 	DUTY_OFFSET=1, DUTY_WIDTH=3
 	DAY_ALRM=125, MON_ALRM=126, CENTURY=50
 	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4}
   */
 /*
 DSDT: Length=22450, Revision=1, Checksum=42,
 	OEMID=LGE, OEM Table ID=LGPC, OEM Revision=0x0,
 	Creator ID=INTL, Creator Revision=0x20051117
   */
 DefinitionBlock ("acpi_dst.aml", "DSDT", 0x1, "LGE", "LGPC", 0x0)
 {
 Name(SP1O, 0x2e)
 Name(IOCE, 0x00)
 Name(IOCL, 0x00)
 Name(IO1B, 0x0a20)
 Name(IO1L, 0x20)
 Name(IOEC, 0x0a10)
 Name(IO4L, 0x80)
 Name(IO5L, 0x80)
 Name(IO2B, 0x0a00)
 Name(IO2L, 0x20)
 Name(IOPM, 0x0a00)
 Name(IO3B, 0x00)
 Name(IO3L, 0x10)
 Name(SI1P, 0x00)
 Name(MCHB, 0xfed14000)
 Name(MCHL, 0x4000)
 Name(EGPB, 0xfed19000)
 Name(EGPL, 0x1000)
 Name(DMIB, 0xfed18000)
 Name(DMIL, 0x1000)
 Name(PEBS, 0xe0000000)
 Name(PELN, 0x10000000)
 Name(LAPB, 0xfee00000)
 Name(SMBS, 0x1180)
 Name(SMBL, 0x20)
 Name(PMBS, 0x0400)
 Name(PMLN, 0x80)
 Name(SMIP, 0xb2)
 Name(GPBS, 0x0500)
 Name(GPLN, 0x40)
 Name(APCB, 0xfec00000)
 Name(APCL, 0x1000)
 Name(PM30, 0x0430)
 Name(SRCB, 0xfed20000)
 Name(SRCL, 0x4000)
 Name(SUSW, 0xff)
 Name(HPTB, 0xfed00000)
 Name(HPTC, 0xfed23404)
 Name(ACPH, 0xde)
 Name(ASSB, 0x00)
 Name(AOTB, 0x00)
 Name(AAXB, 0x00)
 Name(PEHP, 0x01)
 Name(SHPC, 0x00)
 Name(PEPM, 0x01)
 Name(PEER, 0x01)
 Name(PECS, 0x01)
 Name(ITKE, 0x00)
 Name(CMOS, 0x60)
 Method(RRIO, 4) {
      Store("RRIO", Debug)
 }
 Method(RDMA, 3) {
      Store("rDMA", Debug)
 }
 Name(PICM, 0x00)
 Method(_PIC, 1) {
      If(Arg0) {
          Store(0xaa, DBG8)
      }
      Else {
          Store(0xac, DBG8)
      }
      Store(Arg0, PICM)
 }
 Name(OSVR, Ones)
 Method(OSFL) {
      If(LNot(LEqual(OSVR, Ones))) {
          Return(OSVR)
      }
      If(LEqual(PICM, 0x00)) {
          Store(0xac, DBG8)
      }
      Store(0x01, OSVR)
      If(CondRefOf(\_OSI, Local0)) {
          If(\_OSI("Linux")) {
              Store(0x03, OSVR)
          }
          Else {
              If(\_OSI("Windows\x202001")) {
                  Store(0x04, OSVR)
              }
              Else {
                  If(\_OSI("Windows\x202001.1")) {
                      Store(0x05, OSVR)
                  }
                  Else {
                      If(\_OSI("FreeBSD")) {
                          Store(0x06, OSVR)
                      }
                      Else {
                          If(\_OSI("HP\x2dUX")) {
                              Store(0x07, OSVR)
                          }
                          Else {
                              If(\_OSI("OpenVMS")) {
                                  Store(0x08, OSVR)
                              }
                          }
                      }
                  }
              }
          }
      }
      Else {
          If(MCTH(\_OS, "Microsoft\x20Windows\x20NT")) {
              Store(0x00, OSVR)
          }
          Else {
              If(MCTH(\_OS, "Microsoft\x20Windows")) {
                  Store(0x01, OSVR)
              }
              Else {
                  If(MCTH(\_OS, "Microsoft\x20WindowsME\x3a 
 \x20Millennium\x20Edition")) {
                      Store(0x02, OSVR)
                  }
                  Else {
                      If(MCTH(\_OS, "Linux")) {
                          Store(0x03, OSVR)
                      }
                      Else {
                          If(MCTH(\_OS, "FreeBSD")) {
                              Store(0x06, OSVR)
                          }
                          Else {
                              If(MCTH(\_OS, "HP\x2dUX")) {
                                  Store(0x07, OSVR)
                              }
                              Else {
                                  If(MCTH(\_OS, "OpenVMS")) {
                                      Store(0x08, OSVR)
                                  }
                              }
                          }
                      }
                  }
              }
          }
      }
      Return(OSVR)
 }
 Method(MCTH, 2) {
      If(LLess(SizeOf(Arg0), SizeOf(Arg1))) {
          Return(Zero)
      }
      Add(SizeOf(Arg0), 0x01, Local0)
      Name(BUF0, Buffer(Local0) { })
      Name(BUF1, Buffer(Local0) { })
      Store(Arg0, BUF0)
      Store(Arg1, BUF1)
      While(Local0) {
          Decrement(Local0)
          If(LNot(LEqual(DerefOf(Index(BUF0, Local0, )), DerefOf(Index 
 (BUF1, Local0, ))))) {
              Return(Zero)
          }
      }
      Return(One)
 }
 Name(PRWP, Package(0x02) {
      Zero,
      Zero,
 })
 Method(GPRW, 2) {
      Store(Arg0, Index(PRWP, 0x00, ))
      Store(ShiftLeft(SS1, 0x01, ), Local0)
      Or(Local0, ShiftLeft(SS2, 0x02, ), Local0)
      Or(Local0, ShiftLeft(SS3, 0x03, ), Local0)
      Or(Local0, ShiftLeft(SS4, 0x04, ), Local0)
      If(And(ShiftLeft(0x01, Arg1, ), Local0, )) {
          Store(Arg1, Index(PRWP, 0x01, ))
      }
      Else {
          ShiftRight(Local0, 0x01, Local0)
          If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
              FindSetLeftBit(Local0, Index(PRWP, 0x01, ))
          }
          Else {
              FindSetRightBit(Local0, Index(PRWP, 0x01, ))
          }
      }
      Return(PRWP)
 }
 Name(WAKP, Package(0x02) {
      Zero,
      Zero,
 })
 OperationRegion(DEB0, SystemIO, 0x80, 0x01)
 Field(DEB0, ByteAcc, NoLock, Preserve) {
      DBG8,	8
 }
 OperationRegion(DEB1, SystemIO, 0x90, 0x02)
 Field(DEB1, WordAcc, NoLock, Preserve) {
      DBG9,	16
 }
 Name(SS1, 0x01)
 Name(SS2, 0x00)
 Name(SS3, 0x01)
 Name(SS4, 0x01)
 Name(IOST, 0x4400)
 Name(TOPM, 0x3fffffff)
 Name(ROMS, 0xffe00000)
 Name(MG1B, 0x000c0000)
 Name(MG1L, 0x00040000)
 Name(MG2B, 0x40000000)
 Name(MG2L, 0xbff00000)
 Scope(\_SB) {
      Name(PR00, Package(0x12) {
          Package(0x04) {
              0x0001ffff,
              0x00,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0x0001ffff,
              0x01,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0x0001ffff,
              0x02,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0x0001ffff,
              0x03,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0x001fffff,
              0x00,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0x001fffff,
              0x01,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0x001dffff,
              0x00,
              LNKH,
              0x00,
          },
          Package(0x04) {
              0x001dffff,
              0x01,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0x001dffff,
              0x02,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0x001dffff,
              0x03,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0x001effff,
              0x00,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0x001effff,
              0x01,
              LNKE,
              0x00,
          },
          Package(0x04) {
              0x001bffff,
              0x00,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0x001cffff,
              0x00,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0x001cffff,
              0x01,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0x001cffff,
              0x02,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0x001cffff,
              0x03,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0x0002ffff,
              0x00,
              LNKA,
              0x00,
          },
      })
      Name(AR00, Package(0x12) {
          Package(0x04) {
              0x0001ffff,
              0x00,
              0x00,
              0x10,
          },
          Package(0x04) {
              0x0001ffff,
              0x01,
              0x00,
              0x11,
          },
          Package(0x04) {
              0x0001ffff,
              0x02,
              0x00,
              0x12,
          },
          Package(0x04) {
              0x0001ffff,
              0x03,
              0x00,
              0x13,
          },
          Package(0x04) {
              0x001fffff,
              0x00,
              0x00,
              0x12,
          },
          Package(0x04) {
              0x001fffff,
              0x01,
              0x00,
              0x13,
          },
          Package(0x04) {
              0x001dffff,
              0x00,
              0x00,
              0x17,
          },
          Package(0x04) {
              0x001dffff,
              0x01,
              0x00,
              0x13,
          },
          Package(0x04) {
              0x001dffff,
              0x02,
              0x00,
              0x12,
          },
          Package(0x04) {
              0x001dffff,
              0x03,
              0x00,
              0x10,
          },
          Package(0x04) {
              0x001effff,
              0x00,
              0x00,
              0x11,
          },
          Package(0x04) {
              0x001effff,
              0x01,
              0x00,
              0x14,
          },
          Package(0x04) {
              0x001bffff,
              0x00,
              0x00,
              0x10,
          },
          Package(0x04) {
              0x001cffff,
              0x00,
              0x00,
              0x10,
          },
          Package(0x04) {
              0x001cffff,
              0x01,
              0x00,
              0x11,
          },
          Package(0x04) {
              0x001cffff,
              0x02,
              0x00,
              0x12,
          },
          Package(0x04) {
              0x001cffff,
              0x03,
              0x00,
              0x13,
          },
          Package(0x04) {
              0x0002ffff,
              0x00,
              0x00,
              0x10,
          },
      })
      Name(PR02, Package(0x04) {
          Package(0x04) {
              0xffff,
              0x00,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x01,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x02,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x03,
              LNKD,
              0x00,
          },
      })
      Name(AR02, 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,
          },
      })
      Name(PR04, Package(0x04) {
          Package(0x04) {
              0xffff,
              0x00,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x01,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x02,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x03,
              LNKD,
              0x00,
          },
      })
      Name(AR04, 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,
          },
      })
      Name(PR05, Package(0x04) {
          Package(0x04) {
              0xffff,
              0x00,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x01,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x02,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x03,
              LNKA,
              0x00,
          },
      })
      Name(AR05, 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,
          },
      })
      Name(PR06, Package(0x04) {
          Package(0x04) {
              0xffff,
              0x00,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x01,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x02,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x03,
              LNKB,
              0x00,
          },
      })
      Name(AR06, 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,
          },
      })
      Name(PR07, Package(0x04) {
          Package(0x04) {
              0xffff,
              0x00,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x01,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x02,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x03,
              LNKC,
              0x00,
          },
      })
      Name(AR07, 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,
          },
      })
      Name(PR08, Package(0x04) {
          Package(0x04) {
              0xffff,
              0x00,
              LNKA,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x01,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x02,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x03,
              LNKD,
              0x00,
          },
      })
      Name(AR08, 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,
          },
      })
      Name(PR09, Package(0x04) {
          Package(0x04) {
              0xffff,
              0x00,
              LNKB,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x01,
              LNKC,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x02,
              LNKD,
              0x00,
          },
          Package(0x04) {
              0xffff,
              0x03,
              LNKA,
              0x00,
          },
      })
      Name(AR09, 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,
          },
      })
      Name(PRSA, Buffer(0x06) {0x23, 0xf8, 0xdc, 0x18, 0x79, 0x0 })
      Alias(PRSA, PRSB)
      Alias(PRSA, PRSC)
      Alias(PRSA, PRSD)
      Alias(PRSA, PRSE)
      Alias(PRSA, PRSF)
      Alias(PRSA, PRSG)
      Alias(PRSA, PRSH)
      Device(PCI0) {
          Name(_HID, 0x080ad041)
          Name(_CID, 0x030ad041)
          Name(_ADR, 0x00)
          Method(^BN00) {
              Return(0x00)
          }
          Method(_BBN) {
              Return(BN00())
          }
          Name(_UID, 0x00)
          Method(_PRT) {
              If(PICM) {
                  Return(AR00)
              }
              Return(PR00)
          }
          Method(_S3D) {
              If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
                  Return(0x02)
              }
              Else {
                  Return(0x03)
              }
          }
          Scope(\_SB) {
              Scope(PCI0) {
                  Device(MCH) {
                      Name(_HID, 0x010cd041)
                      Name(_UID, 0x03b1)
                      Name(_STA, 0x0f)
                      Name(MCHR, Buffer(0x32) {0x86, 0x9, 0x0, 0x1,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                      Method(_CRS) {
                          CreateDWordField(MCHR, 0x08, ML)
                          CreateDWordField(MCHR, 0x04, MB)
                          Store(\MCHB, MB)
                          Store(\MCHL, ML)
                          CreateDWordField(MCHR, 0x14, EL)
                          CreateDWordField(MCHR, 0x10, EB)
                          Store(\EGPB, EB)
                          Store(\EGPL, EL)
                          CreateDWordField(MCHR, 0x20, DL)
                          CreateDWordField(MCHR, 0x1c, DB)
                          Store(\DMIB, DB)
                          Store(\DMIL, DL)
                          CreateDWordField(MCHR, 0x2c, PL)
                          CreateDWordField(MCHR, 0x28, PB)
                          Store(\PEBS, PB)
                          Store(\PELN, PL)
                          Return(MCHR)
                      }
                  }
              }
          }
          Method(NPTS, 1) {
          }
          Method(NWAK, 1) {
          }
          Device(P0P2) {
              Name(_ADR, 0x00010000)
              Method(_PRW) {
                  Return(GPRW(0x09, 0x04))
              }
              Method(_PRT) {
                  If(PICM) {
                      Return(AR02)
                  }
                  Return(PR02)
              }
              Device(PEGP) {
                  Name(_ADR, 0xffff)
                  Method(_PRW) {
                      Return(GPRW(0x09, 0x04))
                  }
              }
          }
          Device(IDE0) {
              Name(_ADR, 0x001f0001)
              Name(\_SB.PCI0.NATA, Package(0x01) {
                  0x001f0001,
              })
              Name(REGF, 0x01)
              Method(_REG, 2) {
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, REGF)
                  }
              }
              Name(TIM0, Package(0x08) {
                  Package(0x04) {
                      0x78,
                      0xb4,
                      0xf0,
                      0x0384,
                  },
                  Package(0x04) {
                      0x23,
                      0x21,
                      0x10,
                      0x00,
                  },
                  Package(0x04) {
                      0x0b,
                      0x09,
                      0x04,
                      0x00,
                  },
                  Package(0x06) {
                      0x70,
                      0x49,
                      0x36,
                      0x27,
                      0x19,
                      0x0f,
                  },
                  Package(0x06) {
                      0x00,
                      0x01,
                      0x02,
                      0x01,
                      0x02,
                      0x01,
                  },
                  Package(0x06) {
                      0x00,
                      0x00,
                      0x00,
                      0x01,
                      0x01,
                      0x01,
                  },
                  Package(0x04) {
                      0x04,
                      0x03,
                      0x02,
                      0x00,
                  },
                  Package(0x04) {
                      0x02,
                      0x01,
                      0x00,
                      0x00,
                  },
              })
              Name(TMD0, Buffer(0x14) { })
              CreateDWordField(TMD0, 0x00, PIO0)
              CreateDWordField(TMD0, 0x04, DMA0)
              CreateDWordField(TMD0, 0x08, PIO1)
              CreateDWordField(TMD0, 0x0c, DMA1)
              CreateDWordField(TMD0, 0x10, CHNF)
              OperationRegion(CFG2, PCI_Config, 0x40, 0x20)
              Field(CFG2, DWordAcc, NoLock, Preserve) {
                  PMPT,	4,
                  PSPT,	4,
                  PMRI,	6,
                  Offset(0x2),
                  SMPT,	4,
                  SSPT,	4,
                  SMRI,	6,
                  Offset(0x4),
                  PSRI,	4,
                  SSRI,	4,
                  Offset(0x8),
                  PM3E,	1,
                  PS3E,	1,
                  SM3E,	1,
                  SS3E,	1,
                  Offset(0xa),
                  PMUT,	2,
                  ,	2,
                  PSUT,	2,
                  Offset(0xb),
                  SMUT,	2,
                  ,	2,
                  SSUT,	2,
                  Offset(0xc),
                  Offset(0x14),
                  PM6E,	1,
                  PS6E,	1,
                  SM6E,	1,
                  SS6E,	1,
                  PMCR,	1,
                  PSCR,	1,
                  SMCR,	1,
                  SSCR,	1,
                  ,	4,
                  PMAE,	1,
                  PSAE,	1,
                  SMAE,	1,
                  SSAE,	1
              }
              Name(GMPT, 0x00)
              Name(GMUE, 0x00)
              Name(GMUT, 0x00)
              Name(GMCR, 0x00)
              Name(GSPT, 0x00)
              Name(GSUE, 0x00)
              Name(GSUT, 0x00)
              Name(GSCR, 0x00)
              Device(CHN0) {
                  Name(_ADR, 0x00)
                  Method(_GTM) {
                      ShiftLeft(PSCR, 0x01, Local1)
                      Or(PMCR, Local1, Local0)
                      ShiftLeft(PMAE, 0x02, Local3)
                      ShiftLeft(PM6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(PM3E, Local3, Local1)
                      ShiftLeft(PMPT, 0x04, Local3)
                      Or(Local1, Local3, Local1)
                      ShiftLeft(PSAE, 0x02, Local3)
                      ShiftLeft(PS6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(PS3E, Local3, Local2)
                      ShiftLeft(PSPT, 0x04, Local3)
                      Or(Local2, Local3, Local2)
                      Return(GTM(PMRI, Local1, PMUT, PSRI, Local2,  
 PSUT, Local0))
                  }
                  Method(_STM, 3) {
                      Store(Arg0, Debug)
                      Store(Arg0, TMD0)
                      ShiftLeft(PMAE, 0x02, Local3)
                      ShiftLeft(PM6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(PM3E, Local3, Local0)
                      ShiftLeft(PMPT, 0x04, Local3)
                      Or(Local0, Local3, Local0)
                      ShiftLeft(PSAE, 0x02, Local3)
                      ShiftLeft(PS6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(PS3E, Local3, Local1)
                      ShiftLeft(PSPT, 0x04, Local3)
                      Or(Local1, Local3, Local1)
                      Store(PMRI, GMPT)
                      Store(Local0, GMUE)
                      Store(PMUT, GMUT)
                      Store(PMCR, GMCR)
                      Store(PSRI, GSPT)
                      Store(Local1, GSUE)
                      Store(PSUT, GSUT)
                      Store(PSCR, GSCR)
                      STM()
                      Store(GMPT, PMRI)
                      Store(GMUE, Local0)
                      Store(GMUT, PMUT)
                      Store(GMCR, PMCR)
                      Store(GSUE, Local1)
                      Store(GSUT, PSUT)
                      Store(GSCR, PSCR)
                      If(And(Local0, 0x01, )) {
                          Store(0x01, PM3E)
                      }
                      Else {
                          Store(0x00, PM3E)
                      }
                      If(And(Local0, 0x02, )) {
                          Store(0x01, PM6E)
                      }
                      Else {
                          Store(0x00, PM6E)
                      }
                      If(And(Local0, 0x04, )) {
                          Store(0x01, PMAE)
                      }
                      Else {
                          Store(0x00, PMAE)
                      }
                      If(And(Local1, 0x01, )) {
                          Store(0x01, PS3E)
                      }
                      Else {
                          Store(0x00, PS3E)
                      }
                      If(And(Local1, 0x02, )) {
                          Store(0x01, PS6E)
                      }
                      Else {
                          Store(0x00, PS6E)
                      }
                      If(And(Local1, 0x04, )) {
                          Store(0x01, PSAE)
                      }
                      Else {
                          Store(0x00, PSAE)
                      }
                      Store(GTF(0x00, Arg1), ATA0)
                      Store(GTF(0x01, Arg2), ATA1)
                  }
                  Device(DRV0) {
                      Name(_ADR, 0x00)
                      Method(_GTF) {
                          Return(RATA(ATA0))
                      }
                  }
                  Device(DRV1) {
                      Name(_ADR, 0x01)
                      Method(_GTF) {
                          Return(RATA(ATA1))
                      }
                  }
              }
              Device(CHN1) {
                  Name(_ADR, 0x01)
                  Method(_GTM) {
                      ShiftLeft(SSCR, 0x01, Local1)
                      Or(SMCR, Local1, Local0)
                      ShiftLeft(SMAE, 0x02, Local3)
                      ShiftLeft(SM6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(SM3E, Local3, Local1)
                      ShiftLeft(SMPT, 0x04, Local3)
                      Or(Local1, Local3, Local1)
                      ShiftLeft(SSAE, 0x02, Local3)
                      ShiftLeft(SS6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(SS3E, Local3, Local2)
                      ShiftLeft(SSPT, 0x04, Local3)
                      Or(Local2, Local3, Local2)
                      Return(GTM(SMRI, Local1, SMUT, SSRI, Local2,  
 SSUT, Local0))
                  }
                  Method(_STM, 3) {
                      Store(Arg0, Debug)
                      Store(Arg0, TMD0)
                      ShiftLeft(SMAE, 0x02, Local3)
                      ShiftLeft(SM6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(SM3E, Local3, Local0)
                      ShiftLeft(SMPT, 0x04, Local3)
                      Or(Local0, Local3, Local0)
                      ShiftLeft(SSAE, 0x02, Local3)
                      ShiftLeft(SS6E, 0x01, Local4)
                      Or(Local3, Local4, Local3)
                      Or(SS3E, Local3, Local1)
                      ShiftLeft(SSPT, 0x04, Local3)
                      Or(Local1, Local3, Local1)
                      Store(SMRI, GMPT)
                      Store(Local0, GMUE)
                      Store(SMUT, GMUT)
                      Store(SMCR, GMCR)
                      Store(SSRI, GSPT)
                      Store(Local1, GSUE)
                      Store(SSUT, GSUT)
                      Store(SSCR, GSCR)
                      STM()
                      Store(GMPT, SMRI)
                      Store(GMUE, Local0)
                      Store(GMUT, SMUT)
                      Store(GMCR, SMCR)
                      Store(GSUE, Local1)
                      Store(GSUT, SSUT)
                      Store(GSCR, SSCR)
                      If(And(Local0, 0x01, )) {
                          Store(0x01, SM3E)
                      }
                      Else {
                          Store(0x00, SM3E)
                      }
                      If(And(Local0, 0x02, )) {
                          Store(0x01, SM6E)
                      }
                      Else {
                          Store(0x00, SM6E)
                      }
                      If(And(Local0, 0x04, )) {
                          Store(0x01, SMAE)
                      }
                      Else {
                          Store(0x00, SMAE)
                      }
                      If(And(Local1, 0x01, )) {
                          Store(0x01, SS3E)
                      }
                      Else {
                          Store(0x00, SS3E)
                      }
                      If(And(Local1, 0x02, )) {
                          Store(0x01, SS6E)
                      }
                      Else {
                          Store(0x00, SS6E)
                      }
                      If(And(Local1, 0x04, )) {
                          Store(0x01, SSAE)
                      }
                      Else {
                          Store(0x00, SSAE)
                      }
                      Store(GTF(0x00, Arg1), ATA2)
                      Store(GTF(0x01, Arg2), ATA3)
                  }
                  Device(DRV0) {
                      Name(_ADR, 0x00)
                      Method(_GTF) {
                          Return(RATA(ATA2))
                      }
                  }
                  Device(DRV1) {
                      Name(_ADR, 0x01)
                      Method(_GTF) {
                          Return(RATA(ATA3))
                      }
                  }
              }
              Method(GTM, 7, Serialized) {
                  Store(Ones, PIO0)
                  Store(Ones, PIO1)
                  Store(Ones, DMA0)
                  Store(Ones, DMA1)
                  Store(0x10, CHNF)
                  If(REGF) {
                  }
                  Else {
                      Return(TMD0)
                  }
                  If(And(Arg1, 0x20, )) {
                      Or(CHNF, 0x02, CHNF)
                  }
                  Store(Match(DerefOf(Index(TIM0, 0x01, )), MEQ, Arg0,  
 MTR, 0x00, 0x00), Local6)
                  Store(DerefOf(Index(DerefOf(Index(TIM0, 0x00, )),  
 Local6, )), Local7)
                  Store(Local7, DMA0)
                  Store(Local7, PIO0)
                  If(And(Arg4, 0x20, )) {
                      Or(CHNF, 0x08, CHNF)
                  }
                  Store(Match(DerefOf(Index(TIM0, 0x02, )), MEQ, Arg3,  
 MTR, 0x00, 0x00), Local6)
                  Store(DerefOf(Index(DerefOf(Index(TIM0, 0x00, )),  
 Local6, )), Local7)
                  Store(Local7, DMA1)
                  Store(Local7, PIO1)
                  If(And(Arg1, 0x07, )) {
                      Store(Arg2, Local5)
                      If(And(Arg1, 0x02, )) {
                          Add(Local5, 0x02, Local5)
                      }
                      If(And(Arg1, 0x04, )) {
                          Add(Local5, 0x04, Local5)
                      }
                      Store(DerefOf(Index(DerefOf(Index(TIM0,  
 0x03, )), Local5, )), DMA0)
                      Or(CHNF, 0x01, CHNF)
                  }
                  If(And(Arg4, 0x07, )) {
                      Store(Arg5, Local5)
                      If(And(Arg4, 0x02, )) {
                          Add(Local5, 0x02, Local5)
                      }
                      If(And(Arg4, 0x04, )) {
                          Add(Local5, 0x04, Local5)
                      }
                      Store(DerefOf(Index(DerefOf(Index(TIM0,  
 0x03, )), Local5, )), DMA1)
                      Or(CHNF, 0x04, CHNF)
                  }
                  Store(TMD0, Debug)
                  Return(TMD0)
              }
              Method(STM, 0, Serialized) {
                  If(REGF) {
                  }
                  Else {
                      Store(0x00, GMUE)
                      Store(0x00, GMUT)
                      Store(0x00, GSUE)
                      Store(0x00, GSUT)
                      If(And(CHNF, 0x01, )) {
                          Store(Match(DerefOf(Index(TIM0, 0x03, )),  
 MLE, DMA0, MTR, 0x00, 0x00), Local0)
                          If(LGreater(Local0, 0x05)) {
                              Store(0x05, Local0)
                          }
                          Store(DerefOf(Index(DerefOf(Index(TIM0,  
 0x04, )), Local0, )), GMUT)
                          Or(GMUE, 0x01, GMUE)
                          If(LGreater(Local0, 0x02)) {
                              Or(GMUE, 0x02, GMUE)
                          }
                          If(LGreater(Local0, 0x04)) {
                              And(GMUE, 0xfd, GMUE)
                              Or(GMUE, 0x04, GMUE)
                          }
                      }
                      Else {
                          If(Or(LEqual(PIO0, Ones), LEqual(PIO0,  
 0x00), )) {
                              If(And(LLess(DMA0, Ones), LGreater(DMA0,  
 0x00), )) {
                                  Store(DMA0, PIO0)
                                  Or(GMUE, 0x80, GMUE)
                              }
                          }
                      }
                      If(And(CHNF, 0x04, )) {
                          Store(Match(DerefOf(Index(TIM0, 0x03, )),  
 MLE, DMA1, MTR, 0x00, 0x00), Local0)
                          If(LGreater(Local0, 0x05)) {
                              Store(0x05, Local0)
                          }
                          Store(DerefOf(Index(DerefOf(Index(TIM0,  
 0x04, )), Local0, )), GSUT)
                          Or(GSUE, 0x01, GSUE)
                          If(LGreater(Local0, 0x02)) {
                              Or(GSUE, 0x02, GSUE)
                          }
                          If(LGreater(Local0, 0x04)) {
                              And(GSUE, 0xfd, GSUE)
                              Or(GSUE, 0x04, GSUE)
                          }
                      }
                      Else {
                          If(Or(LEqual(PIO1, Ones), LEqual(PIO1,  
 0x00), )) {
                              If(And(LLess(DMA1, Ones), LGreater(DMA1,  
 0x00), )) {
                                  Store(DMA1, PIO1)
                                  Or(GSUE, 0x80, GSUE)
                              }
                          }
                      }
                      If(And(CHNF, 0x02, )) {
                          Or(GMUE, 0x20, GMUE)
                      }
                      If(And(CHNF, 0x08, )) {
                          Or(GSUE, 0x20, GSUE)
                      }
                      And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,  
 PIO0, MTR, 0x00, 0x00), 0x07, Local0)
                      Store(DerefOf(Index(DerefOf(Index(TIM0,  
 0x01, )), Local0, )), Local1)
                      Store(Local1, GMPT)
                      If(LLess(Local0, 0x03)) {
                          Or(GMUE, 0x50, GMUE)
                      }
                      And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,  
 PIO1, MTR, 0x00, 0x00), 0x07, Local0)
                      Store(DerefOf(Index(DerefOf(Index(TIM0,  
 0x02, )), Local0, )), Local1)
                      Store(Local1, GSPT)
                      If(LLess(Local0, 0x03)) {
                          Or(GSUE, 0x50, GSUE)
                      }
                  }
              }
              Name(AT01, Buffer(0x07) {0x3, 0x0, 0x0, 0x0, 0x0, 0x0,  
 0xef })
              Name(AT02, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  
 0x90 })
              Name(AT03, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  
 0xc6 })
              Name(AT04, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  
 0x91 })
              Name(ATA0, Buffer(0x1d) { })
              Name(ATA1, Buffer(0x1d) { })
              Name(ATA2, Buffer(0x1d) { })
              Name(ATA3, Buffer(0x1d) { })
              Name(ATAB, Buffer(0x1d) { })
              CreateByteField(ATAB, 0x00, CMDC)
              Method(GTFB, 3, Serialized) {
                  Multiply(CMDC, 0x38, Local0)
                  Add(Local0, 0x08, Local1)
                  CreateField(ATAB, Local1, 0x38, CMDX)
                  Multiply(CMDC, 0x07, Local0)
                  CreateByteField(ATAB, Add(Local0, 0x02, ), A001)
                  CreateByteField(ATAB, Add(Local0, 0x06, ), A005)
                  Store(Arg0, CMDX)
                  Store(Arg1, A001)
                  Store(Arg2, A005)
                  Increment(CMDC)
              }
              Method(GTF, 2, Serialized) {
                  Store(Arg1, Debug)
                  Store(0x00, CMDC)
                  Name(ID49, 0x0c00)
                  Name(ID59, 0x00)
                  Name(ID53, 0x04)
                  Name(ID63, 0x0f00)
                  Name(ID88, 0x0f00)
                  Name(IRDY, 0x01)
                  Name(PIOT, 0x00)
                  Name(DMAT, 0x00)
                  If(LEqual(SizeOf(Arg1), 0x0200)) {
                      CreateWordField(Arg1, 0x62, IW49)
                      Store(IW49, ID49)
                      CreateWordField(Arg1, 0x6a, IW53)
                      Store(IW53, ID53)
                      CreateWordField(Arg1, 0x7e, IW63)
                      Store(IW63, ID63)
                      CreateWordField(Arg1, 0x76, IW59)
                      Store(IW59, ID59)
                      CreateWordField(Arg1, 0xb0, IW88)
                      Store(IW88, ID88)
                  }
                  Store(0xa0, Local7)
                  If(Arg0) {
                      Store(0xb0, Local7)
                      And(CHNF, 0x08, IRDY)
                      If(And(CHNF, 0x10, )) {
                          Store(PIO1, PIOT)
                      }
                      Else {
                          Store(PIO0, PIOT)
                      }
                      If(And(CHNF, 0x04, )) {
                          If(And(CHNF, 0x10, )) {
                              Store(DMA1, DMAT)
                          }
                          Else {
                              Store(DMA0, DMAT)
                          }
                      }
                  }
                  Else {
                      And(CHNF, 0x02, IRDY)
                      Store(PIO0, PIOT)
                      If(And(CHNF, 0x01, )) {
                          Store(DMA0, DMAT)
                      }
                  }
                  If(LAnd(LAnd(And(ID53, 0x04, ), And(ID88,  
 0xff00, )), DMAT)) {
                      Store(Match(DerefOf(Index(TIM0, 0x03, )), MLE,  
 DMAT, MTR, 0x00, 0x00), Local1)
                      If(LGreater(Local1, 0x05)) {
                          Store(0x05, Local1)
                      }
                      GTFB(AT01, Or(0x40, Local1, ), Local7)
                  }
                  Else {
                      If(LAnd(And(ID63, 0xff00, ), PIOT)) {
                          And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,  
 PIOT, MTR, 0x00, 0x00), 0x03, Local0)
                          Or(0x20, DerefOf(Index(DerefOf(Index(TIM0,  
 0x07, )), Local0, )), Local1)
                          GTFB(AT01, Local1, Local7)
                      }
                  }
                  If(IRDY) {
                      And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,  
 PIOT, MTR, 0x00, 0x00), 0x07, Local0)
                      Or(0x08, DerefOf(Index(DerefOf(Index(TIM0,  
 0x06, )), Local0, )), Local1)
                      GTFB(AT01, Local1, Local7)
                  }
                  Else {
                      If(And(ID49, 0x0400, )) {
                          GTFB(AT01, 0x01, Local7)
                      }
                  }
                  If(LAnd(And(ID59, 0x0100, ), And(ID59, 0xff, ))) {
                      GTFB(AT03, And(ID59, 0xff, ), Local7)
                  }
                  Store(ATAB, Debug)
                  Return(ATAB)
              }
              Method(RATA, 1) {
                  CreateByteField(Arg0, 0x00, CMDN)
                  Multiply(CMDN, 0x38, Local0)
                  CreateField(Arg0, 0x08, Local0, RETB)
                  Store(RETB, Debug)
                  Return(RETB)
              }
          }
          Device(USB0) {
              Name(_ADR, 0x001d0000)
              OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
              Field(BAR0, ByteAcc, NoLock, Preserve) {
                  USBW,	2,
                  Offset(0x1)
              }
              Method(_S3D) {
                  If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
                      Return(0x02)
                  }
                  Else {
                      Return(0x03)
                  }
              }
              Method(_PSW, 1) {
                  If(Arg0) {
                      Store(0x03, USBW)
                  }
                  Else {
                      Store(0x00, USBW)
                  }
              }
              Method(_PRW) {
                  Return(GPRW(0x03, 0x03))
              }
          }
          Device(USB1) {
              Name(_ADR, 0x001d0001)
              OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
              Field(BAR0, ByteAcc, NoLock, Preserve) {
                  USBW,	2,
                  Offset(0x1)
              }
              Method(_S3D) {
                  If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
                      Return(0x02)
                  }
                  Else {
                      Return(0x03)
                  }
              }
              Method(_PSW, 1) {
                  If(Arg0) {
                      Store(0x03, USBW)
                  }
                  Else {
                      Store(0x00, USBW)
                  }
              }
              Method(_PRW) {
                  Return(GPRW(0x04, 0x03))
              }
          }
          Device(USB2) {
              Name(_ADR, 0x001d0002)
              OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
              Field(BAR0, ByteAcc, NoLock, Preserve) {
                  USBW,	2,
                  Offset(0x1)
              }
              Method(_S3D) {
                  If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
                      Return(0x02)
                  }
                  Else {
                      Return(0x03)
                  }
              }
              Method(_PSW, 1) {
                  If(Arg0) {
                      Store(0x03, USBW)
                  }
                  Else {
                      Store(0x00, USBW)
                  }
              }
              Method(_PRW) {
                  Return(GPRW(0x0c, 0x03))
              }
          }
          Device(USB3) {
              Name(_ADR, 0x001d0003)
              OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
              Field(BAR0, ByteAcc, NoLock, Preserve) {
                  USBW,	2,
                  Offset(0x1)
              }
              Method(_S3D) {
                  If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
                      Return(0x02)
                  }
                  Else {
                      Return(0x03)
                  }
              }
              Method(_PSW, 1) {
                  If(Arg0) {
                      Store(0x03, USBW)
                  }
                  Else {
                      Store(0x00, USBW)
                  }
              }
              Method(_PRW) {
                  Return(GPRW(0x0e, 0x03))
              }
          }
          Device(EHCI) {
              Name(_ADR, 0x001d0007)
              Method(_PRW) {
                  Return(GPRW(0x0d, 0x03))
              }
          }
          Device(MC97) {
              Name(_ADR, 0x001e0003)
              Method(_PRW) {
                  Return(GPRW(0x05, 0x04))
              }
          }
          Device(P0P1) {
              Name(_ADR, 0x001e0000)
              Method(_PRW) {
                  Return(GPRW(0x0b, 0x04))
              }
          }
          Device(SBRG) {
              Name(_ADR, 0x001f0000)
              Method(SPTS, 1) {
                  Store(One, PS1S)
                  Store(One, PS1S)
                  Store(One, PS1E)
                  If(LEqual(Arg0, 0x04)) {
                      Store(One, \_SB.PCI0.SBRG.EC.RSD3)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Zero, \_SB.PCI0.SBRG.EC.RSD3)
                  }
              }
              Method(SWAK, 1) {
                  Store(Zero, PS1E)
                  If(LEqual(Arg0, 0x04)) {
                      Notify(\_SB.PWRB, 0x02)
                  }
              }
              OperationRegion(APMP, SystemIO, SMIP, 0x02)
              Field(APMP, ByteAcc, NoLock, Preserve) {
                  APMC,	8,
                  APMS,	8
              }
              Field(APMP, ByteAcc, NoLock, Preserve) {
                  Offset(0x1),
                  ,	1,
                  BRTC,	1
              }
              OperationRegion(PMS0, SystemIO, PMBS, 0x04)
              Field(PMS0, ByteAcc, NoLock, Preserve) {
                  ,	10,
                  RTCS,	1,
                  ,	4,
                  WAKS,	1,
                  Offset(0x3),
                  PWBT,	1,
                  Offset(0x4)
              }
              OperationRegion(SMIE, SystemIO, PM30, 0x08)
              Field(SMIE, ByteAcc, NoLock, Preserve) {
                  ,	4,
                  PS1E,	1,
                  ,	31,
                  PS1S,	1,
                  Offset(0x8)
              }
              Scope(\_SB) {
                  Name(PWRS, 0x00)
                  Device(PWRB) {
                      Name(_HID, 0x0c0cd041)
                      Method(_STA) {
                          Return(0x0b)
                      }
                  }
              }
              Scope(\_SB) {
                  Name(SLPS, 0x00)
                  Device(SLPB) {
                      Name(_HID, 0x0e0cd041)
                      Method(_STA) {
                          Return(0x0f)
                      }
                  }
              }
              Scope(\_SB) {
                  Scope(PCI0) {
                      Device(ICH7) {
                          Name(_HID, 0x010cd041)
                          Name(_UID, 0x01c7)
                          Name(_STA, 0x0f)
                          Name(ICHR, Buffer(0x56) {0x47, 0x1, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  
 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0,  
 0xe0, 0xfe, 0x0, 0x10, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xb0, 0xff,  
 0x0, 0x0, 0x10, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x4, 0x80, 0xfc, 0x0,  
 0xc, 0x0, 0x0, 0x79, 0x0 })
                          Method(_CRS) {
                              CreateWordField(ICHR, 0x02, PBB)
                              CreateWordField(ICHR, 0x04, PBH)
                              CreateByteField(ICHR, 0x07, PML)
                              Store(\PMBS, PBB)
                              Store(\PMBS, PBH)
                              Store(\PMLN, PML)
                              If(SMBS) {
                                  CreateWordField(ICHR, 0x0a, SMB)
                                  CreateWordField(ICHR, 0x0c, SMH)
                                  CreateByteField(ICHR, 0x0f, SML)
                                  Store(\SMBS, SMB)
                                  Store(\SMBS, SMH)
                                  Store(\SMBL, SML)
                              }
                              If(GPBS) {
                                  CreateWordField(ICHR, 0x12, IGB)
                                  CreateWordField(ICHR, 0x14, IGH)
                                  CreateByteField(ICHR, 0x17, IGL)
                                  Store(\GPBS, IGB)
                                  Store(\GPBS, IGH)
                                  Store(\GPLN, IGL)
                              }
                              If(APCB) {
                                  CreateDWordField(ICHR, 0x1c, APB)
                                  CreateDWordField(ICHR, 0x20, APL)
                                  Store(\APCB, APB)
                                  Store(\APCL, APL)
                              }
                              CreateDWordField(ICHR, 0x34, RCB)
                              CreateDWordField(ICHR, 0x38, RCL)
                              Store(\SRCB, RCB)
                              Store(\SRCL, RCL)
                              Return(ICHR)
                          }
                      }
                  }
              }
              Device(SPKR) {
                  Name(_HID, 0x0008d041)
                  Name(_CRS, Buffer(0x0a) {0x47, 0x1, 0x61, 0x0, 0x61,  
 0x0, 0x0, 0x1, 0x79, 0x0 })
              }
              Device(PIC) {
                  Name(_HID, 0xd041)
                  Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20,  
 0x0, 0x0, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x0, 0x2, 0x22, 0x4,  
 0x0, 0x79, 0x0 })
              }
              Device(DMAD) {
                  Name(_HID, 0x0002d041)
                  Name(_CRS, Buffer(0x35) {0x2a, 0x10, 0x4, 0x47, 0x1,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x0,  
 0x3, 0x47, 0x1, 0x87, 0x0, 0x87, 0x0, 0x0, 0x1, 0x47, 0x1, 0x89, 0x0,  
 0x89, 0x0, 0x0, 0x3, 0x47, 0x1, 0x8f, 0x0, 0x8f, 0x0, 0x0, 0x1, 0x47,  
 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x0, 0x20, 0x79, 0x0 })
              }
              Device(TMR) {
                  Name(_HID, 0x0001d041)
                  Name(_CRS, Buffer(0x0d) {0x47, 0x1, 0x40, 0x0, 0x40,  
 0x0, 0x0, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
              }
              Device(RTC0) {
                  Name(_HID, 0x000bd041)
                  Name(_CRS, Buffer(0x0d) {0x47, 0x1, 0x70, 0x0, 0x70,  
 0x0, 0x0, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
              }
              Device(RMSC) {
                  Name(_HID, 0x020cd041)
                  Name(_UID, 0x10)
                  Name(CRS, Buffer(0x7a) {0x47, 0x1, 0x10, 0x0, 0x10,  
 0x0, 0x0, 0x10, 0x47, 0x1, 0x22, 0x0, 0x22, 0x0, 0x0, 0x1e, 0x47,  
 0x1, 0x44, 0x0, 0x44, 0x0, 0x0, 0x1c, 0x47, 0x1, 0x63, 0x0, 0x63,  
 0x0, 0x0, 0x1, 0x47, 0x1, 0x65, 0x0, 0x65, 0x0, 0x0, 0x1, 0x47, 0x1,  
 0x67, 0x0, 0x67, 0x0, 0x0, 0x9, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x0,  
 0xe, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x0, 0x1, 0x47, 0x1, 0x84, 0x0,  
 0x84, 0x0, 0x0, 0x3, 0x47, 0x1, 0x88, 0x0, 0x88, 0x0, 0x0, 0x1, 0x47,  
 0x1, 0x8c, 0x0, 0x8c, 0x0, 0x0, 0x3, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0,  
 0x0, 0x10, 0x47, 0x1, 0xa2, 0x0, 0xa2, 0x0, 0x0, 0x1e, 0x47, 0x1,  
 0xe0, 0x0, 0xe0, 0x0, 0x0, 0x10, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4,  
 0x0, 0x2, 0x79, 0x0 })
                  Method(_CRS) {
                      Return(CRS)
                  }
              }
              Device(COPR) {
                  Name(_HID, 0x040cd041)
                  Name(_CRS, Buffer(0x0d) {0x47, 0x1, 0xf0, 0x0, 0xf0,  
 0x0, 0x0, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
              }
              Device(PS2K) {
                  Name(_HID, 0x0303d041)
                  Name(_CID, 0x0b03d041)
                  Method(_STA) {
                      Return(0x0f)
                  }
                  Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60,  
 0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x2,  
 0x0, 0x79, 0x0 })
                  Name(_PRS, Buffer(0x10) {0x31, 0x0, 0x4b, 0x60, 0x0,  
 0x1, 0x4b, 0x64, 0x0, 0x1, 0x22, 0x2, 0x0, 0x38, 0x79, 0x0 })
              }
              Device(PS2M) {
                  Name(_HID, 0x030fd041)
                  Name(_CID, 0x130fd041)
                  Method(_STA) {
                      Return(0x0f)
                  }
                  Name(_CRS, Buffer(0x05) {0x22, 0x0, 0x10, 0x79, 0x0 })
                  Name(_PRS, Buffer(0x08) {0x31, 0x0, 0x22, 0x0, 0x10,  
 0x38, 0x79, 0x0 })
              }
          }
          Device(P0P4) {
              Name(_ADR, 0x001c0000)
              Method(_PRW) {
                  Return(GPRW(0x09, 0x04))
              }
              Method(_PRT) {
                  If(PICM) {
                      Return(AR04)
                  }
                  Return(PR04)
              }
              Device(PSL0) {
                  Name(_ADR, 0x00)
              }
          }
          Device(P0P5) {
              Name(_ADR, 0x001c0001)
              Method(_PRW) {
                  Return(GPRW(0x09, 0x04))
              }
              Method(_PRT) {
                  If(PICM) {
                      Return(AR05)
                  }
                  Return(PR05)
              }
              Device(PSL1) {
                  Name(_ADR, 0xffff)
              }
          }
          Device(P0P6) {
              Name(_ADR, 0x001c0002)
              Method(_PRW) {
                  Return(GPRW(0x09, 0x04))
              }
              Method(_PRT) {
                  If(PICM) {
                      Return(AR06)
                  }
                  Return(PR06)
              }
          }
          Device(P0P7) {
              Name(_ADR, 0x001c0003)
              Method(_PRW) {
                  Return(GPRW(0x09, 0x04))
              }
              Method(_PRT) {
                  If(PICM) {
                      Return(AR07)
                  }
                  Return(PR07)
              }
          }
          Device(P0P8) {
              Name(_ADR, 0x001c0004)
              Method(_PRW) {
                  Return(GPRW(0x09, 0x04))
              }
              Method(_PRT) {
                  If(PICM) {
                      Return(AR08)
                  }
                  Return(PR08)
              }
          }
          Device(P0P9) {
              Name(_ADR, 0x001c0005)
              Method(_PRW) {
                  Return(GPRW(0x09, 0x04))
              }
              Method(_PRT) {
                  If(PICM) {
                      Return(AR09)
                  }
                  Return(PR09)
              }
          }
          Device(IGD) {
              Name(_ADR, 0x00020000)
              Method(_DOS, 1) {
                  Store(Arg0, SWIT)
              }
              Name(_DOD, Package(0x02) {
                  0x00010100,
                  0x00010410,
              })
              Device(CRT) {
                  Name(_ADR, 0x0100)
                  Name(_DCS, 0x1f)
                  Name(_DGS, 0x00)
                  Method(_DSS, 1) {
                  }
              }
              Device(LCD) {
                  Name(_ADR, 0x0410)
                  Name(_DCS, 0x1f)
                  Name(_DGS, 0x01)
                  Method(_DSS, 1) {
                  }
                  Name(LCFG, 0x00)
                  Name(LCBF, 0x00)
                  Method(_BCM, 1) {
                      If(LEqual(Arg0, 0x14)) {
                          Store(0x00, Local0)
                      }
                      If(LEqual(Arg0, 0x1e)) {
                          Store(0x01, Local0)
                      }
                      If(LEqual(Arg0, 0x28)) {
                          Store(0x02, Local0)
                      }
                      If(LEqual(Arg0, 0x32)) {
                          Store(0x03, Local0)
                      }
                      If(LEqual(Arg0, 0x3c)) {
                          Store(0x04, Local0)
                      }
                      If(LEqual(Arg0, 0x46)) {
                          Store(0x05, Local0)
                      }
                      If(LEqual(Arg0, 0x50)) {
                          Store(0x06, Local0)
                      }
                      If(LEqual(Arg0, 0x5a)) {
                          Store(0x07, Local0)
                      }
                      If(LEqual(Arg0, 0x64)) {
                          Store(0x08, Local0)
                      }
                      Store(Local0, LCBF)
                      Store(Local0, \_SB.PCI0.SBRG.EC.BRLV)
                  }
                  Name(PBCL, Package(0x0b) {
                      0x50,
                      0x14,
                      0x14,
                      0x1e,
                      0x28,
                      0x32,
                      0x3c,
                      0x46,
                      0x50,
                      0x5a,
                      0x64,
                  })
                  Method(_BCL) {
                      Return(PBCL)
                  }
                  Method(_BQC) {
                      If(LCFG) {
                          Store(LCBF, Local0)
                      }
                      Else {
                          Store(\_SB.PCI0.SBRG.EC.BRLV, Local0)
                          Store(Local0, LCBF)
                          Store(0x01, LCFG)
                      }
                      Add(Local0, 0x02, Local0)
                      Store(DerefOf(Index(PBCL, Local0, )), Local1)
                      Return(Local1)
                  }
              }
              Name(SWIT, 0x00)
              Name(GDCS, 0x02)
              Name(GDGS, 0x01)
              Name(GDTS, 0x00)
              Name(GDFG, 0x01)
          }
      }
      Scope(\_GPE) {
          Method(_L09) {
              Notify(\_SB.PCI0.P0P2, 0x02)
              Notify(\_SB.PCI0.P0P2.PEGP, 0x02)
              Notify(\_SB.PCI0.P0P4, 0x02)
              Notify(\_SB.PCI0.P0P5, 0x02)
              Notify(\_SB.PCI0.P0P6, 0x02)
              Notify(\_SB.PCI0.P0P7, 0x02)
              Notify(\_SB.PCI0.P0P8, 0x02)
              Notify(\_SB.PCI0.P0P9, 0x02)
          }
          Method(_L03) {
              Notify(\_SB.PCI0.USB0, 0x02)
          }
          Method(_L04) {
              Notify(\_SB.PCI0.USB1, 0x02)
          }
          Method(_L0C) {
              Notify(\_SB.PCI0.USB2, 0x02)
          }
          Method(_L0E) {
              Notify(\_SB.PCI0.USB3, 0x02)
          }
          Method(_L0D) {
              Notify(\_SB.PCI0.EHCI, 0x02)
          }
          Method(_L05) {
              Notify(\_SB.PCI0.MC97, 0x02)
          }
          Method(_L0B) {
              Notify(\_SB.PCI0.P0P1, 0x02)
          }
      }
 }
 OperationRegion(\_SB.PCI0.SBRG.PIX0, PCI_Config, 0x60, 0x0c)
 Field(\_SB.PCI0.SBRG.PIX0, ByteAcc, NoLock, Preserve) {
      PIRA,	8,
      PIRB,	8,
      PIRC,	8,
      PIRD,	8,
      Offset(0x8),
      PIRE,	8,
      PIRF,	8,
      PIRG,	8,
      PIRH,	8
 }
 Scope(\_SB) {
      Name(BUFA, Buffer(0x06) {0x23, 0x0, 0x80, 0x18, 0x79, 0x0 })
      CreateWordField(BUFA, 0x01, IRA0)
      Device(LNKA) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x01)
          Method(_STA) {
              And(PIRA, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSA)
          }
          Method(_DIS) {
              Or(PIRA, 0x80, PIRA)
          }
          Method(_CRS) {
              And(PIRA, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRA)
          }
      }
      Device(LNKB) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x02)
          Method(_STA) {
              And(PIRB, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSB)
          }
          Method(_DIS) {
              Or(PIRB, 0x80, PIRB)
          }
          Method(_CRS) {
              And(PIRB, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRB)
          }
      }
      Device(LNKC) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x03)
          Method(_STA) {
              And(PIRC, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSC)
          }
          Method(_DIS) {
              Or(PIRC, 0x80, PIRC)
          }
          Method(_CRS) {
              And(PIRC, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRC)
          }
      }
      Device(LNKD) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x04)
          Method(_STA) {
              And(PIRD, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSD)
          }
          Method(_DIS) {
              Or(PIRD, 0x80, PIRD)
          }
          Method(_CRS) {
              And(PIRD, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRD)
          }
      }
      Device(LNKE) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x05)
          Method(_STA) {
              And(PIRE, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSE)
          }
          Method(_DIS) {
              Or(PIRE, 0x80, PIRE)
          }
          Method(_CRS) {
              And(PIRE, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRE)
          }
      }
      Device(LNKF) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x06)
          Method(_STA) {
              And(PIRF, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSF)
          }
          Method(_DIS) {
              Or(PIRF, 0x80, PIRF)
          }
          Method(_CRS) {
              And(PIRF, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRF)
          }
      }
      Device(LNKG) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x07)
          Method(_STA) {
              And(PIRG, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSG)
          }
          Method(_DIS) {
              Or(PIRG, 0x80, PIRG)
          }
          Method(_CRS) {
              And(PIRG, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRG)
          }
      }
      Device(LNKH) {
          Name(_HID, 0x0f0cd041)
          Name(_UID, 0x08)
          Method(_STA) {
              And(PIRH, 0x80, Local0)
              If(Local0) {
                  Return(0x09)
              }
              Else {
                  Return(0x0b)
              }
          }
          Method(_PRS) {
              Return(PRSH)
          }
          Method(_DIS) {
              Or(PIRH, 0x80, PIRH)
          }
          Method(_CRS) {
              And(PIRH, 0x0f, Local0)
              ShiftLeft(0x01, Local0, IRA0)
              Return(BUFA)
          }
          Method(_SRS, 1) {
              CreateWordField(Arg0, 0x01, IRA)
              FindSetRightBit(IRA, Local0)
              Decrement(Local0)
              Store(Local0, PIRH)
          }
      }
 }
 Scope(\_PR) {
      Processor(CPU0, 1, 0x410, 0x6) {
      }
      Processor(CPU1, 2, 0x410, 0x6) {
      }
 }
 Scope(\_SB) {
      Scope(PCI0) {
          Method(_INI) {
          }
          Name(CRS, Buffer(0x88) {0x88, 0xd, 0x0, 0x2, 0xc, 0x0, 0x0,  
 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0xf8, 0xc,  
 0xf8, 0xc, 0x1, 0x8, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0,  
 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3,  
 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x87, 0x17, 0x0,  
 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff,  
 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87, 0x17, 0x0,  
 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0,  
 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
          CreateDWordField(CRS, 0x5c, MIN5)
          CreateDWordField(CRS, 0x60, MAX5)
          CreateDWordField(CRS, 0x68, LEN5)
          CreateDWordField(CRS, 0x76, MIN6)
          CreateDWordField(CRS, 0x7a, MAX6)
          CreateDWordField(CRS, 0x82, LEN6)
          Method(_CRS) {
              Store(MG1L, Local0)
              If(Local0) {
                  Store(MG1B, MIN5)
                  Store(MG1L, LEN5)
                  Add(MIN5, Decrement(Local0), MAX5)
              }
              Store(MG2B, MIN6)
              Store(MG2L, LEN6)
              Store(MG2L, Local0)
              Add(MIN6, Decrement(Local0), MAX6)
              Return(CRS)
          }
      }
 }
 Name(WOTB, 0x00)
 Name(WSSB, 0x00)
 Name(WAXB, 0x00)
 Method(_PTS, 1) {
      Store(Arg0, DBG8)
      PTS(Arg0)
      Store(0x00, Index(WAKP, 0x00, ))
      Store(0x00, Index(WAKP, 0x01, ))
      Store(ASSB, WSSB)
      Store(AOTB, WOTB)
      Store(AAXB, WAXB)
      Store(Arg0, ASSB)
      Store(OSFL(), AOTB)
      Store(Zero, AAXB)
 }
 Method(_WAK, 1) {
      ShiftLeft(Arg0, 0x04, DBG8)
      WAK(Arg0)
      If(ASSB) {
          Store(WSSB, ASSB)
          Store(WOTB, AOTB)
          Store(WAXB, AAXB)
      }
      If(DerefOf(Index(WAKP, 0x00, ))) {
          Store(0x00, Index(WAKP, 0x01, ))
      }
      Else {
          Store(Arg0, Index(WAKP, 0x01, ))
      }
      Return(WAKP)
 }
 OperationRegion(PMS0, SystemIO, PMBS, 0x02)
 Field(PMS0, ByteAcc, NoLock, Preserve) {
      Offset(0x1),
      PWBT,	1,
      ,	1,
      RTCS,	1,
      ,	4,
      WAKS,	1
 }
 OperationRegion(SMIE, SystemIO, PM30, 0x08)
 Field(SMIE, ByteAcc, NoLock, Preserve) {
      ,	4,
      PS1E,	1,
      ,	31,
      PS1S,	1,
      Offset(0x8)
 }
 Scope(\_SB) {
      Scope(PCI0) {
          Device(HPET) {
              Name(_HID, 0x0301d041)
              Name(CRS, Buffer(0x0e) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0,  
 0xd0, 0xfe, 0x0, 0x4, 0x0, 0x0, 0x79, 0x0 })
              OperationRegion(HCNT, SystemMemory, \HPTC, 0x04)
              Field(HCNT, DWordAcc, NoLock, Preserve) {
                  HPTS,	2,
                  ,	5,
                  HPTE,	1
              }
              Method(_STA) {
                  If(LEqual(OSFL(), 0x00)) {
                      If(HPTE) {
                          Return(0x0f)
                      }
                  }
                  Else {
                      If(HPTE) {
                          Return(0x0b)
                      }
                  }
                  Return(0x00)
              }
              Method(_CRS) {
                  CreateDWordField(CRS, 0x04, HTBS)
                  Multiply(HPTS, 0x1000, Local0)
                  Add(Local0, 0xfed00000, HTBS)
                  Return(CRS)
              }
          }
      }
 }
 Scope(\_SB) {
      Scope(PCI0) {
          Method(_OSC, 4) {
              Name(SUPP, 0x00)
              Name(CTRL, 0x00)
              CreateDWordField(Arg3, 0x00, CDW1)
              CreateDWordField(Arg3, 0x04, CDW2)
              CreateDWordField(Arg3, 0x08, CDW3)
              If(LEqual(Arg0, Buffer(0x10) {0x5b, 0x4d, 0xdb, 0x33,  
 0xf7, 0x1f, 0x1c, 0x40, 0x96, 0x57, 0x74, 0x41, 0xc0, 0x3d, 0xd7,  
 0x66 })) {
                  Store(CDW2, SUPP)
                  Store(CDW3, CTRL)
                  If(LNot(LEqual(And(SUPP, 0x16, ), 0x16))) {
                      And(CTRL, 0x1e, CTRL)
                  }
                  If(LNot(PEHP)) {
                      And(CTRL, 0x1e, CTRL)
                  }
                  If(LNot(SHPC)) {
                      And(CTRL, 0x1d, CTRL)
                  }
                  If(LNot(PEPM)) {
                      And(CTRL, 0x1b, CTRL)
                  }
                  If(LNot(PEER)) {
                      And(CTRL, 0x15, CTRL)
                  }
                  If(LNot(PECS)) {
                      And(CTRL, 0x0f, CTRL)
                  }
                  If(LNot(LEqual(Arg1, One))) {
                      Or(CDW1, 0x08, CDW1)
                  }
                  If(LNot(LEqual(CDW3, CTRL))) {
                      Or(CDW1, 0x10, CDW1)
                  }
                  Store(CTRL, CDW3)
                  Return(Arg3)
              }
              Else {
                  Or(CDW1, 0x04, CDW1)
                  Return(Arg3)
              }
          }
      }
 }
 Device(OMSC) {
      Name(_HID, 0x020cd041)
      Name(_UID, 0x0e11)
 }
 Device(\_SB.RMEM) {
      Name(_HID, 0x010cd041)
      Name(_UID, 0x01)
 }
 Scope(\_SB.PCI0.SBRG) {
      OperationRegion(RTCA, SystemIO, 0x72, 0x02)
      Field(RTCA, ByteAcc, NoLock, Preserve) {
          RTCI,	8,
          RTCD,	8
      }
      Method(_INI) {
          Store(CMOS, RTCI)
          Store(OSFL(), RTCD)
      }
 }
 Scope(\_TZ) {
      Method(KELV, 1) {
          And(Arg0, 0xff, Local0)
          Multiply(Local0, 0x0a, Local0)
          Add(Local0, 0x0aac, Local0)
          Return(Local0)
      }
      ThermalZone(THRM) {
          Method(_TMP) {
              If(\_SB.PCI0.SBRG.EC.MYEC) {
                  If(\_SB.PCI0.SBRG.EC.CTSD) {
                      Store(0x00, \_SB.PCI0.SBRG.EC.CTSD)
                      Return(KELV(0x6e))
                  }
                  Else {
                      Store(\_SB.PCI0.SBRG.EC.CPUT, Local0)
                      Add(Local0, 0x02, Local0)
                      Return(KELV(Local0))
                  }
              }
              Else {
                  Return(KELV(0x2d))
              }
          }
          Method(_CRT) {
              Return(KELV(0x64))
          }
      }
 }
 Scope(\_SB.PCI0.SBRG) {
      Device(EC) {
          Name(_HID, 0x090cd041)
          Name(_GPE, 0x17)
          Name(CTID, 0x00)
          Name(MYEC, 0x01)
          Name(CTSD, 0x00)
          Name(\PTHR, 0x00)
          Method(_REG, 2) {
              If(LEqual(Arg0, 0x03)) {
                  Store(Arg1, MYEC)
              }
              Store(0x00, CTSD)
          }
          Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0,  
 0x0, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x0, 0x1, 0x79, 0x0 })
          OperationRegion(EC, EmbeddedControl, 0x00, 0x0100)
          Field(EC, ByteAcc, NoLock, Preserve) {
              SMPR,	8,
              SMST,	8,
              SMAD,	8,
              SMCM,	8,
              SMD0,	264,
              SMAA,	8,
              Offset(0x2c),
              HSTT,	1,
              Offset(0x2d),
              Offset(0x30),
              POWS,	1,
              LIDS,	1,
              KBCS,	1,
              Offset(0x31),
              MBTS,	1,
              MBCS,	1,
              MBDS,	1,
              MBFS,	1,
              MBWS,	1,
              MBLS,	1,
              MBCL,	1,
              MBFL,	1,
              Offset(0x34),
              HSKS,	3,
              Offset(0x35),
              Offset(0x38),
              MDCL,	8,
              MDCH,	8,
              MDVL,	8,
              MDVH,	8,
              MCAL,	8,
              MCAH,	8,
              MSTL,	8,
              MSTH,	8,
              MCCL,	8,
              MCCH,	8,
              MPOL,	8,
              MPOH,	8,
              MFCL,	8,
              MFCH,	8,
              MCUL,	8,
              MCUH,	8,
              MRCL,	8,
              MRCH,	8,
              MVOL,	8,
              MVOH,	8,
              MTEL,	8,
              MTEH,	8,
              RSV1,	8,
              RSD2,	4,
              RSD3,	1,
              RSD4,	3,
              SDCL,	8,
              SDCH,	8,
              SDVL,	8,
              SDVH,	8,
              SCAL,	8,
              SCAH,	8,
              SSTL,	8,
              SSTH,	8,
              SCCL,	8,
              SCCH,	8,
              SPOL,	8,
              SPOH,	8,
              SFCL,	8,
              SFCH,	8,
              SCUL,	8,
              SCUH,	8,
              SRCL,	8,
              SRCH,	8,
              SVOL,	8,
              SVOH,	8,
              STEL,	8,
              STEH,	8,
              Offset(0x68),
              CPUT,	8,
              Offset(0x7e),
              RES1,	3,
              CHET,	1,
              Offset(0x80),
              SYST,	8,
              Offset(0xc4),
              BSFL,	1,
              Offset(0xed),
              SCIC,	8,
              Offset(0xf1),
              BRLV,	8,
              Offset(0xfe),
              DCBL,	8,
              ACBL,	8
          }
          Device(ADP1) {
              Name(_HID, "ACPI0003")
              Name(BFLG, 0x01)
              Name(ACP, 0x01)
              Method(_PSR) {
                  If(\_SB.PCI0.SBRG.EC.POWS) {
                      Return(One)
                  }
                  Else {
                      Return(Zero)
                  }
              }
              Name(_PCL, Package(0x01) {
                  \_SB,
              })
          }
          Name(BIF0, Package(0x0d) {
              0x01,
              0x1130,
              0x1130,
              0x01,
              0x39d0,
              0x00,
              0x00,
              0x01,
              0x01,
              "MS\x2dN021",
              "1",
              "LION",
              "MSI\x20Corp.",
          })
          Name(STAT, Package(0x04) {
              0x02,
              0x0500,
              0x0800,
              0x03e8,
          })
          Device(BAT1) {
              Name(_HID, 0x0a0cd041)
              Name(_UID, 0x01)
              Name(_PCL, Package(0x01) {
                  \_SB,
              })
              Name(SBT1, 0x3a)
              Name(SBT2, 0x3a)
              Name(FLG, 0x00)
              Method(_STA) {
                  If(\_SB.PCI0.SBRG.EC.MYEC) {
                      If(\_SB.PCI0.SBRG.EC.MBTS) {
                          Return(0x1f)
                      }
                      Else {
                          Return(0x0f)
                      }
                  }
                  Else {
                      Return(0x0f)
                  }
              }
              Method(_BIF) {
                  If(\_SB.PCI0.SBRG.EC.MYEC) {
                      UPBI()
                  }
                  Else {
                      IVBI()
                      Store(0x99, DBG8)
                      Sleep(0x03e8)
                  }
                  Return(BIF0)
              }
              Method(_BST) {
                  If(\_SB.PCI0.SBRG.EC.MYEC) {
                      UPBS()
                  }
                  Else {
                      IVBS()
                  }
                  Return(STAT)
              }
              Method(IVBI) {
                  Store(0xffffffff, Index(BIF0, 0x01, ))
                  Store(0xffffffff, Index(BIF0, 0x02, ))
                  Store(0xffffffff, Index(BIF0, 0x04, ))
                  Store("Wrong", Index(BIF0, 0x09, ))
                  Store("\x20", Index(BIF0, 0x0a, ))
                  Store("Wrong", Index(BIF0, 0x0b, ))
                  Store("Wrong", Index(BIF0, 0x0c, ))
              }
              Method(IVBS) {
                  Store(0x00, Index(STAT, 0x00, ))
                  Store(0xffffffff, Index(STAT, 0x01, ))
                  Store(0xffffffff, Index(STAT, 0x02, ))
                  Store(0x2710, Index(STAT, 0x03, ))
              }
              Method(UPBI) {
                  Store(0x00, Local0)
                  Store(0x00, Local1)
                  Store(0x00, Local2)
                  Store(0x00, Local3)
                  Store(MDCH, Local0)
                  Store(MDCL, Local1)
                  ShiftLeft(Local0, 0x08, Local0)
                  Or(Local0, Local1, Local0)
                  Store(Local0, Index(BIF0, 0x01, ))
                  Store(MFCH, Local0)
                  Store(MFCL, Local1)
                  ShiftLeft(Local0, 0x08, Local0)
                  Or(Local0, Local1, Local1)
                  Store(Local1, Index(BIF0, 0x02, ))
                  Store(MDVH, Local0)
                  Store(MDVL, Local2)
                  ShiftLeft(Local0, 0x08, Local0)
                  Or(Local0, Local2, Local2)
                  Store(Local2, Index(BIF0, 0x04, ))
                  Store("\x0a", Index(BIF0, 0x0a, ))
                  Store("LION\x0a", Index(BIF0, 0x0b, ))
                  Store(CTID, Local0)
                  If(LEqual(Local0, 0x00)) {
                      Store("MS\x2dN021\x0a", Index(BIF0, 0x09, ))
                      Store("MSI\x20Corp.\x0a", Index(BIF0, 0x0c, ))
                  }
                  Else {
                      Store("\x3fMODEL\x0a", Index(BIF0, 0x09, ))
                      Store("\x3fCUSTOMER\x0a", Index(BIF0, 0x0c, ))
                  }
              }
              Method(UPBS) {
                  Store(0x00, Local0)
                  Store(0x00, Local1)
                  Store(0x00, Local2)
                  Store(0x00, Local3)
                  Store(0x00, Local4)
                  Store(0x00, Local7)
                  Store(MBTS, Local0)
                  If(LEqual(Local0, 0x01)) {
                      Store(POWS, Local0)
                      If(LEqual(Local0, 0x01)) {
                          Store(MBCS, Local1)
                          If(LEqual(Local1, 0x01)) {
                              Or(Local4, 0x02, Local4)
                          }
                      }
                      Else {
                          Or(Local4, 0x01, Local4)
                          Store(MBLS, Local0)
                          If(LEqual(Local0, 0x01)) {
                              Or(Local4, 0x04, Local4)
                          }
                      }
                      Store(POWS, Local0)
                      If(LEqual(Local0, 0x01)) {
                          Store(MBCS, Local0)
                          If(LEqual(Local0, 0x01)) {
                              Store(MCUH, Local0)
                              Store(MCUL, Local1)
                              ShiftLeft(Local0, 0x08, Local0)
                              Or(Local0, Local1, Local1)
                              If(LEqual(Local1, 0xffff)) {
                                  Store(0xffffffff, Local1)
                              }
                              Store(Local1, Index(STAT, 0x01, ))
                          }
                          Else {
                              Store(0x00, Index(STAT, 0x01, ))
                          }
                      }
                      Else {
                          Store(MCUH, Local0)
                          Store(MCUL, Local1)
                          ShiftLeft(Local0, 0x08, Local0)
                          Or(Local0, Local1, Local1)
                          XOr(Local1, 0xffff, Local1)
                          If(LEqual(Local1, 0x00)) {
                              Store(0xffffffff, Local1)
                          }
                          Store(Local1, Index(STAT, 0x01, ))
                      }
                      If(LEqual(MRCH, 0x00)) {
                          If(LEqual(MRCL, 0x00)) {
                              Store(0x01, \_SB.PCI0.SBRG.EC.BAT1.FLG)
                              Store(0x01, \_SB.PCI0.SBRG.EC.BSFL)
                          }
                      }
                      If(LEqual(\_SB.PCI0.SBRG.EC.BAT1.FLG, 0x00)) {
                          Store(MRCH, Local0)
                          Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT1)
                          Store(MRCL, Local0)
                          Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT2)
                      }
                      Else {
                          Store(\_SB.PCI0.SBRG.EC.BAT1.SBT1, Local0)
                          Store(Local0, MRCH)
                          Store(\_SB.PCI0.SBRG.EC.BAT1.SBT2, Local0)
                          Store(Local0, MRCL)
                          Store(0x00, \_SB.PCI0.SBRG.EC.BAT1.FLG)
                      }
                      Store(MRCH, Local0)
                      Store(MRCL, Local2)
                      ShiftLeft(Local0, 0x08, Local0)
                      Or(Local0, Local2, Local2)
                      Store(Local2, Index(STAT, 0x02, ))
                      Store(MVOH, Local0)
                      Store(MVOL, Local3)
                      ShiftLeft(Local0, 0x08, Local0)
                      Or(Local0, Local3, Local3)
                      Store(Local3, Index(STAT, 0x03, ))
                      Store(Local4, Index(STAT, 0x00, ))
                      Sleep(0x64)
                  }
                  Else {
                      IVBS()
                  }
              }
          }
          Device(LID0) {
              Name(_HID, 0x0d0cd041)
              Method(_LID) {
                  If(\_SB.PCI0.SBRG.EC.MYEC) {
                      Store(\_SB.PCI0.SBRG.EC.LIDS, Local0)
                  }
                  Else {
                      Store(0x01, Local0)
                  }
                  Return(Local0)
              }
          }
          Method(_Q80) {
              Store(0x80, SCIC)
              Store(0x80, DBG8)
          }
          Method(_Q81) {
              Store(0x81, SCIC)
              Store(0x81, DBG8)
              Store(One, CHET)
              Or(0x01, \PTHR, \PTHR)
              Notify(\_PR.CPU0, 0x80)
              Sleep(0x64)
              Notify(\_PR.CPU1, 0x80)
          }
          Method(_Q82) {
              Store(0x82, SCIC)
              Store(0x82, DBG8)
              Store(One, CHET)
              And(0xfe, \PTHR, \PTHR)
              Notify(\_PR.CPU0, 0x80)
              Sleep(0x64)
              Notify(\_PR.CPU1, 0x80)
          }
          Method(_Q83) {
              Store(0x83, SCIC)
              Store(0x83, DBG8)
              Store(0x00, Local0)
              Store(POWS, Local0)
              If(LEqual(Local0, 0x01)) {
                  Store(0x01, \_SB.PCI0.SBRG.EC.ADP1.ACP)
              }
              Else {
                  Store(0x00, \_SB.PCI0.SBRG.EC.ADP1.ACP)
              }
              Notify(\_SB.PCI0.SBRG.EC.ADP1, 0x80)
              Sleep(0x64)
              If(\_OSI("Windows\x202006")) {
              }
              Else {
                  Store(0x8c, APMC)
              }
          }
          Method(_Q84) {
              Store(0x84, SCIC)
              Store(0x84, DBG8)
              Notify(\_SB.PCI0.SBRG.EC.LID0, 0x80)
          }
          Method(_QBD) {
              Store(0xbd, SCIC)
              Store(0xbd, DBG8)
              Notify(\_SB.SLPB, 0x80)
          }
          Method(_Q85) {
              Store(0x85, SCIC)
              Store(0x85, DBG8)
          }
          Method(_Q86) {
              Store(0x86, SCIC)
              Store(0x86, DBG8)
          }
          Method(_Q87) {
              Store(0x87, SCIC)
              Store(0x87, DBG8)
              Store(0x00, Local0)
              Store(MBTS, Local0)
              If(LEqual(Local0, 0x01)) {
                  Store(0x01, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                  If(LEqual(MRCH, 0x00)) {
                      If(LEqual(MRCL, 0x00)) {
                          Store(0x01, \_SB.PCI0.SBRG.EC.BAT1.FLG)
                          Store(0x01, \_SB.PCI0.SBRG.EC.BSFL)
                      }
                  }
                  If(LEqual(\_SB.PCI0.SBRG.EC.BAT1.FLG, 0x00)) {
                      Store(MRCH, Local0)
                      Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT1)
                      Store(MRCL, Local0)
                      Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT2)
                  }
                  Else {
                      Store(\_SB.PCI0.SBRG.EC.BAT1.SBT1, Local0)
                      Store(Local0, MRCH)
                      Store(\_SB.PCI0.SBRG.EC.BAT1.SBT2, Local0)
                      Store(Local0, MRCL)
                      Store(0x00, \_SB.PCI0.SBRG.EC.BAT1.FLG)
                  }
                  Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x80)
                  Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x81)
              }
              Else {
                  Store(0x00, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                  Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x81)
              }
              Notify(\_SB.PCI0.SBRG.EC.ADP1, 0x80)
          }
          Method(_Q77) {
              Store(0x77, SCIC)
              Store(0x77, DBG8)
              Store(0x00, Local0)
              Store(MBTS, Local0)
              If(LEqual(Local0, 0x01)) {
                  Store(0x01, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                  Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x80)
              }
              Else {
                  Store(0x00, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
                  Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x81)
              }
              Notify(\_SB.PCI0.SBRG.EC.ADP1, 0x80)
          }
          Method(_Q88) {
              Store(0x88, SCIC)
              Store(0x88, DBG8)
          }
          Method(_Q89) {
              Store(0x89, SCIC)
              Store(0x89, DBG8)
          }
          Method(_Q8A) {
              Store(0x8a, SCIC)
              Store(0x8a, DBG8)
              Store(0x01, \_SB.PCI0.SBRG.EC.CTSD)
              Notify(\_TZ.THRM, 0x80)
          }
          Method(_Q8B) {
              Store(0x8b, SCIC)
              Store(0x8b, DBG8)
          }
          Method(_Q8C) {
              Store(0x8c, SCIC)
              Store(0x8c, DBG8)
          }
          Method(_Q90) {
              Store(0x90, SCIC)
              Store(0x90, DBG8)
          }
          Method(_QB4) {
              Store(0xb4, SCIC)
              Store(0xb4, DBG8)
              If(LEqual(\_SB.PCI0.IGD.SWIT, 0x00)) {
                  Store(0xb4, APMC)
                  Store(APMS, Local0)
                  Store(Local0, DBG8)
                  If(LEqual(\_SB.PCI0.IGD.GDTS, 0x00)) {
                      If(LEqual(Local0, 0x01)) {
                          If(LEqual(\_SB.PCI0.IGD.GDGS, 0x01)) {
                              Store(0x00, \_SB.PCI0.IGD.LCD._DGS)
                              Store(0x01, \_SB.PCI0.IGD.CRT._DGS)
                          }
                          If(LEqual(\_SB.PCI0.IGD.GDGS, 0x02)) {
                              Store(0x01, \_SB.PCI0.IGD.LCD._DGS)
                              Store(0x01, \_SB.PCI0.IGD.CRT._DGS)
                          }
                          If(LEqual(\_SB.PCI0.IGD.GDGS, 0x03)) {
                              Store(0x01, \_SB.PCI0.IGD.LCD._DGS)
                              Store(0x00, \_SB.PCI0.IGD.CRT._DGS)
                          }
                          If(LNot(LLess(\_SB.PCI0.IGD.GDGS, 0x03))) {
                              Store(0x01, \_SB.PCI0.IGD.GDGS)
                          }
                          Else {
                              Add(0x01, \_SB.PCI0.IGD.GDGS,  
 \_SB.PCI0.IGD.GDGS)
                          }
                      }
                      Notify(\_SB.PCI0.IGD, 0x80)
                  }
              }
          }
          Method(_QB5) {
              Store(0xb5, SCIC)
              Store(0xb5, DBG8)
          }
          Method(_QB6) {
              Store(0xb6, SCIC)
              Store(0xb6, DBG8)
          }
          Method(_QB7) {
              Store(0xb7, SCIC)
              Store(0xb7, DBG8)
              If(\_OSI("Windows\x202006")) {
                  Notify(\_SB.PCI0.IGD.LCD, 0x87)
              }
              Else {
                  If(LNot(LEqual(BRLV, 0x00))) {
                      Store(BRLV, Local0)
                      Decrement(Local0)
                      Store(Local0, BRLV)
                  }
              }
          }
          Method(_QB8) {
              Store(0xb8, SCIC)
              Store(0xb8, DBG8)
              If(\_OSI("Windows\x202006")) {
                  Notify(\_SB.PCI0.IGD.LCD, 0x86)
              }
              Else {
                  If(LNot(LEqual(BRLV, 0x08))) {
                      Store(BRLV, Local0)
                      Increment(Local0)
                      Store(Local0, BRLV)
                  }
              }
          }
          Method(_QB9) {
              Store(0xb9, SCIC)
              Store(0xb9, DBG8)
              Store(0x00, \_SB.PCI0.SBRG.EC.HSTT)
          }
          OperationRegion(LP4D, SystemIO, 0x4d, 0x02)
          Field(LP4D, WordAcc, NoLock, Preserve) {
              IO4D,	16
          }
          OperationRegion(LP4F, SystemIO, 0x4f, 0x01)
          Field(LP4F, ByteAcc, NoLock, Preserve) {
              IO4F,	8
          }
          OperationRegion(IO, SystemIO, 0x62, 0x05)
          Field(IO, ByteAcc, Lock, Preserve) {
              DAT1,	8,
              Offset(0x4),
              CMD1,	8
          }
          Field(IO, ByteAcc, Lock, Preserve) {
              Offset(0x4),
              OUTS,	1,
              INPS,	1
          }
          Method(IRDY, 0, Serialized) {
              Return(LNot(INPS))
          }
          Method(ORDY, 0, Serialized) {
              Return(OUTS)
          }
          Method(WATI, 0, Serialized) {
              Store(0x32, Local0)
              While(LAnd(Local0, LNot(IRDY()))) {
                  Sleep(0x01)
                  Decrement(Local0)
              }
              Return(IRDY())
          }
          Method(WATO, 0, Serialized) {
              Store(0x32, Local0)
              While(LAnd(Local0, LNot(ORDY()))) {
                  Sleep(0x01)
                  Decrement(Local0)
              }
              Return(ORDY())
          }
          Method(CLRB, 0, Serialized) {
              While(WATO()) {
                  Store(DAT1, Local0)
              }
          }
          Method(RDEC, 1, Serialized) {
              If(WATI()) {
                  Store(0x80, CMD1)
                  If(WATI()) {
                      Store(Arg0, DAT1)
                      If(WATO()) {
                          Return(DAT1)
                      }
                  }
              }
              Return(Zero)
          }
          Method(WREC, 2, Serialized) {
              Noop
          }
          Method(QREC, 0, Serialized) {
              Noop
          }
          Method(_QC0) {
              Store(0xc0, \_SB.PCI0.SBRG.EC.SCM0.TDED)
              Store(0xc0, DBG8)
              Notify(SCM0, 0xc0)
          }
          Device(SCM0) {
              Name(_HID, "pnp0c14")
              Name(_UID, 0x00)
              Name(TDVR, 0x12)
              Name(_WDG, Buffer(0xc8) {0x6a, 0x8d, 0x41, 0x24, 0x79,  
 0xa, 0x4c, 0x52, 0x9a, 0xb1, 0x18, 0xb7, 0x8c, 0xa6, 0x8c, 0xe7,  
 0x41, 0x41, 0x22, 0x1, 0x6b, 0xd5, 0xfb, 0x4a, 0x91, 0x9f, 0x49,  
 0x8f, 0x81, 0xf5, 0x99, 0x5b, 0xa7, 0x38, 0x22, 0xaf, 0x41, 0x42,  
 0x2, 0x1, 0x6c, 0xba, 0x3c, 0x2d, 0x9c, 0x1c, 0x41, 0x7f, 0xb5, 0x4c,  
 0xf5, 0xd5, 0xd5, 0x80, 0xd4, 0x82, 0x41, 0x43, 0x1, 0x1, 0x6d, 0x2,  
 0xba, 0x40, 0x5d, 0x7, 0x4a, 0xcd, 0x97, 0x10, 0xf7, 0xc5, 0x73,  
 0x47, 0xca, 0xc9, 0x41, 0x44, 0xf, 0x1, 0x6e, 0xcf, 0xbc, 0x8d, 0xb4,  
 0x9d, 0x46, 0xe, 0xa3, 0xf2, 0x99, 0xaf, 0xaa, 0xa7, 0x7a, 0x7a,  
 0x41, 0x45, 0xd, 0x1, 0x6f, 0x21, 0x2a, 0xbd, 0xb9, 0x2f, 0x40, 0xa6,  
 0xb8, 0x7, 0xdd, 0xdb, 0xad, 0x65, 0x68, 0x91, 0x41, 0x46, 0x13, 0x1,  
 0x7a, 0xec, 0xc3, 0x1e, 0x9b, 0x1e, 0x4a, 0xe7, 0x90, 0x26, 0xcf,  
 0x12, 0x2b, 0xb, 0xbd, 0x21, 0x41, 0x47, 0x12, 0x1, 0x7b, 0x3d, 0x75,  
 0xa1, 0x21, 0xb6, 0x4a, 0xde, 0xb4, 0x1a, 0x55, 0x71, 0x6a, 0xe,  
 0xce, 0x7a, 0x41, 0x48, 0x15, 0x1, 0x7c, 0x3d, 0x75, 0xa1, 0x21,  
 0xb6, 0x4a, 0xde, 0xb4, 0x1a, 0x55, 0x71, 0x6a, 0xe, 0xce, 0x7a,  
 0x41, 0x49, 0x8, 0x1, 0x8a, 0xc3, 0x3c, 0x5b, 0xd9, 0x40, 0x45, 0x72,  
 0x8a, 0xe6, 0x11, 0x45, 0xb7, 0x51, 0xbe, 0x3f, 0xc0, 0x0, 0x1, 0x9 })
              OperationRegion(EC, EmbeddedControl, 0x00, 0x0100)
              Field(EC, ByteAcc, NoLock, Preserve) {
                  Offset(0x2d),
                  T2D0,	1,
                  T2D1,	4,
                  T2D5,	3,
                  TD2E,	8,
                  TD2F,	8,
                  TD30,	8,
                  TD31,	8,
                  TD32,	8,
                  TD33,	8,
                  Offset(0x35),
                  TD35,	8,
                  TD36,	8,
                  Offset(0x38),
                  TD38,	16,
                  TD3A,	16,
                  TD3C,	16,
                  TD3E,	16,
                  TD40,	16,
                  TD42,	16,
                  TD44,	16,
                  TD46,	16,
                  TD48,	16,
                  TD4A,	16,
                  TD4C,	16,
                  Offset(0x50),
                  TD50,	16,
                  TD52,	16,
                  TD54,	16,
                  TD56,	16,
                  TD58,	16,
                  TD5A,	16,
                  TD5C,	16,
                  TD5E,	16,
                  TD60,	16,
                  TD62,	16,
                  TD64,	16,
                  Offset(0x68),
                  TD68,	8,
                  TD69,	8,
                  TD6A,	8,
                  TD6B,	8,
                  TD6C,	8,
                  TD6D,	8,
                  TD6E,	8,
                  TD6F,	8,
                  TD70,	8,
                  TD71,	8,
                  TD72,	8,
                  TD73,	8,
                  TD74,	8,
                  TD75,	8,
                  TD76,	8,
                  TD77,	8,
                  TD78,	8,
                  TD79,	8,
                  Offset(0x80),
                  TD80,	8,
                  TD81,	8,
                  TD82,	8,
                  TD83,	8,
                  TD84,	8,
                  TD85,	8,
                  TD86,	8,
                  TD87,	8,
                  TD88,	8,
                  TD89,	8,
                  TD8A,	8,
                  TD8B,	8,
                  TD8C,	8,
                  TD8D,	8,
                  TD8E,	8,
                  TD8F,	8,
                  TD90,	8,
                  Offset(0xa0),
                  TDA0,	8,
                  TDA1,	8,
                  TDA2,	8,
                  TDA3,	8,
                  TDA4,	8,
                  TDA5,	8,
                  TDA6,	8,
                  TDA7,	8,
                  TDA8,	8,
                  TDA9,	8,
                  TDAA,	8,
                  TDAB,	8,
                  TDAC,	8,
                  TDAD,	8,
                  TDAE,	8,
                  TDAF,	8,
                  TDB0,	8,
                  TDB1,	8,
                  TDB2,	8,
                  TDB3,	8,
                  TDB4,	8,
                  TDB5,	8,
                  TDB6,	8,
                  TDB7,	8,
                  TDB8,	8,
                  TDB9,	8,
                  TDBA,	8,
                  TDBB,	8,
                  Offset(0xc8),
                  TDC8,	8,
                  TDC9,	8,
                  TDCA,	8,
                  TDCB,	8,
                  TDCC,	8,
                  TDCD,	8,
                  TDCE,	8,
                  TDCF,	8,
                  Offset(0xe0),
                  TDE0,	8,
                  Offset(0xe3),
                  TDE3,	8,
                  TE40,	3,
                  TE43,	5,
                  TDE5,	8,
                  TDE6,	8,
                  TDE7,	8,
                  TDE8,	8,
                  TDE9,	8,
                  Offset(0xed),
                  TDED,	8,
                  TDEE,	8,
                  Offset(0xf0),
                  TDF0,	8,
                  TDF1,	8,
                  TDF2,	8,
                  TDF3,	8,
                  TDF4,	8,
                  TDF5,	8,
                  TDF6,	8,
                  TDF7,	8,
                  TDF8,	8,
                  TDF9,	8,
                  TDFA,	8,
                  TDFB,	8,
                  TDFC,	8,
                  TDFD,	8,
                  TDFE,	8,
                  TDFF,	8
              }
              Method(WQAA, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(T2D0, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(T2D1, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(TDEE, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(T2D5, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(TDE5, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(TDE6, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(TDA0, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(TDA1, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(TDA2, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(TDA3, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(TDA4, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(TDA5, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(TDA6, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(TDA7, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(TDA8, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(TDA9, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(TDAA, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(TDAB, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x12)) {
                      Store(TDAC, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x13)) {
                      Store(TDAD, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x14)) {
                      Store(TDAE, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x15)) {
                      Store(TDAF, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x16)) {
                      Store(TDB0, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x17)) {
                      Store(TDB1, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x18)) {
                      Store(TDB2, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x19)) {
                      Store(TDB3, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x1a)) {
                      Store(TDB4, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x1b)) {
                      Store(TDB5, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x1c)) {
                      Store(TDB6, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x1d)) {
                      Store(TDB7, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x1e)) {
                      Store(TDB8, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x1f)) {
                      Store(TDB9, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x20)) {
                      Store(TDBA, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x21)) {
                      Store(TDBB, Local0)
                      Return(Local0)
                  }
              }
              Method(WQAB, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TD2E, Local1)
                      Return(Local1)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(TD2F, Local1)
                      Return(Local1)
                  }
              }
              Method(WQAC, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TD30, Local2)
                      Return(Local2)
                  }
              }
              Method(WQAD, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TD31, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(TD38, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(TD3A, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(TD3C, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(TD3E, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(TD40, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(TD42, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(TD44, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(TD46, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(TD48, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(TD4A, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(TD4C, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(TDE8, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(TD35, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(TD36, Local0)
                      Return(Local0)
                  }
              }
              Method(WQAE, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TD32, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(TD50, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(TD52, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(TD54, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(TD56, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(TD58, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(TD5A, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(TD5C, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(TD5E, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(TD60, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(TD62, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(TD64, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(TDE9, Local0)
                      Return(Local0)
                  }
              }
              Method(WQAF, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TD33, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(TD68, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(TD71, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(TD70, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(TD69, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(TD6A, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(TD6B, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(TD6C, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(TD6D, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(TD6E, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(TD6F, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(TD72, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(TD73, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(TD74, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(TD75, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(TD76, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(TD77, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(TD78, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x12)) {
                      Store(TD79, Local0)
                      Return(Local0)
                  }
              }
              Method(WQAG, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TD33, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(TD80, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(TD89, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(TD88, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(TD81, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(TD82, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(TD83, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(TD84, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(TD85, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(TD86, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(TD87, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(TD8A, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(TD8B, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(TD8C, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(TD8D, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(TD8E, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(TD8F, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(TD90, Local0)
                      Return(Local0)
                  }
              }
              Method(WQAH, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TE40, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(TE43, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(TDE7, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(TDF0, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(TDF1, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(TDFE, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(TDFF, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(TDF2, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(TDF3, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(TDF4, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(TDF5, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(TDF6, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(TDF7, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(TDF8, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(TDF9, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(TDFA, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(TDFB, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(TDFC, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x12)) {
                      Store(TDFD, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x13)) {
                      Store(TDE0, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x14)) {
                      Store(TDE3, Local0)
                      Return(Local0)
                  }
              }
              Method(WQAI, 1) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(TDCF, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(TDVR, TDCE)
                      Store(TDCE, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(TDCD, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(TDCC, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(TDCB, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(TDCA, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(TDC9, Local0)
                      Return(Local0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(TDC8, Local0)
                      Return(Local0)
                  }
              }
              Method(WSAA, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, T2D0)
                      Return(T2D0)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, T2D1)
                      Return(T2D1)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, TDEE)
                      Return(TDEE)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(Arg1, T2D5)
                      Return(T2D5)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(Arg1, TDE5)
                      Return(TDE5)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Arg1, TDE6)
                      Return(TDE6)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(Arg1, TDA0)
                      Return(TDA0)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(Arg1, TDA1)
                      Return(TDA1)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(Arg1, TDA2)
                      Return(TDA2)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(Arg1, TDA3)
                      Return(TDA3)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(Arg1, TDA4)
                      Return(TDA4)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(Arg1, TDA5)
                      Return(TDA5)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(Arg1, TDA6)
                      Return(TDA6)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(Arg1, TDA7)
                      Return(TDA7)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(Arg1, TDA8)
                      Return(TDA8)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(Arg1, TDA9)
                      Return(TDA9)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(Arg1, TDAA)
                      Return(TDAA)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(Arg1, TDAB)
                      Return(TDAB)
                  }
                  If(LEqual(Arg0, 0x12)) {
                      Store(Arg1, TDAC)
                      Return(TDAC)
                  }
                  If(LEqual(Arg0, 0x13)) {
                      Store(Arg1, TDAD)
                      Return(TDAD)
                  }
                  If(LEqual(Arg0, 0x14)) {
                      Store(Arg1, TDAE)
                      Return(TDAE)
                  }
                  If(LEqual(Arg0, 0x15)) {
                      Store(Arg1, TDAF)
                      Return(TDAF)
                  }
                  If(LEqual(Arg0, 0x16)) {
                      Store(Arg1, TDB0)
                      Return(TDB0)
                  }
                  If(LEqual(Arg0, 0x17)) {
                      Store(Arg1, TDB1)
                      Return(TDB1)
                  }
                  If(LEqual(Arg0, 0x18)) {
                      Store(Arg1, TDB2)
                      Return(TDB2)
                  }
                  If(LEqual(Arg0, 0x19)) {
                      Store(Arg1, TDB3)
                      Return(TDB3)
                  }
                  If(LEqual(Arg0, 0x1a)) {
                      Store(Arg1, TDB4)
                      Return(TDB4)
                  }
                  If(LEqual(Arg0, 0x1b)) {
                      Store(Arg1, TDB5)
                      Return(TDB5)
                  }
                  If(LEqual(Arg0, 0x1c)) {
                      Store(Arg1, TDB6)
                      Return(TDB6)
                  }
                  If(LEqual(Arg0, 0x1d)) {
                      Store(Arg1, TDB7)
                      Return(TDB7)
                  }
                  If(LEqual(Arg0, 0x1e)) {
                      Store(Arg1, TDB8)
                      Return(TDB8)
                  }
                  If(LEqual(Arg0, 0x1f)) {
                      Store(Arg1, TDB9)
                      Return(TDB9)
                  }
                  If(LEqual(Arg0, 0x20)) {
                      Store(Arg1, TDBA)
                      Return(TDBA)
                  }
                  If(LEqual(Arg0, 0x21)) {
                      Store(Arg1, TDBB)
                      Return(TDBB)
                  }
              }
              Method(WSAB, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TD2E)
                      Return(TD2E)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, TD2F)
                      Return(TD2F)
                  }
              }
              Method(WSAC, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TD30)
                      Return(TD30)
                  }
              }
              Method(WSAD, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TD31)
                      Return(TD31)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, TD38)
                      Return(TD38)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, TD3A)
                      Return(TD3A)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(Arg1, TD3C)
                      Return(TD3C)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(Arg1, TD3E)
                      Return(TD3E)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Arg1, TD40)
                      Return(TD40)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(Arg1, TD42)
                      Return(TD42)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(Arg1, TD44)
                      Return(TD44)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(Arg1, TD46)
                      Return(TD46)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(Arg1, TD48)
                      Return(TD48)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(Arg1, TD4A)
                      Return(TD4A)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(Arg1, TD4C)
                      Return(TD4C)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(Arg1, TDE8)
                      Return(TDE8)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(Arg1, TD35)
                      Return(TD35)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(Arg1, TD36)
                      Return(TD36)
                  }
              }
              Method(WSAE, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TD32)
                      Return(TD32)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, TD50)
                      Return(TD50)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, TD52)
                      Return(TD52)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(Arg1, TD54)
                      Return(TD54)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(Arg1, TD56)
                      Return(TD56)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Arg1, TD58)
                      Return(TD58)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(Arg1, TD5A)
                      Return(TD5A)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(Arg1, TD5C)
                      Return(TD5C)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(Arg1, TD5E)
                      Return(TD5E)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(Arg1, TD60)
                      Return(TD60)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(Arg1, TD62)
                      Return(TD62)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(Arg1, TD64)
                      Return(TD64)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(Arg1, TDE9)
                      Return(TDE9)
                  }
              }
              Method(WSAF, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TD33)
                      Return(TD33)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, TD68)
                      Return(TD68)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, TD71)
                      Return(TD71)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(Arg1, TD70)
                      Return(TD70)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(Arg1, TD69)
                      Return(TD69)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Arg1, TD6A)
                      Return(TD6A)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(Arg1, TD6B)
                      Return(TD6B)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(Arg1, TD6C)
                      Return(TD6C)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(Arg1, TD6D)
                      Return(TD6D)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(Arg1, TD6E)
                      Return(TD6E)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(Arg1, TD6F)
                      Return(TD6F)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(Arg1, TD72)
                      Return(TD72)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(Arg1, TD73)
                      Return(TD73)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(Arg1, TD74)
                      Return(TD74)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(Arg1, TD75)
                      Return(TD75)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(Arg1, TD76)
                      Return(TD76)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(Arg1, TD77)
                      Return(TD77)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(Arg1, TD78)
                      Return(TD78)
                  }
                  If(LEqual(Arg0, 0x12)) {
                      Store(Arg1, TD79)
                      Return(TD79)
                  }
              }
              Method(WSAG, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TD33)
                      Return(TD33)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, TD80)
                      Return(TD80)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, TD89)
                      Return(TD89)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(Arg1, TD88)
                      Return(TD88)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(Arg1, TD81)
                      Return(TD81)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Arg1, TD82)
                      Return(TD82)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(Arg1, TD83)
                      Return(TD83)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(Arg1, TD84)
                      Return(TD84)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(Arg1, TD85)
                      Return(TD85)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(Arg1, TD86)
                      Return(TD86)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(Arg1, TD87)
                      Return(TD87)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(Arg1, TD8A)
                      Return(TD8A)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(Arg1, TD8B)
                      Return(TD8B)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(Arg1, TD8C)
                      Return(TD8C)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(Arg1, TD8D)
                      Return(TD8D)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(Arg1, TD8E)
                      Return(TD8E)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(Arg1, TD8F)
                      Return(TD8F)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(Arg1, TD90)
                      Return(TD90)
                  }
              }
              Method(WSAH, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TE40)
                      Return(TE40)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, TE43)
                      Return(TE43)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, TDE7)
                      Return(TDE7)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(Arg1, TDF0)
                      Return(TDF0)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(Arg1, TDF1)
                      Return(TDF1)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Arg1, TDFE)
                      Return(TDFE)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(Arg1, TDFF)
                      Return(TDFF)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(Arg1, TDF2)
                      Return(TDF2)
                  }
                  If(LEqual(Arg0, 0x08)) {
                      Store(Arg1, TDF3)
                      Return(TDF3)
                  }
                  If(LEqual(Arg0, 0x09)) {
                      Store(Arg1, TDF4)
                      Return(TDF4)
                  }
                  If(LEqual(Arg0, 0x0a)) {
                      Store(Arg1, TDF5)
                      Return(TDF5)
                  }
                  If(LEqual(Arg0, 0x0b)) {
                      Store(Arg1, TDF6)
                      Return(TDF6)
                  }
                  If(LEqual(Arg0, 0x0c)) {
                      Store(Arg1, TDF7)
                      Return(TDF7)
                  }
                  If(LEqual(Arg0, 0x0d)) {
                      Store(Arg1, TDF8)
                      Return(TDF8)
                  }
                  If(LEqual(Arg0, 0x0e)) {
                      Store(Arg1, TDF9)
                      Return(TDF9)
                  }
                  If(LEqual(Arg0, 0x0f)) {
                      Store(Arg1, TDFA)
                      Return(TDFA)
                  }
                  If(LEqual(Arg0, 0x10)) {
                      Store(Arg1, TDFB)
                      Return(TDFB)
                  }
                  If(LEqual(Arg0, 0x11)) {
                      Store(Arg1, TDFC)
                      Return(TDFC)
                  }
                  If(LEqual(Arg0, 0x12)) {
                      Store(Arg1, TDFD)
                      Return(TDFD)
                  }
                  If(LEqual(Arg0, 0x13)) {
                      Store(Arg1, TDE0)
                      Return(TDE0)
                  }
                  If(LEqual(Arg0, 0x14)) {
                      Store(Arg1, TDE3)
                      Return(TDE3)
                  }
              }
              Method(WSAI, 2) {
                  If(LEqual(Arg0, 0x00)) {
                      Store(Arg1, TDCF)
                      Return(TDCF)
                  }
                  If(LEqual(Arg0, 0x01)) {
                      Store(Arg1, TDCE)
                      Return(TDCE)
                  }
                  If(LEqual(Arg0, 0x02)) {
                      Store(Arg1, TDCD)
                      Return(TDCD)
                  }
                  If(LEqual(Arg0, 0x03)) {
                      Store(Arg1, TDCC)
                      Return(TDCC)
                  }
                  If(LEqual(Arg0, 0x04)) {
                      Store(Arg1, TDCB)
                      Return(TDCB)
                  }
                  If(LEqual(Arg0, 0x05)) {
                      Store(Arg1, TDCA)
                      Return(TDCA)
                  }
                  If(LEqual(Arg0, 0x06)) {
                      Store(Arg1, TDC9)
                      Return(TDC9)
                  }
                  If(LEqual(Arg0, 0x07)) {
                      Store(Arg1, TDC8)
                      Return(TDC8)
                  }
              }
              Method(_WED, 1) {
                  If(LEqual(Arg0, 0xc0)) {
                      Name(EVRT, Buffer(0x02) {0x0, 0x0 })
                      Name(TMPB, 0x00)
                      Store(TDEE, TMPB)
                      Store(TMPB, Index(EVRT, 0x00, ))
                      If(LEqual(TMPB, 0x08)) {
                          Store(TE43, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x56)) {
                          Store(TD2E, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x57)) {
                          Store(TD2E, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x5f)) {
                          Store(TD2E, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x60)) {
                          Store(TE40, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x62)) {
                          Store(TDF1, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x63)) {
                          Store(TDF1, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x73)) {
                          Store(TE43, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0x79)) {
                          Store(TE43, Index(EVRT, 0x01, ))
                      }
                      If(LEqual(TMPB, 0xb4)) {
                          Store(TE43, Index(EVRT, 0x01, ))
                      }
                      Store(0x00, TDEE)
                      Return(EVRT)
                  }
                  Return(0x00)
              }
          }
      }
 }
 Name(\_S0, Package(0x04) {
      0x00,
      0x00,
      0x00,
      0x00,
 })
 If(SS1) {
      Name(\_S1, Package(0x04) {
          0x01,
          0x00,
          0x00,
          0x00,
      })
 }
 If(SS3) {
      Name(\_S3, Package(0x04) {
          0x05,
          0x00,
          0x00,
          0x00,
      })
 }
 If(SS4) {
      Name(\_S4, Package(0x04) {
          0x06,
          0x00,
          0x00,
          0x00,
      })
 }
 Name(\_S5, Package(0x04) {
      0x07,
      0x00,
      0x00,
      0x00,
 })
 Method(PTS, 1) {
      If(Arg0) {
          \_SB.PCI0.NPTS(Arg0)
          \_SB.PCI0.SBRG.SPTS(Arg0)
      }
 }
 Method(WAK, 1) {
      \_SB.PCI0.NWAK(Arg0)
      \_SB.PCI0.SBRG.SWAK(Arg0)
 }

 }
 /*
 APIC: Length=92, Revision=2, Checksum=242,
 	OEMID=LGE, OEM Table ID=LGPC, OEM Revision=0x6222004,
 	Creator ID=MSFT, Creator Revision=0x10013
   */
 /*
 SSDT: Length=1230, Revision=2, Checksum=220,
 	OEMID=PmRef, OEM Table ID=CpuPm, OEM Revision=0x3000,
 	Creator ID=INTL, Creator Revision=0x20051117
   */
 /*
 SSDT: Length=562, Revision=2, Checksum=247,
 	OEMID=PmRef, OEM Table ID=Cpu0Tst, OEM Revision=0x3000,
 	Creator ID=INTL, Creator Revision=0x20051117
   */
 /*
 SSDT: Length=160, Revision=2, Checksum=183,
 	OEMID=PmRef, OEM Table ID=Cpu1Tst, OEM Revision=0x3000,
 	Creator ID=INTL, Creator Revision=0x20051117
   */

 Regards,

 Dave

>How-To-Repeat:
 (As above.)

>Fix:

Unknown
>Release-Note:

>Audit-Trail:

Responsible-Changed-From-To: gnats-admin->kern-bug-people
Responsible-Changed-By: dholland@NetBSD.org
Responsible-Changed-When: Sat, 15 Aug 2009 18:47:25 +0000
Responsible-Changed-Why:
Sort out mangled PR.


>Unformatted:

NetBSD Home
NetBSD PR Database Search

(Contact us) $NetBSD: query-full-pr,v 1.43 2018/01/16 07:36:43 maya Exp $
$NetBSD: gnats_config.sh,v 1.9 2014/08/02 14:16:04 spz Exp $
Copyright © 1994-2017 The NetBSD Foundation, Inc. ALL RIGHTS RESERVED.