/*
 * Intel ACPI Component Architecture
 * AML/ASL+ Disassembler version 20160729-64
 * Copyright (c) 2000 - 2016 Intel Corporation
 *Â
 * Disassembling to symbolic ASL+ operators
 *
 * Disassembly of /Users/ottokatz/Downloads/DarwinDumper_3.0.4_24.10_22.04.06_MacBookPro8,3_Phoenix_Technologies_Ltd._X64_Yosemite_14F27_ottokatz/ACPI Tables/AML/DSDT.aml, Wed Oct 24 22:04:39 2018
 *
 * Original Table Header:
 *   Signature    "DSDT"
 *   Length      0x0000990D (39181)
 *   Revision     0x02
 *   Checksum     0xC4
 *   OEM ID      "Apple "
 *   OEM Table ID   "SNB-CPT"
 *   OEM Revision   0x00000000 (0)
 *   Compiler ID   "INTL"
 *   Compiler Version 0x20140214 (538182164)
 */
DefinitionBlock ("", "DSDT", 2, "Apple ", "SNB-CPT", 0x00000000)
{
  /*
   * iASL Warning: There were 5 external control methods found during
   * disassembly, but only 1 was resolved (4 unresolved). Additional
   * ACPI tables may be required to properly disassemble the code. This
   * resulting disassembler output file may not compile because the
   * disassembler did not know how many arguments to assign to the
   * unresolved methods. Note: SSDTs can be dynamically loaded at
   * runtime and may or may not be available via the host OS.
   *
   * In addition, the -fe option can be used to specify a file containing
   * control method external declarations with the associated method
   * argument counts. Each line of the file must be of the form:
   *   External (<method pathname>, MethodObj, <argument count>)
   * Invocation:
   *   iasl -fe refs.txt -d dsdt.aml
   *
   * The following methods were unresolved and many not compile properly
   * because the disassembler had to guess at the number of arguments
   * required for each:
   */
  External (_PR_.CPU0._PPC, MethodObj)  // 0 Arguments
  External (_SB_.PCI0.LPCB.EC0_.BSN0, IntObj)
  External (_SB_.PCI0.LPCB.EC0_.CAP0, IntObj)
  External (_SB_.PCI0.LPCB.EC0_.CRT0, IntObj)
  External (_SB_.PCI0.LPCB.EC0_.DCP0, IntObj)
  External (_SB_.PCI0.LPCB.EC0_.DVT0, IntObj)
  External (_SB_.PCI0.LPCB.EC0_.FCP0, IntObj)
  External (_SB_.PCI0.LPCB.EC0_.VOT0, IntObj)
  External (_SB_.PCI0.PEG0.PEGP.DD02, UnknownObj)
  External (CFGD, UnknownObj)
  External (HBRT, MethodObj)  // Warning: Unknown method, guessing 1 arguments
  External (HDOS, MethodObj)  // Warning: Unknown method, guessing 0 arguments
  External (HNOT, MethodObj)  // Warning: Unknown method, guessing 1 arguments
  External (HWID, IntObj)
  External (IDAB, MethodObj)  // Warning: Unknown method, guessing 0 arguments
  External (PDC0, UnknownObj)
  External (PDC1, UnknownObj)
  External (PDC2, UnknownObj)
  External (PDC3, UnknownObj)
  External (PDC4, UnknownObj)
  External (PDC5, UnknownObj)
  External (PDC6, UnknownObj)
  External (PDC7, UnknownObj)
  Name (SS1, Zero)
  Name (SS2, Zero)
  Name (SS3, One)
  Name (SS4, One)
  Name (SP2O, 0x4E)
  Name (SP1O, 0x164E)
  Name (IO1B, 0x0600)
  Name (IO1L, 0x70)
  Name (IO2B, 0x0680)
  Name (IO2L, 0x20)
  Name (IO3B, 0x0290)
  Name (IO3L, 0x10)
  Name (SP3O, 0x2E)
  Name (IO4B, 0x0A20)
  Name (IO4L, 0x20)
  Name (MCHB, 0xFED10000)
  Name (MCHL, 0x8000)
  Name (EGPB, 0xFED19000)
  Name (EGPL, 0x1000)
  Name (DMIB, 0xFED18000)
  Name (DMIL, 0x1000)
  Name (IFPB, 0xFED14000)
  Name (IFPL, 0x1000)
  Name (PEBS, 0xF8000000)
  Name (PELN, 0x04000000)
  Name (SMBS, 0x0580)
  Name (SMBL, 0x20)
  Name (PBLK, 0x0410)
  Name (PMBS, 0x0400)
  Name (PMLN, 0x80)
  Name (LVL2, 0x0414)
  Name (LVL3, 0x0415)
  Name (LVL4, 0x0416)
  Name (SMIP, 0xB2)
  Name (GPBS, 0x0500)
  Name (GPLN, 0x80)
  Name (APCB, 0xFEC00000)
  Name (APCL, 0x1000)
  Name (PM30, 0x0430)
  Name (SRCB, 0xFED1C000)
  Name (SRCL, 0x4000)
  Name (HPTB, 0xFED00000)
  Name (HPTC, 0xFED1F404)
  Name (ACPH, 0xDE)
  Name (ASSB, Zero)
  Name (AOTB, Zero)
  Name (AAXB, Zero)
  Name (PEHP, One)
  Name (SHPC, One)
  Name (PEPM, One)
  Name (PEER, One)
  Name (PECS, One)
  Name (DSSP, Zero)
  Name (FHPP, One)
  Name (FMBL, One)
  Name (FDTP, 0x02)
  Name (FUPS, 0x03)
  Name (BSH, Zero)
  Name (BEL, One)
  Name (BEH, 0x02)
  Name (BRH, 0x03)
  Name (BTF, 0x04)
  Name (BHC, 0x05)
  Name (BYB, 0x06)
  Name (BPH, 0x07)
  Name (BSHS, 0x08)
  Name (BELS, 0x09)
  Name (BRHS, 0x0A)
  Name (BTFS, 0x0B)
  Name (BEHS, 0x0C)
  Name (BPHS, 0x0D)
  Name (BTL, 0x10)
  Name (BSR, 0x14)
  Name (BOF, 0x20)
  Name (BEF, 0x21)
  Name (BLLE, 0x22)
  Name (BLLC, 0x23)
  Name (BLCA, 0x24)
  Name (BLLS, 0x25)
  Name (BLLP, 0x26)
  Name (BLLD, 0x27)
  Name (BHBE, 0x30)
  Name (BHBC, 0x31)
  Name (BHBN, 0x32)
  Name (BHBM, 0x33)
  Name (TCGM, One)
  Name (TRTP, One)
  Name (WDTE, One)
  Name (TRTD, 0x02)
  Name (TRTI, 0x03)
  Name (PDBR, 0x4D)
  Name (DPPB, 0xFED98000)
  Name (DPPL, 0x8000)
  Name (MY9F, Zero)
  OperationRegion (OMVS, SystemMemory, 0xBAF9EF98, 0x000E)
  Field (OMVS, AnyAcc, Lock, Preserve)
  {
    OVRS,  8,Â
    WFI1,  16,Â
    WFI2,  16,Â
    WIFS,  8,Â
    BEMQ,  8,Â
    QCKS,  8,Â
    BSBF,  8,Â
    MSRC,  8,Â
    NDSS,  8,Â
    ADSD,  8,Â
    CADD,  8,Â
    DDMB,  8
  }
  OperationRegion (GNVS, SystemMemory, 0xBAF41E18, 0x01B0)
  Field (GNVS, AnyAcc, Lock, Preserve)
  {
    OSYS,  16,Â
    SMIF,  8,Â
    PRM0,  8,Â
    PRM1,  8,Â
    SCIF,  8,Â
    PRM2,  8,Â
    PRM3,  8,Â
    LCKF,  8,Â
    PRM4,  8,Â
    PRM5,  8,Â
    P80D,  32,Â
    LIDS,  8,Â
    PWRS,  8,Â
    DBGS,  8,Â
    THOF,  8,Â
    ACT1,  8,Â
    ACTT,  8,Â
    PSVT,  8,Â
    TC1V,  8,Â
    TC2V,  8,Â
    TSPV,  8,Â
    CRTT,  8,Â
    DTSE,  8,Â
    DTS1,  8,Â
    DTS2,  8,Â
    DTSF,  8,Â
    Offset (0x25),Â
    REVN,  8,Â
    Offset (0x28),Â
    APIC,  8,Â
    TCNT,  8,Â
    PCP0,  8,Â
    PCP1,  8,Â
    PPCM,  8,Â
    PPMF,  32,Â
    C67L,  8,Â
    NATP,  8,Â
    CMAP,  8,Â
    CMBP,  8,Â
    LPTP,  8,Â
    FDCP,  8,Â
    CMCP,  8,Â
    CIRP,  8,Â
    SMSC,  8,Â
    W381,  8,Â
    SMC1,  8,Â
    IGDS,  8,Â
    TLST,  8,Â
    CADL,  8,Â
    PADL,  8,Â
    CSTE,  16,Â
    NSTE,  16,Â
    SSTE,  16,Â
    NDID,  8,Â
    DID1,  32,Â
    DID2,  32,Â
    DID3,  32,Â
    DID4,  32,Â
    DID5,  32,Â
    KSV0,  32,Â
    KSV1,  8,Â
    Offset (0x67),Â
    BLCS,  8,Â
    BRTL,  8,Â
    ALSE,  8,Â
    ALAF,  8,Â
    LLOW,  8,Â
    LHIH,  8,Â
    Offset (0x6E),Â
    EMAE,  8,Â
    EMAP,  16,Â
    EMAL,  16,Â
    Offset (0x74),Â
    MEFE,  8,Â
    DSTS,  8,Â
    Offset (0x78),Â
    TPMP,  8,Â
    TPME,  8,Â
    MORD,  8,Â
    TCGP,  8,Â
    PPRP,  32,Â
    PPRQ,  8,Â
    LPPR,  8,Â
    GTF0,  56,Â
    GTF2,  56,Â
    IDEM,  8,Â
    GTF1,  56,Â
    BID,  8,Â
    ACST,  8,Â
    DQST,  8,Â
    ATST,  8,Â
    NDST,  8,Â
    DPRM,  8,Â
    Offset (0xAA),Â
    ASLB,  32,Â
    IBTT,  8,Â
    IPAT,  8,Â
    ITVF,  8,Â
    ITVM,  8,Â
    IPSC,  8,Â
    IBLC,  8,Â
    IBIA,  8,Â
    ISSC,  8,Â
    I409,  8,Â
    I509,  8,Â
    I609,  8,Â
    I709,  8,Â
    IPCF,  8,Â
    IDMS,  8,Â
    IF1E,  8,Â
    HVCO,  8,Â
    NXD1,  32,Â
    NXD2,  32,Â
    NXD3,  32,Â
    NXD4,  32,Â
    NXD5,  32,Â
    NXD6,  32,Â
    NXD7,  32,Â
    NXD8,  32,Â
    GSMI,  8,Â
    PAVP,  8,Â
    Offset (0xE1),Â
    OSCC,  8,Â
    NEXP,  8,Â
    SBV1,  8,Â
    SBV2,  8,Â
    MRSN,  16,Â
    MSGA,  16,Â
    Offset (0xEB),Â
    DSEN,  8,Â
    ECON,  8,Â
    GPIC,  8,Â
    CTYP,  8,Â
    L01C,  8,Â
    VFN0,  8,Â
    VFN1,  8,Â
    VFN2,  8,Â
    VFN3,  8,Â
    VFN4,  8,Â
    Offset (0x100),Â
    NVGA,  32,Â
    NVHA,  32,Â
    AMDA,  32,Â
    DID6,  32,Â
    DID7,  32,Â
    DID8,  32,Â
    EBAS,  32,Â
    CPSP,  32,Â
    EECP,  32,Â
    EVCP,  32,Â
    XBAS,  32,Â
    OBS1,  32,Â
    OBS2,  32,Â
    OBS3,  32,Â
    OBS4,  32,Â
    OBS5,  32,Â
    OBS6,  32,Â
    OBS7,  32,Â
    OBS8,  32,Â
    BRID,  8,Â
    PRID,  16,Â
    Offset (0x151),Â
    DMFG,  8,Â
    Offset (0x157),Â
    ATMC,  8,Â
    PTMC,  8,Â
    ATRA,  8,Â
    PTRA,  8,Â
    PNHM,  32,Â
    TBAB,  32,Â
    TBAH,  32,Â
    RTIP,  8,Â
    TSOD,  8,Â
    ATPC,  8,Â
    PTPC,  8,Â
    PFLV,  8,Â
    BREV,  8,Â
    SGMD,  8,Â
    SGFL,  8,Â
    PWOK,  8,Â
    HLRS,  8,Â
    DSEL,  8,Â
    ESEL,  8,Â
    PSEL,  8,Â
    PWEN,  8,Â
    PRST,  8,Â
    MXD1,  32,Â
    MXD2,  32,Â
    MXD3,  32,Â
    MXD4,  32,Â
    MXD5,  32,Â
    MXD6,  32,Â
    MXD7,  32,Â
    MXD8,  32,Â
    GBAS,  16,Â
    Offset (0x19D),Â
    ALFP,  8,Â
    IMON,  8,Â
    PDTS,  8,Â
    PKGA,  8,Â
    PAMT,  8,Â
    AC0F,  8,Â
    AC1F,  8,Â
    DTS3,  8,Â
    DTS4,  8
  }
  OperationRegion (NV1, SystemIO, 0x72, 0x02)
  Field (NV1, ByteAcc, NoLock, Preserve)
  {
    INDX,  8,Â
    DATA,  8
  }
  IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
  {
    Offset (0x50),Â
    BRGA,  4,Â
    Offset (0x51),Â
    USBK,  1,Â
    Offset (0x52),Â
    OPTF,  4,Â
    SLPO,  4,Â
    OSTY,  8,Â
    BRGD,  4
  }
  Scope (_SB)
  {
    Device (AMW0)
    {
      Mutex (WMIX, 0x01)
      Name (_HID, "PNP0C14" /* Windows Management Instrumentation Device */) // _HID: Hardware ID
      Name (_UID, Zero) // _UID: Unique ID
      Method (STBY, 3, NotSerialized)
      {
        CreateByteField (Arg0, Arg1, TMP)
        TMP = Arg2
      }
      Method (STWD, 3, NotSerialized)
      {
        CreateWordField (Arg0, Arg1, TMP)
        TMP = Arg2
      }
      Method (STDW, 3, NotSerialized)
      {
        CreateDWordField (Arg0, Arg1, TMP)
        TMP = Arg2
      }
      Method (CLBY, 1, NotSerialized)
      {
        Local0 = Zero
        While (Local0 < SizeOf (Arg0))
        {
          STBY (Arg0, Local0, Zero)
          Local0++
        }
      }
      Name (_WDG, Buffer (0x78)
      {
        /* 0000 */ 0xBC, 0xDC, 0x9D, 0x8D, 0x97, 0xA9, 0xDA, 0x11, /* ........ */
        /* 0008 */ 0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, /* ..."..T. */
        /* 0010 */ 0x41, 0x41, 0x01, 0x00, 0xCE, 0x93, 0x05, 0xA8, /* AA...... */
        /* 0018 */ 0x97, 0xA9, 0xDA, 0x11, 0xB0, 0x12, 0xB6, 0x22, /* ......." */
        /* 0020 */ 0xA1, 0xEF, 0x54, 0x92, 0x42, 0x41, 0x01, 0x02, /* ..T.BA.. */
        /* 0028 */ 0x70, 0x76, 0x8C, 0xDD, 0xB5, 0x1C, 0xDB, 0x11, /* pv...... */
        /* 0030 */ 0xA9, 0x8B, 0x66, 0x9A, 0x0C, 0x20, 0x00, 0x08, /* ..f.. .. */
        /* 0038 */ 0x42, 0x43, 0x01, 0x02, 0x94, 0x59, 0xBB, 0x9D, /* BC...Y.. */
        /* 0040 */ 0x97, 0xA9, 0xDA, 0x11, 0xB0, 0x12, 0xB6, 0x22, /* ......." */
        /* 0048 */ 0xA1, 0xEF, 0x54, 0x92, 0xD0, 0x00, 0x01, 0x08, /* ..T..... */
        /* 0050 */ 0xE0, 0x6C, 0x77, 0xA3, 0x88, 0x1E, 0xDB, 0x11, /* .lw..... */
        /* 0058 */ 0xA9, 0x8B, 0x08, 0x00, 0x20, 0x0C, 0x9A, 0x66, /* .... ..f */
        /* 0060 */ 0x42, 0x43, 0x01, 0x00, 0x21, 0x12, 0x90, 0x05, /* BC..!... */
        /* 0068 */ 0x66, 0xD5, 0xD1, 0x11, 0xB2, 0xF0, 0x00, 0xA0, /* f....... */
        /* 0070 */ 0xC9, 0x06, 0x29, 0x10, 0x4D, 0x4F, 0x01, 0x00  /* ..).MO.. */
      })
      Name (INFO, Buffer (0x80) {})
      CreateWordField (INFO, Zero, INF0)
      CreateWordField (INFO, 0x02, INF1)
      CreateWordField (INFO, 0x04, INF2)
      CreateWordField (INFO, 0x06, INF3)
      CreateWordField (INFO, 0x08, INF4)
      CreateWordField (INFO, 0x0A, INF5)
      CreateWordField (INFO, 0x0C, INF6)
      CreateWordField (INFO, 0x0E, INF7)
      Name (ECD0, Zero)
      Method (WED0, 1, NotSerialized)
      {
        ECD0 = Arg0
        Return (Arg0)
      }
      Method (WCAA, 1, NotSerialized)
      {
        Return (Arg0)
      }
      Method (WQAA, 1, NotSerialized)
      {
        Acquire (WMIX, 0xFFFF)
        CLBY (INFO)
        If (Arg0 != Zero)
        {
          Local1 = INFO /* \_SB_.AMW0.INFO */
        }
        Else
        {
          STDW (INFO, Zero, 0x4C4C4544)
          STDW (INFO, 0x04, 0x494D5720)
          STDW (INFO, 0x08, Zero)
          STDW (INFO, 0x0C, 0x1000)
          Local1 = INFO /* \_SB_.AMW0.INFO */
        }
        Release (WMIX)
        Return (Local1)
      }
      Method (WSAA, 2, NotSerialized)
      {
        Return (Arg1)
      }
      Method (WMI, 2, NotSerialized)
      {
        Return (PHWM (Arg0, Arg1))
      }
      Method (WMBA, 3, NotSerialized)
      {
        CreateDWordField (Arg2, 0x28, WBUF)
        Local1 = (WBUF + 0x2C)
        If (Local1 <= 0x1000)
        {
          Local0 = WMI (Arg2, Local1)
        }
        Return (Local0)
      }
      Method (WMBC, 3, NotSerialized)
      {
        Return (Arg2)
      }
      Method (_WED, 1, NotSerialized) // _Wxx: Wake Event
      {
        If (Arg0 == 0xD0)
        {
          Return (INFO) /* \_SB_.AMW0.INFO */
        }
        CLBY (INFO)
        INFO = Arg0
        Return (INFO) /* \_SB_.AMW0.INFO */
      }
      Name (WQMO, Buffer (0x057A)
      {
        /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, /* FOMB.... */
        /* 0008 */ 0x6A, 0x05, 0x00, 0x00, 0x98, 0x1C, 0x00, 0x00, /* j....... */
        /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, /* DS...}.T */
        /* 0018 */ 0x18, 0xD9, 0x8D, 0x00, 0x01, 0x06, 0x18, 0x42, /* .......B */
        /* 0020 */ 0x10, 0x0F, 0x10, 0x22, 0x21, 0x04, 0x12, 0x01, /* ..."!... */
        /* 0028 */ 0xA1, 0xC8, 0x2C, 0x0C, 0x86, 0x10, 0x38, 0x2E, /* ..,...8. */
        /* 0030 */ 0x84, 0x1C, 0x40, 0x48, 0x1C, 0x14, 0x4A, 0x08, /* ..@H..J. */
        /* 0038 */ 0x84, 0xFA, 0x13, 0xC8, 0xAF, 0x00, 0x84, 0x0E, /* ........ */
        /* 0040 */ 0x05, 0xC8, 0x14, 0x60, 0x50, 0x80, 0x53, 0x04, /* ...`P.S. */
        /* 0048 */ 0x11, 0xF4, 0x2A, 0xC0, 0xA6, 0x00, 0x93, 0x02, /* ..*..... */
        /* 0050 */ 0x2C, 0x0A, 0xD0, 0x2E, 0xC0, 0xB2, 0x00, 0xDD, /* ,....... */
        /* 0058 */ 0x02, 0xA4, 0xC3, 0x12, 0x91, 0xE0, 0x28, 0x31, /* ......(1 */
        /* 0060 */ 0xE0, 0x28, 0x9D, 0xD8, 0xC2, 0x0D, 0x1B, 0xBC, /* .(...... */
        /* 0068 */ 0x50, 0x14, 0xCD, 0x20, 0x4A, 0x82, 0xCA, 0x05, /* P.. J... */
        /* 0070 */ 0xF8, 0x46, 0x10, 0x78, 0xB9, 0x02, 0x24, 0x4F, /* .F.x..$O */
        /* 0078 */ 0x40, 0x9A, 0x05, 0x18, 0x16, 0x60, 0x5D, 0x80, /* @....`]. */
        /* 0080 */ 0xEC, 0x21, 0x50, 0xA9, 0x43, 0x40, 0xC9, 0x19, /* .!P.C@.. */
        /* 0088 */ 0x02, 0x6A, 0x00, 0xAD, 0x4E, 0x40, 0xF8, 0x95, /* .j..N@.. */
        /* 0090 */ 0x4E, 0x09, 0x49, 0x10, 0xCE, 0x58, 0xC5, 0xE3, /* N.I..X.. */
        /* 0098 */ 0x6B, 0x16, 0x4D, 0xCF, 0x49, 0xCE, 0x31, 0xE4, /* k.M.I.1. */
        /* 00A0 */ 0x78, 0x5C, 0xE8, 0x41, 0xF0, 0x40, 0x0A, 0x40, /* x\.A.@.@ */
        /* 00A8 */ 0x58, 0x78, 0x08, 0x45, 0x80, 0x41, 0x49, 0x18, /* Xx.E.AI. */
        /* 00B0 */ 0x0B, 0x75, 0x31, 0x6A, 0xD4, 0x48, 0xD9, 0x80, /* .u1j.H.. */
        /* 00B8 */ 0x0C, 0x51, 0xDA, 0xA8, 0xD1, 0x03, 0x3A, 0xBF, /* .Q....:. */
        /* 00C0 */ 0x23, 0x39, 0xBB, 0xA3, 0x3B, 0x92, 0x04, 0x46, /* #9..;..F */
        /* 00C8 */ 0x3D, 0xA6, 0x63, 0x2C, 0x6C, 0x46, 0x42, 0x8D, /* =.c,lFB. */
        /* 00D0 */ 0xD1, 0x1C, 0x14, 0x81, 0xC6, 0x0D, 0xDA, 0x12, /* ........ */
        /* 00D8 */ 0x61, 0x35, 0xAE, 0xD8, 0x67, 0x66, 0xE1, 0xC3, /* a5..gf.. */
        /* 00E0 */ 0x12, 0xC6, 0x11, 0x1C, 0x58, 0x82, 0x46, 0xD1, /* ....X.F. */
        /* 00E8 */ 0x34, 0xC7, 0xB3, 0x0D, 0x91, 0xE0, 0x20, 0x42, /* 4..... B */
        /* 00F0 */ 0x63, 0x64, 0x40, 0xC8, 0xF3, 0xB0, 0x05, 0x7A, /* cd@....z */
        /* 00F8 */ 0xE4, 0x09, 0xEC, 0x1E, 0x51, 0x0A, 0x11, 0x34, /* ....Q..4 */
        /* 0100 */ 0xDF, 0x13, 0xA9, 0x51, 0x80, 0x36, 0x0C, 0xD9, /* ...Q.6.. */
        /* 0108 */ 0x3A, 0x1B, 0x68, 0xA8, 0xB1, 0x1A, 0x43, 0x11, /* :.h...C. */
        /* 0110 */ 0x44, 0x84, 0xA0, 0x51, 0x0C, 0x16, 0x21, 0x54, /* D..Q..!T */
        /* 0118 */ 0x88, 0xFF, 0x7F, 0x94, 0xA8, 0xA7, 0x14, 0x24, /* .......$ */
        /* 0120 */ 0x6A, 0x65, 0x20, 0x42, 0x0B, 0x66, 0x04, 0x66, /* je B.f.f */
        /* 0128 */ 0x7F, 0x10, 0x24, 0xC6, 0x99, 0x41, 0x87, 0x05, /* ..$..A.. */
        /* 0130 */ 0xCB, 0x00, 0x91, 0x11, 0x41, 0xA3, 0x61, 0x67, /* ....A.ag */
        /* 0138 */ 0x01, 0x0F, 0xC7, 0x33, 0x69, 0x7E, 0x62, 0x1A, /* ...3i~b. */
        /* 0140 */ 0x9C, 0x09, 0xC6, 0x86, 0x90, 0x06, 0x08, 0x89, /* ........ */
        /* 0148 */ 0x3A, 0x38, 0x50, 0x02, 0x4B, 0x19, 0x38, 0xB1, /* :8P.K.8. */
        /* 0150 */ 0x3D, 0x2E, 0x8D, 0xEF, 0x8C, 0xA3, 0x86, 0x38, /* =......8 */
        /* 0158 */ 0xF5, 0x33, 0xF3, 0x3F, 0xC2, 0x5B, 0xF0, 0x11, /* .3.?.[.. */
        /* 0160 */ 0x80, 0x8F, 0xC1, 0x83, 0x3D, 0x84, 0x80, 0x47, /* ....=..G */
        /* 0168 */ 0xC8, 0xCE, 0x00, 0x06, 0xC4, 0x7B, 0x9F, 0x34, /* .....{.4 */
        /* 0170 */ 0x99, 0x8B, 0xCF, 0x02, 0x30, 0x86, 0x0F, 0xD7, /* ....0... */
        /* 0178 */ 0xF8, 0x28, 0x34, 0x1E, 0x76, 0x3E, 0x60, 0xE3, /* .(4.v>`. */
        /* 0180 */ 0xE2, 0xF0, 0x3E, 0x14, 0x9C, 0x70, 0xB1, 0x20, /* ..>..p. */
        /* 0188 */ 0x0A, 0x00, 0x21, 0x59, 0xE7, 0x03, 0xF4, 0xAC, /* ..!Y.... */
        /* 0190 */ 0x8F, 0x2D, 0xE0, 0xC3, 0x40, 0xB3, 0x77, 0x08, /* .-..@.w. */
        /* 0198 */ 0x42, 0xF0, 0x22, 0xE0, 0xA3, 0x83, 0x8F, 0x1B, /* B."..... */
        /* 01A0 */ 0x1E, 0xF7, 0xF3, 0x06, 0x18, 0x0E, 0x07, 0x1E, /* ........ */
        /* 01A8 */ 0x8E, 0x4F, 0x1B, 0xC0, 0x65, 0x04, 0x5C, 0xDA, /* .O..e.\. */
        /* 01B0 */ 0x93, 0xC2, 0x04, 0x92, 0xFC, 0x04, 0x90, 0x18, /* ........ */
        /* 01B8 */ 0x18, 0xD4, 0x81, 0xC0, 0x07, 0x0B, 0xB8, 0x92, /* ........ */
        /* 01C0 */ 0xE0, 0x50, 0xC3, 0xF3, 0xC4, 0x1E, 0x10, 0xFE, /* .P...... */
        /* 01C8 */ 0xFF, 0x47, 0x79, 0x22, 0x2F, 0x06, 0x9E, 0xFE, /* .Gy"/... */
        /* 01D0 */ 0x63, 0x00, 0x8C, 0x03, 0x82, 0xA7, 0x75, 0x52, /* c.....uR */
        /* 01D8 */ 0xBE, 0x79, 0x3C, 0x48, 0x78, 0x50, 0x61, 0x12, /* .y<HxPa. */
        /* 01E0 */ 0xF8, 0x94, 0xC0, 0xD0, 0xF8, 0x71, 0x03, 0xAC, /* .....q.. */
        /* 01E8 */ 0xA3, 0xC6, 0x1F, 0x10, 0xE0, 0x9D, 0x24, 0xCE, /* ......$. */
        /* 01F0 */ 0xAF, 0xCF, 0x01, 0xE8, 0xD0, 0x70, 0x8A, 0x0C, /* .....p.. */
        /* 01F8 */ 0xE4, 0x35, 0xE0, 0xA4, 0x4F, 0xC9, 0xE3, 0x4B, /* .5..O..K */
        /* 0200 */ 0xE0, 0x33, 0x07, 0xEC, 0xBB, 0xC1, 0x61, 0x1C, /* .3....a. */
        /* 0208 */ 0x4C, 0x88, 0x08, 0xEF, 0x01, 0x4F, 0x1D, 0xBE, /* L....O.. */
        /* 0210 */ 0x6B, 0x3C, 0x0A, 0x04, 0x8A, 0xD0, 0xDB, 0x99, /* k<...... */
        /* 0218 */ 0x83, 0x9E, 0x42, 0x8C, 0x12, 0xED, 0xAC, 0xC2, /* ..B..... */
        /* 0220 */ 0x3C, 0x70, 0x44, 0xF1, 0x91, 0xC3, 0x08, 0xEF, /* <pD..... */
        /* 0228 */ 0x1E, 0xBE, 0x13, 0x3C, 0x80, 0xB4, 0x36, 0x39, /* ...<..69 */
        /* 0230 */ 0xE1, 0x06, 0x7A, 0xE6, 0x60, 0xD1, 0xCE, 0x2C, /* ..z.`.., */
        /* 0238 */ 0xB2, 0x00, 0xA2, 0x48, 0xA3, 0x41, 0x9D, 0x11, /* ...H.A.. */
        /* 0240 */ 0x7C, 0x1A, 0xF0, 0xB4, 0x9E, 0x62, 0x7C, 0x94, /* |....b|. */
        /* 0248 */ 0x30, 0xC8, 0x19, 0x1E, 0xD8, 0x73, 0xC2, 0x63, /* 0....s.c */
        /* 0250 */ 0x80, 0x07, 0xCC, 0xEE, 0x07, 0x3E, 0x4E, 0xF8, /* .....>N. */
        /* 0258 */ 0x5C, 0x80, 0x77, 0x0D, 0xA8, 0x19, 0xFA, 0xB0, /* \.w..... */
        /* 0260 */ 0x01, 0xE7, 0xD0, 0x81, 0x3F, 0x4D, 0xE0, 0x0F, /* ....?M.. */
        /* 0268 */ 0x16, 0xF8, 0xF1, 0xF8, 0x9A, 0xC3, 0x26, 0x9C, /* ......&. */
        /* 0270 */ 0xC0, 0xF2, 0x07, 0x81, 0x1A, 0x99, 0xA1, 0x3D, /* .......= */
        /* 0278 */ 0xCB, 0xD3, 0x7A, 0x0D, 0xF0, 0x69, 0xC7, 0x04, /* ..z..i.. */
        /* 0280 */ 0x3E, 0x6F, 0xF8, 0xFF, 0xFF, 0xCF, 0xF1, 0x78, /* >o.....x */
        /* 0288 */ 0xC0, 0xAF, 0xF8, 0x74, 0x41, 0xEE, 0x0A, 0x9E, /* ...tA... */
        /* 0290 */ 0xAF, 0xCF, 0x2E, 0xCC, 0xC6, 0x78, 0x50, 0xA3, /* .....xP. */
        /* 0298 */ 0xF0, 0x01, 0x07, 0x77, 0x76, 0xF1, 0x11, 0xC0, /* ...wv... */
        /* 02A0 */ 0x67, 0x17, 0xE0, 0x39, 0x89, 0x67, 0x09, 0xF0, /* g..9.g.. */
        /* 02A8 */ 0x1E, 0x02, 0x7C, 0x22, 0x89, 0xF7, 0xB0, 0x05, /* ..|".... */
        /* 02B0 */ 0x63, 0xC4, 0x78, 0xC8, 0x33, 0xAE, 0x7A, 0x18, /* c.x.3.z. */
        /* 02B8 */ 0xBA, 0x08, 0x58, 0xDD, 0x7D, 0x05, 0x75, 0xF4, /* ..X.}.u. */
        /* 02C0 */ 0x02, 0x13, 0xD4, 0x6B, 0x06, 0xEE, 0xF4, 0x02, /* ...k.... */
        /* 02C8 */ 0x7C, 0x4E, 0x59, 0xF0, 0xFE, 0xFF, 0xA7, 0x2C, /* |NY...., */
        /* 02D0 */ 0xE0, 0x7E, 0x55, 0xE0, 0x47, 0x14, 0x30, 0x40, /* .~U.G.0@ */
        /* 02D8 */ 0x76, 0x76, 0x3A, 0x11, 0xC2, 0x7B, 0xC9, 0x73, /* vv:..{.s */
        /* 02E0 */ 0x88, 0x6F, 0x57, 0x3E, 0x98, 0x04, 0x79, 0x0E, /* .oW>..y. */
        /* 02E8 */ 0x88, 0xF0, 0x94, 0xC5, 0xEF, 0x03, 0x51, 0x62, /* ......Qb */
        /* 02F0 */ 0x1E, 0x50, 0xA4, 0x28, 0x46, 0x0C, 0xF2, 0x84, /* .P.(F... */
        /* 02F8 */ 0xE5, 0xEB, 0x49, 0x0C, 0x43, 0x07, 0x0B, 0x17, /* ..I.C... */
        /* 0300 */ 0x3E, 0xC2, 0x53, 0x16, 0x60, 0xF1, 0x92, 0x85, /* >.S.`... */
        /* 0308 */ 0x39, 0x65, 0xC1, 0x7C, 0x1B, 0xF8, 0x94, 0x05, /* 9e.|.... */
        /* 0310 */ 0x8E, 0xFF, 0xFF, 0x29, 0x0B, 0x5C, 0xE3, 0x7E, /* ...).\.~ */
        /* 0318 */ 0xCA, 0x02, 0x66, 0xD2, 0x9F, 0x02, 0x3E, 0xD5, /* ..f...>. */
        /* 0320 */ 0xF8, 0x09, 0xA0, 0xE8, 0x07, 0x0B, 0x0A, 0xE3, /* ........ */
        /* 0328 */ 0x53, 0x16, 0xE0, 0x4A, 0xDE, 0x01, 0x01, 0x34, /* S..J...4 */
        /* 0330 */ 0x67, 0x27, 0xDF, 0x16, 0x0C, 0x76, 0xCC, 0xBE, /* g'...v.. */
        /* 0338 */ 0x64, 0xF8, 0x94, 0x08, 0x86, 0x43, 0x86, 0xEF, /* d....C.. */
        /* 0340 */ 0x54, 0x87, 0xF2, 0xC8, 0xF1, 0x14, 0xE0, 0x23, /* T......# */
        /* 0348 */ 0x16, 0xD8, 0xE3, 0x1C, 0x03, 0x74, 0x5C, 0xF1, /* .....t\. */
        /* 0350 */ 0x11, 0xCB, 0xFF, 0xFF, 0x23, 0x16, 0xC0, 0x8D, /* ....#... */
        /* 0358 */ 0x03, 0x08, 0xFE, 0xD4, 0x01, 0xEB, 0x1E, 0x10, /* ........ */
        /* 0360 */ 0xD6, 0x87, 0x0E, 0xE0, 0x21, 0xFB, 0x21, 0xA0, /* ....!.!. */
        /* 0368 */ 0x33, 0x8C, 0x25, 0x83, 0xC8, 0xC6, 0xB9, 0x86, /* 3.%..... */
        /* 0370 */ 0x8E, 0xD1, 0xE2, 0x17, 0xAA, 0x9B, 0x42, 0xEC, /* ......B. */
        /* 0378 */ 0x83, 0xE1, 0xB2, 0x81, 0x04, 0xEA, 0xE1, 0x5A, /* .......Z */
        /* 0380 */ 0x30, 0x85, 0x44, 0xD1, 0x68, 0x34, 0x06, 0x26, /* 0.D.h4.& */
        /* 0388 */ 0x30, 0x82, 0x33, 0x88, 0x01, 0x9D, 0x11, 0x42, /* 0.3....B */
        /* 0390 */ 0x87, 0x32, 0x9C, 0x8A, 0xF3, 0x10, 0xEA, 0xFF, /* .2...... */
        /* 0398 */ 0x4F, 0x30, 0xD4, 0x8D, 0x89, 0xCE, 0xCE, 0xF3, /* O0...... */
        /* 03A0 */ 0xE7, 0xB7, 0x11, 0x9F, 0x08, 0x0C, 0xEC, 0x2B, /* .......+ */
        /* 03A8 */ 0xC4, 0x5B, 0x06, 0x58, 0x86, 0xE5, 0xC5, 0x3D, /* .[.X...= */
        /* 03B0 */ 0x01, 0x1C, 0xE3, 0x49, 0x26, 0xA8, 0xE6, 0x58, /* ...I&..X */
        /* 03B8 */ 0x83, 0x9A, 0x83, 0xAF, 0x02, 0x6F, 0x64, 0x26, /* .....od& */
        /* 03C0 */ 0xF0, 0x15, 0x0C, 0x6C, 0xA7, 0x19, 0x8C, 0xBE, /* ...l.... */
        /* 03C8 */ 0x3B, 0x01, 0x28, 0x80, 0x7C, 0x14, 0xF0, 0x7D, /* ;.(.|..} */
        /* 03D0 */ 0xF9, 0x6D, 0x80, 0xCD, 0xE2, 0x95, 0xD9, 0x68, /* .m.....h */
        /* 03D8 */ 0x3E, 0x7F, 0x22, 0x86, 0x8E, 0x12, 0x33, 0x74, /* >."...3t */
        /* 03E0 */ 0x0A, 0xE2, 0xA1, 0x3B, 0xE8, 0xD0, 0xD1, 0xC7, /* ...;.... */
        /* 03E8 */ 0x01, 0x9F, 0xAC, 0x70, 0xC1, 0x0E, 0x5F, 0xD0, /* ...p.._. */
        /* 03F0 */ 0x26, 0x77, 0xB4, 0x27, 0xE6, 0x59, 0x78, 0x9E, /* &w.'.Yx. */
        /* 03F8 */ 0xB8, 0xB9, 0x83, 0xE9, 0x88, 0x04, 0x63, 0xF0, /* ......c. */
        /* 0400 */ 0x98, 0xC9, 0x83, 0x59, 0xE0, 0xE4, 0x41, 0xF1, /* ...Y..A. */
        /* 0408 */ 0xFF, 0x9F, 0x3C, 0x4C, 0x78, 0x4C, 0xD8, 0xC3, /* ..<LxL.. */
        /* 0410 */ 0x21, 0x3D, 0x74, 0x78, 0x64, 0x7C, 0x9C, 0x3E, /* !=txd|.> */
        /* 0418 */ 0xFD, 0x30, 0xEC, 0xD3, 0x39, 0x97, 0xA2, 0x67, /* .0..9..g */
        /* 0420 */ 0xA4, 0x3B, 0xC6, 0x33, 0x17, 0x06, 0xD6, 0x23, /* .;.3...# */
        /* 0428 */ 0xE7, 0xB0, 0x46, 0x0B, 0x7B, 0xC0, 0xCF, 0x21, /* ..F.{..! */
        /* 0430 */ 0xBE, 0xC3, 0xF8, 0xC0, 0xC3, 0x60, 0x7D, 0x7A, /* .....`}z */
        /* 0438 */ 0x01, 0xC7, 0xF1, 0x0B, 0xFE, 0x69, 0x00, 0x3C, /* .....i.< */
        /* 0440 */ 0x07, 0x10, 0x8F, 0xE1, 0x05, 0x84, 0x13, 0x14, /* ........ */
        /* 0448 */ 0x7D, 0xFE, 0xA5, 0x42, 0x17, 0x27, 0x99, 0x30, /* }..B.'.0 */
        /* 0450 */ 0xA8, 0xD3, 0x14, 0xE0, 0xEA, 0xF4, 0x06, 0x9E, /* ........ */
        /* 0458 */ 0xAB, 0x3E, 0xEE, 0x2C, 0x85, 0xFB, 0xFF, 0x9F, /* .>.,.... */
        /* 0460 */ 0xA5, 0x60, 0x1C, 0x7E, 0x7D, 0x81, 0xF7, 0x5D, /* .`.~}..] */
        /* 0468 */ 0xCA, 0x08, 0x07, 0xF2, 0x2C, 0x05, 0xF6, 0xF8, /* ....,... */
        /* 0470 */ 0xCF, 0x10, 0x1D, 0x02, 0x7C, 0x96, 0x02, 0xF8, /* ....|... */
        /* 0478 */ 0x21, 0xE4, 0x4C, 0x09, 0xE5, 0x3C, 0x83, 0x0B, /* !.L..<.. */
        /* 0480 */ 0x7E, 0xA6, 0x04, 0x5A, 0xFF, 0xFF, 0x53, 0x08, /* ~..Z..S. */
        /* 0488 */ 0xF8, 0x8F, 0x11, 0x3E, 0xE2, 0xC0, 0x3D, 0x54, /* ...>..=T */
        /* 0490 */ 0xF2, 0x00, 0x87, 0x30, 0x28, 0x87, 0x4A, 0xB8, /* ...0(.J. */
        /* 0498 */ 0xC7, 0x5F, 0x70, 0x1C, 0x8E, 0xF9, 0x39, 0x03, /* ._p...9. */
        /* 04A0 */ 0x77, 0x24, 0x03, 0x1E, 0xA7, 0x67, 0xDC, 0x28, /* w$...g.( */
        /* 04A8 */ 0x3D, 0x04, 0x3E, 0x80, 0x56, 0xE7, 0x46, 0x4E, /* =.>.V.FN */
        /* 04B0 */ 0x3E, 0xA7, 0x84, 0x3B, 0x12, 0xF0, 0x29, 0xE1, /* >..;..). */
        /* 04B8 */ 0x06, 0x80, 0x09, 0x70, 0xCE, 0x04, 0xD4, 0xFC, /* ...p.... */
        /* 04C0 */ 0xFF, 0xCF, 0x99, 0x80, 0x01, 0x90, 0x08, 0xEF, /* ........ */
        /* 04C8 */ 0x0A, 0x51, 0xDF, 0x93, 0x0D, 0xF1, 0x9C, 0xCC, /* .Q...... */
        /* 04D0 */ 0x70, 0x5E, 0x22, 0x1E, 0x61, 0x9E, 0x93, 0xC1, /* p^".a... */
        /* 04D8 */ 0x79, 0xCE, 0x04, 0xF8, 0xF2, 0xFF, 0x3F, 0xD6, /* y.....?. */
        /* 04E0 */ 0xC3, 0xBE, 0x29, 0x04, 0x7F, 0x0A, 0x01, 0x26, /* ..)....& */
        /* 04E8 */ 0xE2, 0xCF, 0x99, 0x54, 0xF8, 0x39, 0x13, 0xDA, /* ...T.9.. */
        /* 04F0 */ 0x5C, 0x3C, 0x6D, 0x9F, 0x33, 0x01, 0xAE, 0xFD, /* \<m.3... */
        /* 04F8 */ 0xFF, 0xCF, 0x99, 0x80, 0xFF, 0xC8, 0xE7, 0x4C, /* .......L */
        /* 0500 */ 0x40, 0xCF, 0x91, 0x0A, 0x77, 0xCE, 0x04, 0xC3, /* @...w... */
        /* 0508 */ 0x38, 0xDF, 0x9F, 0x0C, 0xF2, 0x3C, 0xE2, 0x03, /* 8....<.. */
        /* 0510 */ 0x81, 0x8F, 0x32, 0x4C, 0xA1, 0x4D, 0x9F, 0x1A, /* ..2L.M.. */
        /* 0518 */ 0x8D, 0x5A, 0x35, 0x28, 0x53, 0xA3, 0x4C, 0x83, /* .Z5(S.L. */
        /* 0520 */ 0x5A, 0x7D, 0x2A, 0x35, 0x66, 0xEC, 0xE8, 0x64, /* Z}*5f..d */
        /* 0528 */ 0x11, 0x6B, 0xD5, 0x60, 0xFD, 0xFF, 0x0F, 0xB5, /* .k.`.... */
        /* 0530 */ 0x5E, 0x81, 0x58, 0xD2, 0x13, 0x43, 0x20, 0x16, /* ^.X..C . */
        /* 0538 */ 0xE5, 0x01, 0x84, 0xC5, 0x35, 0x01, 0xC2, 0x84, /* ....5... */
        /* 0540 */ 0xAF, 0x4A, 0x20, 0x8E, 0x0D, 0x42, 0xC5, 0xEA, /* .J ..B.. */
        /* 0548 */ 0x38, 0xDA, 0x69, 0x88, 0x06, 0x11, 0x90, 0x43, /* 8.i....C */
        /* 0550 */ 0xF8, 0x00, 0x62, 0x91, 0x40, 0x04, 0x4E, 0x94, /* ..b.@.N. */
        /* 0558 */ 0x80, 0x52, 0x27, 0x20, 0x4C, 0xF6, 0x5A, 0x04, /* .R' L.Z. */
        /* 0560 */ 0x62, 0x99, 0x5E, 0x40, 0x58, 0x48, 0x10, 0x2A, /* b.^@XH.* */
        /* 0568 */ 0xCD, 0x0C, 0x38, 0xD3, 0x09, 0x22, 0x20, 0x4B, /* ..8.." K */
        /* 0570 */ 0x7E, 0x85, 0x08, 0xC8, 0x01, 0x40, 0x04, 0xE4, /* ~....@.. */
        /* 0578 */ 0xFF, 0x3F                    /* .? */
      })
    }
    OperationRegion (PNVS, SystemMemory, 0xBAE0C018, 0x100E)
    Field (PNVS, AnyAcc, NoLock, Preserve)
    {
      WCMD,  8,Â
      TPID,  8,Â
      WDID,  32,Â
      DI00,  32768
    }
    Field (PNVS, AnyAcc, NoLock, Preserve)
    {
      AccessAs (ByteAcc, 0x00),Â
      Offset (0x06),Â
      WCCL,  16,Â
      WCSE,  16,Â
      WCA1,  32,Â
      WCA2,  32,Â
      WCA3,  32,Â
      WCA4,  32,Â
      WCR1,  32,Â
      WCR2,  32,Â
      WCR3,  32,Â
      WCR4,  32
    }
    OperationRegion (IOPH, SystemIO, 0x0800, 0x10)
    Field (IOPH, ByteAcc, NoLock, Preserve)
    {
      Offset (0x02),Â
      Offset (0x04),Â
      Offset (0x06),Â
      Offset (0x08),Â
      PHXI,  8,Â
      Offset (0x0A),Â
      Offset (0x0B),Â
      Offset (0x0C),Â
      Offset (0x0D),Â
      Offset (0x0E),Â
      Offset (0x0F),Â
      Offset (0x10)
    }
    Mutex (PSMX, 0x00)
    Method (FOWM, 2, NotSerialized)
    {
    }
    Method (PHWM, 2, NotSerialized)
    {
      Acquire (PSMX, 0xFFFF)
      P8XH (Zero, 0xE0)
      WCMD = 0xE0
      TPID = 0x57
      WDID = Arg1
      DI00 = Arg0
      PHXI = Zero
      Release (PSMX)
      Name (RETB, Buffer (0x1000) {})
      RETB = DI00 /* \_SB_.DI00 */
      Return (RETB) /* \_SB_.PHWM.RETB */
    }
    Name (PR00, Package (0x18)
    {
      Package (0x04)
      {
        0x001FFFFF,Â
        Zero,Â
        LNKF,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001FFFFF,Â
        One,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001FFFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001FFFFF,Â
        0x03,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001DFFFF,Â
        Zero,Â
        LNKH,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001AFFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001BFFFF,Â
        Zero,Â
        LNKG,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        One,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        0x03,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        One,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        0x03,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        One,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x03,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0002FFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        One,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        0x03,Â
        LNKD,Â
        Zero
      }
    })
    Name (AR00, Package (0x18)
    {
      Package (0x04)
      {
        0x001FFFFF,Â
        Zero,Â
        Zero,Â
        0x15
      },Â
      Package (0x04)
      {
        0x001FFFFF,Â
        One,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0x001FFFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0x001FFFFF,Â
        0x03,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0x001DFFFF,Â
        Zero,Â
        Zero,Â
        0x17
      },Â
      Package (0x04)
      {
        0x001AFFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0x001BFFFF,Â
        Zero,Â
        Zero,Â
        0x16
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        One,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0x0016FFFF,Â
        0x03,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        One,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0x001CFFFF,Â
        0x03,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        One,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x03,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0x0002FFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        One,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0x0004FFFF,Â
        0x03,Â
        Zero,Â
        0x13
      }
    })
    Name (PR04, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKD,Â
        Zero
      }
    })
    Name (AR04, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x13
      }
    })
    Name (PR05, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKA,Â
        Zero
      }
    })
    Name (AR05, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x10
      }
    })
    Name (PR06, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKB,Â
        Zero
      }
    })
    Name (AR06, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x11
      }
    })
    Name (PR07, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKC,Â
        Zero
      }
    })
    Name (AR07, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x12
      }
    })
    Name (PR08, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKD,Â
        Zero
      }
    })
    Name (AR08, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x13
      }
    })
    Name (PR09, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKA,Â
        Zero
      }
    })
    Name (AR09, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x10
      }
    })
    Name (PR0E, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKB,Â
        Zero
      }
    })
    Name (AR0E, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x11
      }
    })
    Name (PR0F, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKC,Â
        Zero
      }
    })
    Name (AR0F, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x12
      }
    })
    Name (PR02, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKD,Â
        Zero
      }
    })
    Name (AR02, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x13
      }
    })
    Name (PR0A, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKA,Â
        Zero
      }
    })
    Name (AR0A, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x10
      }
    })
    Name (PR0B, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKB,Â
        Zero
      }
    })
    Name (AR0B, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x11
      }
    })
    Name (PR0C, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKD,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKA,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKB,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKC,Â
        Zero
      }
    })
    Name (AR0C, Package (0x04)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x13
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x10
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x11
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x12
      }
    })
    Name (PR01, Package (0x0C)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        LNKF,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        LNKG,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        LNKH,Â
        Zero
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        LNKE,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        Zero,Â
        LNKG,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        One,Â
        LNKF,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x02,Â
        LNKE,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x03,Â
        LNKH,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        Zero,Â
        LNKC,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        One,Â
        LNKE,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        0x02,Â
        LNKG,Â
        Zero
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        0x03,Â
        LNKF,Â
        Zero
      }
    })
    Name (AR01, Package (0x0C)
    {
      Package (0x04)
      {
        0xFFFF,Â
        Zero,Â
        Zero,Â
        0x15
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        One,Â
        Zero,Â
        0x16
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x02,Â
        Zero,Â
        0x17
      },Â
      Package (0x04)
      {
        0xFFFF,Â
        0x03,Â
        Zero,Â
        0x14
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        Zero,Â
        Zero,Â
        0x16
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        One,Â
        Zero,Â
        0x15
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x02,Â
        Zero,Â
        0x14
      },Â
      Package (0x04)
      {
        0x0001FFFF,Â
        0x03,Â
        Zero,Â
        0x17
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        Zero,Â
        Zero,Â
        0x12
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        One,Â
        Zero,Â
        0x14
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        0x02,Â
        Zero,Â
        0x16
      },Â
      Package (0x04)
      {
        0x0005FFFF,Â
        0x03,Â
        Zero,Â
        0x15
      }
    })
    Name (PRSA, ResourceTemplate ()
    {
      IRQ (Level, ActiveLow, Shared, )
        {1,3,4,5,6,10,11,12,14,15}
    })
    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, EisaId ("PNP0A08") /* PCI Express Bus */) // _HID: Hardware ID
      Name (_CID, EisaId ("PNP0A03") /* PCI Bus */) // _CID: Compatible ID
      Name (_ADR, Zero) // _ADR: Address
      Method (^BN00, 0, NotSerialized)
      {
        Return (Zero)
      }
      Method (_BBN, 0, NotSerialized) // _BBN: BIOS Bus Number
      {
        Return (BN00 ())
      }
      Name (_UID, Zero) // _UID: Unique ID
      Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
      {
        If (PICM)
        {
          Return (AR00 ())
        }
        Return (PR00 ())
      }
      OperationRegion (HBUS, PCI_Config, Zero, 0x0100)
      Field (HBUS, DWordAcc, NoLock, Preserve)
      {
        Offset (0x40),Â
        EPEN,  1,Â
          ,  11,Â
        EPBR,  20,Â
        Offset (0x48),Â
        MHEN,  1,Â
          ,  14,Â
        MHBR,  17,Â
        Offset (0x50),Â
        GCLK,  1,Â
        Offset (0x54),Â
        D0EN,  1,Â
        Offset (0x60),Â
        PXEN,  1,Â
        PXSZ,  2,Â
          ,  23,Â
        PXBR,  6,Â
        Offset (0x68),Â
        DIEN,  1,Â
          ,  11,Â
        DIBR,  20,Â
        Offset (0x70),Â
          ,  20,Â
        MEBR,  12,Â
        Offset (0x80),Â
          ,  4,Â
        PM0H,  2,Â
        Offset (0x81),Â
        PM1L,  2,Â
          ,  2,Â
        PM1H,  2,Â
        Offset (0x82),Â
        PM2L,  2,Â
          ,  2,Â
        PM2H,  2,Â
        Offset (0x83),Â
        PM3L,  2,Â
          ,  2,Â
        PM3H,  2,Â
        Offset (0x84),Â
        PM4L,  2,Â
          ,  2,Â
        PM4H,  2,Â
        Offset (0x85),Â
        PM5L,  2,Â
          ,  2,Â
        PM5H,  2,Â
        Offset (0x86),Â
        PM6L,  2,Â
          ,  2,Â
        PM6H,  2,Â
        Offset (0x87),Â
        Offset (0xA8),Â
          ,  20,Â
        TUUD,  19,Â
        Offset (0xBC),Â
          ,  20,Â
        TLUD,  12,Â
        Offset (0xC8),Â
          ,  7,Â
        HTSE,  1
      }
      OperationRegion (MCHT, SystemMemory, 0xFED10000, 0x1100)
      Field (MCHT, ByteAcc, NoLock, Preserve)
      {
      }
      Name (BUF0, ResourceTemplate ()
      {
        WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
          0x0000,       // Granularity
          0x0000,       // Range Minimum
          0x00FF,       // Range Maximum
          0x0000,       // Translation Offset
          0x0100,       // Length
          ,, _Y00)
        DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
          0x00000000,     // Granularity
          0x00000000,     // Range Minimum
          0x00000CF7,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00000CF8,     // Length
          ,, , TypeStatic)
        IO (Decode16,
          0x0CF8,       // Range Minimum
          0x0CF8,       // Range Maximum
          0x01,        // Alignment
          0x08,        // Length
          )
        DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
          0x00000000,     // Granularity
          0x00000D00,     // Range Minimum
          0x0000FFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x0000F300,     // Length
          ,, , TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000A0000,     // Range Minimum
          0x000BFFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00020000,     // Length
          ,, , AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000C0000,     // Range Minimum
          0x000C3FFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y01, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000C4000,     // Range Minimum
          0x000C7FFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y02, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000C8000,     // Range Minimum
          0x000CBFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y03, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000CC000,     // Range Minimum
          0x000CFFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y04, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000D0000,     // Range Minimum
          0x000D3FFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y05, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000D4000,     // Range Minimum
          0x000D7FFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y06, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000D8000,     // Range Minimum
          0x000DBFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y07, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000DC000,     // Range Minimum
          0x000DFFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y08, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000E0000,     // Range Minimum
          0x000E3FFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y09, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000E4000,     // Range Minimum
          0x000E7FFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y0A, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000E8000,     // Range Minimum
          0x000EBFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y0B, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000EC000,     // Range Minimum
          0x000EFFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00004000,     // Length
          ,, _Y0C, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x000F0000,     // Range Minimum
          0x000FFFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00010000,     // Length
          ,, _Y0D, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0x00000000,     // Range Minimum
          0xFEAFFFFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0xFEB00000,     // Length
          ,, _Y0E, AddressRangeMemory, TypeStatic)
        DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
          0x00000000,     // Granularity
          0xFED40000,     // Range Minimum
          0xFED44FFF,     // Range Maximum
          0x00000000,     // Translation Offset
          0x00005000,     // Length
          ,, , AddressRangeMemory, TypeStatic)
      })
      Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
      {
        CreateWordField (BUF0, \_SB.PCI0._Y00._MAX, PBMX) // _MAX: Maximum Base Address
        PBMX = ((PELN >> 0x14) - 0x02)
        CreateWordField (BUF0, \_SB.PCI0._Y00._LEN, PBLN) // _LEN: Length
        PBLN = ((PELN >> 0x14) - One)
        If (PM1L)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y01._LEN, C0LN) // _LEN: Length
          C0LN = Zero
        }
        If (PM1L == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y01._RW, C0RW) // _RW_: Read-Write Status
          C0RW = Zero
        }
        If (PM1H)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y02._LEN, C4LN) // _LEN: Length
          C4LN = Zero
        }
        If (PM1H == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y02._RW, C4RW) // _RW_: Read-Write Status
          C4RW = Zero
        }
        If (PM2L)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y03._LEN, C8LN) // _LEN: Length
          C8LN = Zero
        }
        If (PM2L == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y03._RW, C8RW) // _RW_: Read-Write Status
          C8RW = Zero
        }
        If (PM2H)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y04._LEN, CCLN) // _LEN: Length
          CCLN = Zero
        }
        If (PM2H == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y04._RW, CCRW) // _RW_: Read-Write Status
          CCRW = Zero
        }
        If (PM3L)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y05._LEN, D0LN) // _LEN: Length
          D0LN = Zero
        }
        If (PM3L == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y05._RW, D0RW) // _RW_: Read-Write Status
          D0RW = Zero
        }
        If (PM3H)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y06._LEN, D4LN) // _LEN: Length
          D4LN = Zero
        }
        If (PM3H == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y06._RW, D4RW) // _RW_: Read-Write Status
          D4RW = Zero
        }
        If (PM4L)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y07._LEN, D8LN) // _LEN: Length
          D8LN = Zero
        }
        If (PM4L == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y07._RW, D8RW) // _RW_: Read-Write Status
          D8RW = Zero
        }
        If (PM4H)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y08._LEN, DCLN) // _LEN: Length
          DCLN = Zero
        }
        If (PM4H == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y08._RW, DCRW) // _RW_: Read-Write Status
          DCRW = Zero
        }
        If (PM5L)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y09._LEN, E0LN) // _LEN: Length
          E0LN = Zero
        }
        If (PM5L == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y09._RW, E0RW) // _RW_: Read-Write Status
          E0RW = Zero
        }
        If (PM5H)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y0A._LEN, E4LN) // _LEN: Length
          E4LN = Zero
        }
        If (PM5H == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y0A._RW, E4RW) // _RW_: Read-Write Status
          E4RW = Zero
        }
        If (PM6L)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y0B._LEN, E8LN) // _LEN: Length
          E8LN = Zero
        }
        If (PM6L == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y0B._RW, E8RW) // _RW_: Read-Write Status
          E8RW = Zero
        }
        If (PM6H)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y0C._LEN, ECLN) // _LEN: Length
          ECLN = Zero
        }
        If (PM6H == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y0C._RW, ECRW) // _RW_: Read-Write Status
          ECRW = Zero
        }
        If (PM0H)
        {
          CreateDWordField (BUF0, \_SB.PCI0._Y0D._LEN, F0LN) // _LEN: Length
          F0LN = Zero
        }
        If (PM0H == One)
        {
          CreateBitField (BUF0, \_SB.PCI0._Y0D._RW, F0RW) // _RW_: Read-Write Status
          F0RW = Zero
        }
        CreateDWordField (BUF0, \_SB.PCI0._Y0E._MIN, M1MN) // _MIN: Minimum Base Address
        CreateDWordField (BUF0, \_SB.PCI0._Y0E._MAX, M1MX) // _MAX: Maximum Base Address
        CreateDWordField (BUF0, \_SB.PCI0._Y0E._LEN, M1LN) // _LEN: Length
        M1MN = (TLUD << 0x14)
        M1LN = ((M1MX - M1MN) + One)
        Return (BUF0) /* \_SB_.PCI0.BUF0 */
      }
      Name (GUID, ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */)
      Name (SUPP, Zero)
      Name (CTRL, Zero)
      Method (_OSC, 4, Serialized) // _OSC: Operating System Capabilities
      {
        Local0 = Arg3
        CreateDWordField (Local0, Zero, CDW1)
        CreateDWordField (Local0, 0x04, CDW2)
        CreateDWordField (Local0, 0x08, CDW3)
        If ((Arg0 == GUID) && NEXP)
        {
          SUPP = CDW2 /* \_SB_.PCI0._OSC.CDW2 */
          CTRL = CDW3 /* \_SB_.PCI0._OSC.CDW3 */
          If (~(CDW1 & One))
          {
            If (CTRL & One)
            {
              NHPG ()
            }
            If (CTRL & 0x04)
            {
              NPME ()
            }
          }
          If (Arg1 != One)
          {
            CDW1 |= 0x08
          }
          If (CDW3 != CTRL)
          {
            CDW1 |= 0x10
          }
          CDW3 = CTRL /* \_SB_.PCI0.CTRL */
          OSCC = CTRL /* \_SB_.PCI0.CTRL */
          Return (Local0)
        }
        Else
        {
          CDW1 |= 0x04
          Return (Local0)
        }
      }
      Scope (\_SB.PCI0)
      {
        Method (AR00, 0, NotSerialized)
        {
          Return (^^AR00) /* \_SB_.AR00 */
        }
        Method (PR00, 0, NotSerialized)
        {
          Return (^^PR00) /* \_SB_.PR00 */
        }
        Method (AR01, 0, NotSerialized)
        {
          Return (^^AR01) /* \_SB_.AR01 */
        }
        Method (PR01, 0, NotSerialized)
        {
          Return (^^PR01) /* \_SB_.PR01 */
        }
        Method (AR02, 0, NotSerialized)
        {
          Return (^^AR02) /* \_SB_.AR02 */
        }
        Method (PR02, 0, NotSerialized)
        {
          Return (^^PR02) /* \_SB_.PR02 */
        }
        Method (AR04, 0, NotSerialized)
        {
          Return (^^AR04) /* \_SB_.AR04 */
        }
        Method (PR04, 0, NotSerialized)
        {
          Return (^^PR04) /* \_SB_.PR04 */
        }
        Method (AR05, 0, NotSerialized)
        {
          Return (^^AR05) /* \_SB_.AR05 */
        }
        Method (PR05, 0, NotSerialized)
        {
          Return (^^PR05) /* \_SB_.PR05 */
        }
        Method (AR06, 0, NotSerialized)
        {
          Return (^^AR06) /* \_SB_.AR06 */
        }
        Method (PR06, 0, NotSerialized)
        {
          Return (^^PR06) /* \_SB_.PR06 */
        }
        Method (AR07, 0, NotSerialized)
        {
          Return (^^AR07) /* \_SB_.AR07 */
        }
        Method (PR07, 0, NotSerialized)
        {
          Return (^^PR07) /* \_SB_.PR07 */
        }
        Method (AR08, 0, NotSerialized)
        {
          Return (^^AR08) /* \_SB_.AR08 */
        }
        Method (PR08, 0, NotSerialized)
        {
          Return (^^PR08) /* \_SB_.PR08 */
        }
        Method (AR09, 0, NotSerialized)
        {
          Return (^^AR09) /* \_SB_.AR09 */
        }
        Method (PR09, 0, NotSerialized)
        {
          Return (^^PR09) /* \_SB_.PR09 */
        }
        Method (AR0A, 0, NotSerialized)
        {
          Return (^^AR0A) /* \_SB_.AR0A */
        }
        Method (PR0A, 0, NotSerialized)
        {
          Return (^^PR0A) /* \_SB_.PR0A */
        }
        Method (AR0B, 0, NotSerialized)
        {
          Return (^^AR0B) /* \_SB_.AR0B */
        }
        Method (PR0B, 0, NotSerialized)
        {
          Return (^^PR0B) /* \_SB_.PR0B */
        }
      }
      Device (P0P1)
      {
        Name (_ADR, 0x001E0000) // _ADR: Address
        Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
        {
          Return (GPRW (0x0B, 0x04))
        }
        Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
        {
          If (PICM)
          {
            Return (AR01 ())
          }
          Return (PR01 ())
        }
      }
      Device (LPCB)
      {
        Name (_ADR, 0x001F0000) // _ADR: Address
        Scope (\_SB)
        {
          OperationRegion (PCI0.LPCB.LPC1, PCI_Config, 0x40, 0xC0)
          Field (PCI0.LPCB.LPC1, AnyAcc, NoLock, Preserve)
          {
            Offset (0x20),Â
            PARC,  8,Â
            PBRC,  8,Â
            PCRC,  8,Â
            PDRC,  8,Â
            Offset (0x28),Â
            PERC,  8,Â
            PFRC,  8,Â
            PGRC,  8,Â
            PHRC,  8
          }
          Device (LNKA)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, One) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PARC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSA) /* \_SB_.PRSA */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLA, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLA, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PARC & 0x0F))
              Return (RTLA) /* \_SB_.LNKA._CRS.RTLA */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PARC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PARC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
          Device (LNKB)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, 0x02) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PBRC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSB) /* \_SB_.PRSB */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLB, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLB, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PBRC & 0x0F))
              Return (RTLB) /* \_SB_.LNKB._CRS.RTLB */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PBRC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PBRC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
          Device (LNKC)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, 0x03) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PCRC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSC) /* \_SB_.PRSC */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLC, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLC, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PCRC & 0x0F))
              Return (RTLC) /* \_SB_.LNKC._CRS.RTLC */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PCRC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PCRC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
          Device (LNKD)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, 0x04) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PDRC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSD) /* \_SB_.PRSD */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLD, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLD, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PDRC & 0x0F))
              Return (RTLD) /* \_SB_.LNKD._CRS.RTLD */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PDRC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PDRC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
          Device (LNKE)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, 0x05) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PERC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSE) /* \_SB_.PRSE */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLE, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLE, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PERC & 0x0F))
              Return (RTLE) /* \_SB_.LNKE._CRS.RTLE */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PERC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PERC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
          Device (LNKF)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, 0x06) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PFRC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSF) /* \_SB_.PRSF */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLF, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLF, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PFRC & 0x0F))
              Return (RTLF) /* \_SB_.LNKF._CRS.RTLF */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PFRC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PFRC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
          Device (LNKG)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, 0x07) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PGRC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSG) /* \_SB_.PRSG */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLG, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLG, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PGRC & 0x0F))
              Return (RTLG) /* \_SB_.LNKG._CRS.RTLG */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PGRC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PGRC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
          Device (LNKH)
          {
            Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID
            Name (_UID, 0x08) // _UID: Unique ID
            Method (_DIS, 0, Serialized) // _DIS: Disable Device
            {
              PHRC |= 0x80
            }
            Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
            {
              Return (PRSH) /* \_SB_.PRSH */
            }
            Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
            {
              Name (RTLH, ResourceTemplate ()
              {
                IRQ (Level, ActiveLow, Shared, )
                  {}
              })
              CreateWordField (RTLH, One, IRQ0)
              IRQ0 = Zero
              IRQ0 = (One << (PHRC & 0x0F))
              Return (RTLH) /* \_SB_.LNKH._CRS.RTLH */
            }
            Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
            {
              CreateWordField (Arg0, One, IRQ0)
              FindSetRightBit (IRQ0, Local0)
              Local0--
              PHRC = Local0
            }
            Method (_STA, 0, Serialized) // _STA: Status
            {
              If (PHRC & 0x80)
              {
                Return (0x09)
              }
              Else
              {
                Return (0x0B)
              }
            }
          }
        }
        OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)
        Field (LPC0, AnyAcc, NoLock, Preserve)
        {
          Offset (0x40),Â
          IOD0,  8,Â
          IOD1,  8,Â
          Offset (0xB0),Â
          RAEN,  1,Â
            ,  13,Â
          RCBA,  18
        }
        Device (DMAC)
        {
          Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IO (Decode16,
              0x0000,       // Range Minimum
              0x0000,       // Range Maximum
              0x01,        // Alignment
              0x20,        // Length
              )
            IO (Decode16,
              0x0081,       // Range Minimum
              0x0081,       // Range Maximum
              0x01,        // Alignment
              0x11,        // Length
              )
            IO (Decode16,
              0x0093,       // Range Minimum
              0x0093,       // Range Maximum
              0x01,        // Alignment
              0x0D,        // Length
              )
            IO (Decode16,
              0x00C0,       // Range Minimum
              0x00C0,       // Range Maximum
              0x01,        // Alignment
              0x20,        // Length
              )
            DMA (Compatibility, NotBusMaster, Transfer8_16, )
              {4}
          })
        }
        Device (HPET)
        {
          Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID
          Name (_UID, Zero) // _UID: Unique ID
          Name (BUF0, ResourceTemplate ()
          {
            IRQNoFlags ()
              {0,8,11,15}
            Memory32Fixed (ReadWrite,
              0xFED00000,     // Address Base
              0x00000400,     // Address Length
              )
          })
          Method (_STA, 0, NotSerialized) // _STA: Status
          {
            If (OSYS >= 0x07D1)
            {
              If (HPAE)
              {
                Return (0x0F)
              }
            }
            ElseIf (HPAE)
            {
              Return (0x0B)
            }
            Return (Zero)
          }
          Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
          {
            If (HPAE)
            {
              CreateDWordField (BUF0, 0x04, HPT0)
              If (HPAS == One)
              {
                HPT0 = 0xFED01000
              }
              If (HPAS == 0x02)
              {
                HPT0 = 0xFED02000
              }
              If (HPAS == 0x03)
              {
                HPT0 = 0xFED03000
              }
            }
            Return (BUF0) /* \_SB_.PCI0.LPCB.HPET.BUF0 */
          }
        }
        Device (IPIC)
        {
          Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */) // _HID: Hardware ID
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IO (Decode16,
              0x0020,       // Range Minimum
              0x0020,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x0024,       // Range Minimum
              0x0024,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x0028,       // Range Minimum
              0x0028,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x002C,       // Range Minimum
              0x002C,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x0030,       // Range Minimum
              0x0030,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x0034,       // Range Minimum
              0x0034,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x0038,       // Range Minimum
              0x0038,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x003C,       // Range Minimum
              0x003C,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00A0,       // Range Minimum
              0x00A0,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00A4,       // Range Minimum
              0x00A4,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00A8,       // Range Minimum
              0x00A8,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00AC,       // Range Minimum
              0x00AC,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00B0,       // Range Minimum
              0x00B0,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00B4,       // Range Minimum
              0x00B4,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00B8,       // Range Minimum
              0x00B8,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x00BC,       // Range Minimum
              0x00BC,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x04D0,       // Range Minimum
              0x04D0,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IRQNoFlags ()
              {2}
          })
        }
        Device (MATH)
        {
          Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */) // _HID: Hardware ID
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IO (Decode16,
              0x00F0,       // Range Minimum
              0x00F0,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IRQNoFlags ()
              {13}
          })
        }
        Device (LDRC)
        {
          Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID
          Name (_UID, 0x02) // _UID: Unique ID
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IO (Decode16,
              0x002E,       // Range Minimum
              0x002E,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x004E,       // Range Minimum
              0x004E,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x0061,       // Range Minimum
              0x0061,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0063,       // Range Minimum
              0x0063,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0065,       // Range Minimum
              0x0065,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0067,       // Range Minimum
              0x0067,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0068,       // Range Minimum
              0x0068,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x006C,       // Range Minimum
              0x006C,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0070,       // Range Minimum
              0x0070,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0080,       // Range Minimum
              0x0080,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0092,       // Range Minimum
              0x0092,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x00B2,       // Range Minimum
              0x00B2,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
            IO (Decode16,
              0x0680,       // Range Minimum
              0x0680,       // Range Maximum
              0x01,        // Alignment
              0x20,        // Length
              )
            IO (Decode16,
              0x1000,       // Range Minimum
              0x1000,       // Range Maximum
              0x01,        // Alignment
              0x04,        // Length
              )
            IO (Decode16,
              0x1004,       // Range Minimum
              0x1004,       // Range Maximum
              0x01,        // Alignment
              0x10,        // Length
              )
            IO (Decode16,
              0xFFFF,       // Range Minimum
              0xFFFF,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0400,       // Range Minimum
              0x0400,       // Range Maximum
              0x01,        // Alignment
              0x54,        // Length
              )
            IO (Decode16,
              0x0458,       // Range Minimum
              0x0458,       // Range Maximum
              0x01,        // Alignment
              0x28,        // Length
              )
            IO (Decode16,
              0x0500,       // Range Minimum
              0x0500,       // Range Maximum
              0x01,        // Alignment
              0x80,        // Length
              )
            IO (Decode16,
              0x164E,       // Range Minimum
              0x164E,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
          })
        }
        Device (RTC)
        {
          Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IO (Decode16,
              0x0070,       // Range Minimum
              0x0070,       // Range Maximum
              0x01,        // Alignment
              0x02,        // Length
              )
          })
        }
        Device (TIMR)
        {
          Name (_HID, EisaId ("PNP0100") /* PC-class System Timer */) // _HID: Hardware ID
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IO (Decode16,
              0x0040,       // Range Minimum
              0x0040,       // Range Maximum
              0x01,        // Alignment
              0x04,        // Length
              )
            IO (Decode16,
              0x0050,       // Range Minimum
              0x0050,       // Range Maximum
              0x10,        // Alignment
              0x04,        // Length
              )
          })
        }
        Device (CWDT)
        {
          Name (_HID, EisaId ("INT3F0D") /* ACPI Motherboard Resources */) // _HID: Hardware ID
          Name (_CID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _CID: Compatible ID
          Name (BUF0, ResourceTemplate ()
          {
            IO (Decode16,
              0x0454,       // Range Minimum
              0x0454,       // Range Maximum
              0x04,        // Alignment
              0x04,        // Length
              )
          })
          Method (_STA, 0, Serialized) // _STA: Status
          {
            If (WDTE == One)
            {
              Return (0x0F)
            }
            Else
            {
              Return (Zero)
            }
          }
          Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
          {
            Return (BUF0) /* \_SB_.PCI0.LPCB.CWDT.BUF0 */
          }
        }
        Device (MBT)
        {
          Name (_HID, EisaId ("PNP0C32")) // _HID: Hardware ID
          Method (_STA, 0, NotSerialized) // _STA: Status
          {
            If (OSYS >= 0x07D6)
            {
              Return (0x0F)
            }
            Else
            {
              Return (Zero)
            }
          }
          Method (GHID, 0, NotSerialized)
          {
            Return (Buffer (One)
            {
               0x02                       /* . */
            })
          }
        }
        Device (EC0)
        {
          Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */) // _HID: Hardware ID
          Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
          {
            Name (BFFR, ResourceTemplate ()
            {
              IO (Decode16,
                0x0062,       // Range Minimum
                0x0062,       // Range Maximum
                0x00,        // Alignment
                0x01,        // Length
                )
              IO (Decode16,
                0x0066,       // Range Minimum
                0x0066,       // Range Maximum
                0x00,        // Alignment
                0x01,        // Length
                )
            })
            Return (BFFR) /* \_SB_.PCI0.LPCB.EC0_._CRS.BFFR */
          }
          Method (_REG, 2, NotSerialized) // _REG: Region Availability
          {
            If ((Arg0 == 0x03) && (Arg1 == One))
            {
              ECON = One
              Acquire (MUT0, 0xFFFF)
              PWRS = ACIN /* \_SB_.PCI0.LPCB.EC0_.ACIN */
              ^^^^BAT0.BSTA = B0IN /* \_SB_.PCI0.LPCB.EC0_.B0IN */
              Release (MUT0)
              If (OSYS == 0x03E8)
              {
                Acquire (MUT0, 0xFFFF)
                ACOS = 0x40
                OSTY = 0x40
                Release (MUT0)
              }
              If (OSYS == 0x2710)
              {
                Acquire (MUT0, 0xFFFF)
                ACOS = 0x80
                OSTY = 0x80
                Release (MUT0)
              }
              If (OSYS == 0x07D0)
              {
                Acquire (MUT0, 0xFFFF)
                ACOS = 0x08
                OSTY = 0x08
                Release (MUT0)
              }
              If (OSYS == 0x07D1)
              {
                Acquire (MUT0, 0xFFFF)
                ACOS = 0x10
                OSTY = 0x10
                Release (MUT0)
              }
              If (OSYS == 0x07D2)
              {
                Acquire (MUT0, 0xFFFF)
                ACOS = 0x10
                OSTY = 0x10
                Release (MUT0)
              }
              If (OSYS == 0x07D6)
              {
                Acquire (MUT0, 0xFFFF)
                ACOS = 0x20
                OSTY = 0x20
                Release (MUT0)
              }
              If (OSYS == 0x07D9)
              {
                Acquire (MUT0, 0xFFFF)
                ACOS = 0x80
                OSTY = 0x80
                Release (MUT0)
              }
            }
          }
          Name (_GPE, 0x17) // _GPE: General Purpose Events
          OperationRegion (ECRM, EmbeddedControl, Zero, 0x0100)
          Field (ECRM, ByteAcc, Lock, Preserve)
          {
            WKEV,  8,Â
            Offset (0x18),Â
            PRTC,  8,Â
            SSTA,  8,Â
            SADR,  8,Â
            SCMD,  8,Â
            SMID,  8,Â
            SDAT,  8,Â
            SDT1,  8,Â
            Offset (0x3C),Â
            BCNT,  8,Â
            ALRA,  8,Â
            ALD0,  8,Â
            ALD1,  8,Â
            ACIN,  1,Â
            PWON,  1,Â
            INS3,  1,Â
            WPSW,  1,Â
            INS4,  1,Â
            SMON,  1,Â
            WPWG,  1,Â
            RVCO,  1,Â
            SUSB,  1,Â
            SUSC,  1,Â
            FANO,  1,Â
            SNIF,  1,Â
            LIDA,  1,Â
            Offset (0x42),Â
            KBBP,  1,Â
            DADP,  1,Â
            MMBT,  1,Â
            KBSO,  1,Â
            KBER,  1,Â
            ECCB,  1,Â
            CIRB,  1,Â
            MUTE,  1,Â
            TSN0,  1,Â
            TSN1,  1,Â
            OSTP,  1,Â
            TSN2,  1,Â
            EBK0,  1,Â
            EBK1,  1,Â
            EBK2,  1,Â
            EBK3,  1,Â
            Offset (0x45),Â
              ,  4,Â
            QA3E,  1,Â
            Offset (0x50),Â
            TOFS,  8,Â
            Offset (0x53),Â
            TTRT,  1,Â
            CCPU,  1,Â
            Offset (0x55),Â
            OTPC,  8,Â
            VGAT,  8,Â
            CHPT,  8,Â
            CPUT,  8,Â
            SYST,  8,Â
            DTS1,  8,Â
            DTS2,  8,Â
            Offset (0x5E),Â
            HWSN,  8,Â
            CTYP,  8,Â
            FCNT,  1,Â
            FTST,  1,Â
              ,  3,Â
            FADJ,  1,Â
            TCTL,  1,Â
            FATO,  1,Â
            DAC1,  8,Â
            DAC2,  8,Â
            FLVL,  8,Â
            CTL1,  16,Â
            CTL2,  16,Â
            FANH,  8,Â
            FANL,  8,Â
            RPM2,  16,Â
            FTAC,  16,Â
            FSPD,  16,Â
            SLED,  1,Â
            NLED,  1,Â
            CLED,  1,Â
            Offset (0x71),Â
            BT1L,  1,Â
            BT2L,  1,Â
            SNIL,  1,Â
            Offset (0x74),Â
            BLBU,  1,Â
            BLBD,  1,Â
            BLBH,  1,Â
            Offset (0x75),Â
            BHLL,  8,Â
            BTLL,  8,Â
            BTLI,  8,Â
            Offset (0x79),Â
            SVPL,  8,Â
            DIAG,  8,Â
            KLED,  8,Â
            Offset (0x80),Â
            ACTP,  8,Â
            Offset (0x82),Â
            NOS0,  8,Â
            Offset (0x89),Â
            ACOS,  8,Â
            Offset (0x8B),Â
            KBTL,  8,Â
            KBBL,  8,Â
            BRSL,  8,Â
            PLGH,  8,Â
            PLGL,  8,Â
            Offset (0x9D),Â
            SBF0,  8,Â
            Offset (0xA0),Â
            SAP0,  8,Â
            SAP1,  8,Â
            RCP0,  16,Â
            SOT0,  8,Â
            SOT1,  8,Â
            SRT0,  8,Â
            SRT1,  8,Â
            BTM0,  16,Â
            BST0,  16,Â
            BRC0,  16,Â
            SFC0,  8,Â
            SFC1,  8,Â
            SCP0,  8,Â
            SCP1,  8,Â
            SVT0,  8,Â
            SVT1,  8,Â
            MER0,  16,Â
            MFD0,  16,Â
            SBN0,  8,Â
            SBN1,  8,Â
            MAS0,  16,Â
            Offset (0xC3),Â
            BCS0,  8,Â
            MNN0,  8,Â
            DNN0,  8,Â
            BCN0,  8,Â
            BOC0,  8,Â
            BFC0,  8,Â
            BMD0,  8,Â
            CPL0,  8,Â
            B0IN,  1,Â
            B0DY,  1,Â
            B0PF,  1,Â
            B0TF,  1,Â
            B0CL,  1,Â
            B0LW,  1,Â
            B0DC,  1,Â
            B0DD,  1,Â
            B0FC,  1,Â
            B0PC,  1,Â
            B0OT,  1,Â
              ,  1,Â
            B0WK,  1,Â
            B0IC,  1,Â
            B0WC,  1,Â
            B0L3,  1,Â
            B0FG,  1,Â
            B0DG,  1,Â
            B0VL,  1,Â
            B0RY,  1,Â
            B0AL,  1,Â
            B0AF,  1,Â
            B0NI,  1,Â
            B0LI,  1,Â
            SME0,  1,Â
            SME1,  1,Â
            SME2,  1,Â
            SME3,  1,Â
            FLDG,  1,Â
            FLCG,  1,Â
            DSG0,  1,Â
            INIT,  1,Â
            RTAM,  1,Â
            RCAM,  1,Â
              ,  1,Â
            TDAM,  1,Â
            OTAM,  1,Â
              ,  1,Â
            TCAM,  1,Â
            OCAM,  1,Â
            CAP1,  16,Â
            RCP1,  16,Â
            VOT1,  16,Â
            CRT1,  16,Â
            BTM1,  16,Â
            BST1,  16,Â
            BRC1,  16,Â
            FCP1,  16,Â
            DCP1,  16,Â
            DVT1,  16,Â
            MER1,  16,Â
            MFD1,  16,Â
            BSN1,  16,Â
            MAS1,  16,Â
            Offset (0xF3),Â
            BCS1,  8,Â
            MNN1,  8,Â
            DNN1,  8,Â
            BCN1,  8,Â
            BOC1,  8,Â
            BFC1,  8,Â
            BMD1,  8,Â
            CPL1,  8,Â
            B1IN,  1,Â
            B1DY,  1,Â
            B1PF,  1,Â
            B1TF,  1,Â
            B1CL,  1,Â
            B1LW,  1,Â
            B1DC,  1,Â
            B1DD,  1,Â
            B1FC,  1,Â
            B1PC,  1,Â
            B1OT,  1,Â
              ,  1,Â
            B1WK,  1,Â
            B1IC,  1,Â
            B1WC,  1,Â
            B1L3,  1,Â
            B1FG,  1,Â
            B1DG,  1,Â
            B1VL,  1,Â
            B1RY,  1,Â
            B1AL,  1,Â
            B1AF,  1,Â
            B1NI,  1,Â
            B1LI,  1,Â
            SLM1,  8,Â
            SLM2,  8
          }
          Mutex (MUT0, 0x00)
          Method (_QB1, 0, NotSerialized) // _Qxx: EC Query
          {
            If ((OSYS == 0x07D1) || (OSYS == 0x07D2))
            {
              Local0 = Zero
              If (PWRS)
              {
                If (BRGA == Zero)
                {
                  BRTL = 0x06
                }
                If (BRGA == One)
                {
                  BRTL = 0x0C
                }
                If (BRGA == 0x02)
                {
                  BRTL = 0x12
                }
                If (BRGA == 0x03)
                {
                  BRTL = 0x18
                }
                If (BRGA == 0x04)
                {
                  BRTL = 0x1E
                }
                If (BRGA == 0x05)
                {
                  BRTL = 0x24
                }
                If (BRGA == 0x06)
                {
                  BRTL = 0x2A
                }
                If (BRGA == 0x07)
                {
                  BRTL = 0x30
                }
                If (BRGA == 0x08)
                {
                  BRTL = 0x36
                }
                If (BRGA == 0x09)
                {
                  BRTL = 0x3C
                }
                If (BRGA == 0x0A)
                {
                  BRTL = 0x42
                }
                If (BRGA == 0x0B)
                {
                  BRTL = 0x48
                }
                If (BRGA == 0x0C)
                {
                  BRTL = 0x4E
                }
                If (BRGA == 0x0D)
                {
                  BRTL = 0x54
                }
                If (BRGA == 0x0E)
                {
                  BRTL = 0x5A
                }
                If (BRGA == 0x0F)
                {
                  BRTL = 0x64
                }
              }
              Else
              {
                If (BRGD == Zero)
                {
                  BRTL = 0x06
                }
                If (BRGD == One)
                {
                  BRTL = 0x0C
                }
                If (BRGD == 0x02)
                {
                  BRTL = 0x12
                }
                If (BRGD == 0x03)
                {
                  BRTL = 0x18
                }
                If (BRGD == 0x04)
                {
                  BRTL = 0x1E
                }
                If (BRGD == 0x05)
                {
                  BRTL = 0x24
                }
                If (BRGD == 0x06)
                {
                  BRTL = 0x2A
                }
                If (BRGD == 0x07)
                {
                  BRTL = 0x30
                }
                If (BRGD == 0x08)
                {
                  BRTL = 0x36
                }
                If (BRGD == 0x09)
                {
                  BRTL = 0x3C
                }
                If (BRGD == 0x0A)
                {
                  BRTL = 0x42
                }
                If (BRGD == 0x0B)
                {
                  BRTL = 0x48
                }
                If (BRGD == 0x0C)
                {
                  BRTL = 0x4E
                }
                If (BRGD == 0x0D)
                {
                  BRTL = 0x54
                }
                If (BRGD == 0x0E)
                {
                  BRTL = 0x5A
                }
                If (BRGD == 0x0F)
                {
                  BRTL = 0x64
                }
              }
              ^^^IGPU.AINT (One, BRTL)
            }
          }
          Method (_O80, 0, NotSerialized)
          {
            P8XH (Zero, 0x80)
            If (OSYS == 0x07D6)
            {
              Local0 = Zero
              If (BRID == One)
              {
                Notify (^^^PEG0.PEGP.DD02, 0x86) // Device-Specific
              }
              Notify (^^^IGPU.DD02, 0x86) // Device-Specific
              Local0 = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
              Local0 &= 0xFF
              If ((Local0 >= Zero) && (Local0 < 0x07))
              {
                Local0 = Zero
              }
              If ((Local0 >= 0x07) && (Local0 < 0x0D))
              {
                Local0 = One
              }
              If ((Local0 >= 0x0D) && (Local0 < 0x13))
              {
                Local0 = 0x02
              }
              If ((Local0 >= 0x13) && (Local0 < 0x19))
              {
                Local0 = 0x03
              }
              If ((Local0 >= 0x19) && (Local0 < 0x1F))
              {
                Local0 = 0x04
              }
              If ((Local0 >= 0x1F) && (Local0 < 0x25))
              {
                Local0 = 0x05
              }
              If ((Local0 >= 0x25) && (Local0 < 0x2B))
              {
                Local0 = 0x06
              }
              If ((Local0 >= 0x2B) && (Local0 < 0x31))
              {
                Local0 = 0x07
              }
              If ((Local0 >= 0x31) && (Local0 < 0x37))
              {
                Local0 = 0x08
              }
              If ((Local0 >= 0x37) && (Local0 < 0x3D))
              {
                Local0 = 0x09
              }
              If ((Local0 >= 0x3D) && (Local0 < 0x43))
              {
                Local0 = 0x0A
              }
              If ((Local0 >= 0x43) && (Local0 < 0x49))
              {
                Local0 = 0x0B
              }
              If ((Local0 >= 0x49) && (Local0 < 0x4F))
              {
                Local0 = 0x0C
              }
              If ((Local0 >= 0x4F) && (Local0 < 0x55))
              {
                Local0 = 0x0D
              }
              If ((Local0 >= 0x55) && (Local0 < 0x5B))
              {
                Local0 = 0x0E
              }
              If (Local0 >= 0x5B)
              {
                Local0 = 0x0F
              }
              If (Local0 == 0x0F) {}
              Else
              {
                Local0++
              }
              If (PWRS)
              {
                BRGA = Local0
              }
              Else
              {
                BRGD = Local0
              }
              ^^^^AMW0.INF0 = 0x03
              ^^^^AMW0.INF1 = Zero
              ^^^^AMW0.INF2 = 0xE006
              ^^^^AMW0.INF3 = Local0
              If (DMFG == Zero)
              {
                Notify (AMW0, 0xD0) // Hardware-Specific
              }
            }
            Else
            {
              If (CondRefOf (HBRT))
              {
                HBRT (0x03)
              }
              If (IGDS)
              {
                If (0x04 & DSEN)
                {
                  BRTN (0x86)
                }
                Else
                {
                  Local0 = BRTL /* \BRTL */
                  BRTL = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
                  BRTL = ((BRTL + One) & 0xFE)
                  If (BRTL <= 0x5A)
                  {
                    BRTL += 0x0A
                  }
                  If ((OSYS == 0x07D1) || (OSYS == 0x07D2))
                  {
                    Local0 = Zero
                    Local0 = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
                    Local0 &= 0xFF
                    If (Local0 <= 0x0D)
                    {
                      Local0 = 0x0E
                    }
                    ElseIf (Local0 <= 0x5E)
                    {
                      Local0 += 0x06
                    }
                    If ((Local0 >= Zero) && (Local0 < 0x07))
                    {
                      BRTL = 0x06
                    }
                    If ((Local0 >= 0x07) && (Local0 < 0x0D))
                    {
                      BRTL = 0x0C
                    }
                    If ((Local0 >= 0x0D) && (Local0 < 0x13))
                    {
                      BRTL = 0x12
                    }
                    If ((Local0 >= 0x13) && (Local0 < 0x19))
                    {
                      BRTL = 0x18
                    }
                    If ((Local0 >= 0x19) && (Local0 < 0x1F))
                    {
                      BRTL = 0x1E
                    }
                    If ((Local0 >= 0x1F) && (Local0 < 0x25))
                    {
                      BRTL = 0x24
                    }
                    If ((Local0 >= 0x25) && (Local0 < 0x2B))
                    {
                      BRTL = 0x2A
                    }
                    If ((Local0 >= 0x2B) && (Local0 < 0x31))
                    {
                      BRTL = 0x30
                    }
                    If ((Local0 >= 0x31) && (Local0 < 0x37))
                    {
                      BRTL = 0x36
                    }
                    If ((Local0 >= 0x37) && (Local0 < 0x3D))
                    {
                      BRTL = 0x3C
                    }
                    If ((Local0 >= 0x3D) && (Local0 < 0x43))
                    {
                      BRTL = 0x42
                    }
                    If ((Local0 >= 0x43) && (Local0 < 0x49))
                    {
                      BRTL = 0x48
                    }
                    If ((Local0 >= 0x49) && (Local0 < 0x4F))
                    {
                      BRTL = 0x4E
                    }
                    If ((Local0 >= 0x4F) && (Local0 < 0x55))
                    {
                      BRTL = 0x54
                    }
                    If ((Local0 >= 0x55) && (Local0 < 0x5B))
                    {
                      BRTL = 0x5A
                    }
                    If (Local0 >= 0x5B)
                    {
                      BRTL = 0x64
                    }
                  }
                  ^^^IGPU.AINT (One, BRTL)
                }
              }
              Local0 = Zero
              If (BRID == One)
              {
                Notify (^^^PEG0.PEGP.DD02, 0x86) // Device-Specific
              }
              Notify (^^^IGPU.DD02, 0x86) // Device-Specific
              Local0 = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
              Local0 &= 0xFF
              If ((Local0 >= Zero) && (Local0 < 0x07))
              {
                Local0 = Zero
              }
              If ((Local0 >= 0x07) && (Local0 < 0x0D))
              {
                Local0 = One
              }
              If ((Local0 >= 0x0D) && (Local0 < 0x13))
              {
                Local0 = 0x02
              }
              If ((Local0 >= 0x13) && (Local0 < 0x19))
              {
                Local0 = 0x03
              }
              If ((Local0 >= 0x19) && (Local0 < 0x1F))
              {
                Local0 = 0x04
              }
              If ((Local0 >= 0x1F) && (Local0 < 0x25))
              {
                Local0 = 0x05
              }
              If ((Local0 >= 0x25) && (Local0 < 0x2B))
              {
                Local0 = 0x06
              }
              If ((Local0 >= 0x2B) && (Local0 < 0x31))
              {
                Local0 = 0x07
              }
              If ((Local0 >= 0x31) && (Local0 < 0x37))
              {
                Local0 = 0x08
              }
              If ((Local0 >= 0x37) && (Local0 < 0x3D))
              {
                Local0 = 0x09
              }
              If ((Local0 >= 0x3D) && (Local0 < 0x43))
              {
                Local0 = 0x0A
              }
              If ((Local0 >= 0x43) && (Local0 < 0x49))
              {
                Local0 = 0x0B
              }
              If ((Local0 >= 0x49) && (Local0 < 0x4F))
              {
                Local0 = 0x0C
              }
              If ((Local0 >= 0x4F) && (Local0 < 0x55))
              {
                Local0 = 0x0D
              }
              If ((Local0 >= 0x55) && (Local0 < 0x5B))
              {
                Local0 = 0x0E
              }
              If (Local0 >= 0x5B)
              {
                Local0 = 0x0F
              }
              If (Local0 == 0x0F) {}
              Else
              {
                Local0++
              }
              If (PWRS)
              {
                BRGA = Local0
              }
              Else
              {
                BRGD = Local0
              }
              ^^^^AMW0.INF0 = 0x03
              ^^^^AMW0.INF1 = Zero
              ^^^^AMW0.INF2 = 0xE006
              ^^^^AMW0.INF3 = Local0
              If (DMFG == Zero)
              {
                Notify (AMW0, 0xD0) // Hardware-Specific
              }
            }
          }
          Method (_O81, 0, NotSerialized)
          {
            P8XH (Zero, 0x81)
            If (OSYS == 0x07D6)
            {
              Local0 = Zero
              If (BRID == One)
              {
                Notify (^^^PEG0.PEGP.DD02, 0x87) // Device-Specific
              }
              Notify (^^^IGPU.DD02, 0x87) // Device-Specific
              Local0 = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
              Local0 &= 0xFF
              If ((Local0 >= Zero) && (Local0 < 0x07))
              {
                Local0 = Zero
              }
              If ((Local0 >= 0x07) && (Local0 < 0x0D))
              {
                Local0 = One
              }
              If ((Local0 >= 0x0D) && (Local0 < 0x13))
              {
                Local0 = 0x02
              }
              If ((Local0 >= 0x13) && (Local0 < 0x19))
              {
                Local0 = 0x03
              }
              If ((Local0 >= 0x19) && (Local0 < 0x1F))
              {
                Local0 = 0x04
              }
              If ((Local0 >= 0x1F) && (Local0 < 0x25))
              {
                Local0 = 0x05
              }
              If ((Local0 >= 0x25) && (Local0 < 0x2B))
              {
                Local0 = 0x06
              }
              If ((Local0 >= 0x2B) && (Local0 < 0x31))
              {
                Local0 = 0x07
              }
              If ((Local0 >= 0x31) && (Local0 < 0x37))
              {
                Local0 = 0x08
              }
              If ((Local0 >= 0x37) && (Local0 < 0x3D))
              {
                Local0 = 0x09
              }
              If ((Local0 >= 0x3D) && (Local0 < 0x43))
              {
                Local0 = 0x0A
              }
              If ((Local0 >= 0x43) && (Local0 < 0x49))
              {
                Local0 = 0x0B
              }
              If ((Local0 >= 0x49) && (Local0 < 0x4F))
              {
                Local0 = 0x0C
              }
              If ((Local0 >= 0x4F) && (Local0 < 0x55))
              {
                Local0 = 0x0D
              }
              If ((Local0 >= 0x55) && (Local0 < 0x5B))
              {
                Local0 = 0x0E
              }
              If (Local0 >= 0x5B)
              {
                Local0 = 0x0F
              }
              If (Local0 == Zero) {}
              Else
              {
                Local0--
              }
              If (PWRS)
              {
                BRGA = Local0
              }
              Else
              {
                BRGD = Local0
              }
              ^^^^AMW0.INF0 = 0x03
              ^^^^AMW0.INF1 = Zero
              ^^^^AMW0.INF2 = 0xE005
              ^^^^AMW0.INF3 = Local0
              If (DMFG == Zero)
              {
                Notify (AMW0, 0xD0) // Hardware-Specific
              }
            }
            Else
            {
              If (CondRefOf (HBRT))
              {
                HBRT (0x04)
              }
              If (IGDS)
              {
                If (0x04 & DSEN)
                {
                  BRTN (0x87)
                }
                Else
                {
                  Local0 = BRTL /* \BRTL */
                  BRTL = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
                  BRTL = ((BRTL + One) & 0xFE)
                  If (BRTL >= 0x0A)
                  {
                    BRTL -= 0x0A
                  }
                  If ((OSYS == 0x07D1) || (OSYS == 0x07D2))
                  {
                    Local0 = Zero
                    Local0 = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
                    Local0 &= 0xFF
                    If (Local0 >= 0x12)
                    {
                      Local0 -= 0x06
                    }
                    Else
                    {
                      Local0 = 0x0C
                    }
                    If ((Local0 >= Zero) && (Local0 < 0x07))
                    {
                      BRTL = 0x06
                    }
                    If ((Local0 >= 0x07) && (Local0 < 0x0D))
                    {
                      BRTL = 0x0C
                    }
                    If ((Local0 >= 0x0D) && (Local0 < 0x13))
                    {
                      BRTL = 0x12
                    }
                    If ((Local0 >= 0x13) && (Local0 < 0x19))
                    {
                      BRTL = 0x18
                    }
                    If ((Local0 >= 0x19) && (Local0 < 0x1F))
                    {
                      BRTL = 0x1E
                    }
                    If ((Local0 >= 0x1F) && (Local0 < 0x25))
                    {
                      BRTL = 0x24
                    }
                    If ((Local0 >= 0x25) && (Local0 < 0x2B))
                    {
                      BRTL = 0x2A
                    }
                    If ((Local0 >= 0x2B) && (Local0 < 0x31))
                    {
                      BRTL = 0x30
                    }
                    If ((Local0 >= 0x31) && (Local0 < 0x37))
                    {
                      BRTL = 0x36
                    }
                    If ((Local0 >= 0x37) && (Local0 < 0x3D))
                    {
                      BRTL = 0x3C
                    }
                    If ((Local0 >= 0x3D) && (Local0 < 0x43))
                    {
                      BRTL = 0x42
                    }
                    If ((Local0 >= 0x43) && (Local0 < 0x49))
                    {
                      BRTL = 0x48
                    }
                    If ((Local0 >= 0x49) && (Local0 < 0x4F))
                    {
                      BRTL = 0x4E
                    }
                    If ((Local0 >= 0x4F) && (Local0 < 0x55))
                    {
                      BRTL = 0x54
                    }
                    If ((Local0 >= 0x55) && (Local0 < 0x5B))
                    {
                      BRTL = 0x5A
                    }
                    If (Local0 >= 0x5B)
                    {
                      BRTL = 0x64
                    }
                  }
                  ^^^IGPU.AINT (One, BRTL)
                }
              }
              Local0 = Zero
              If (BRID == One)
              {
                Notify (^^^PEG0.PEGP.DD02, 0x87) // Device-Specific
              }
              Notify (^^^IGPU.DD02, 0x87) // Device-Specific
              Local0 = ^^^IGPU.CBLV /* \_SB_.PCI0.IGPU.CBLV */
              Local0 &= 0xFF
              If ((Local0 >= Zero) && (Local0 < 0x07))
              {
                Local0 = Zero
              }
              If ((Local0 >= 0x07) && (Local0 < 0x0D))
              {
                Local0 = One
              }
              If ((Local0 >= 0x0D) && (Local0 < 0x13))
              {
                Local0 = 0x02
              }
              If ((Local0 >= 0x13) && (Local0 < 0x19))
              {
                Local0 = 0x03
              }
              If ((Local0 >= 0x19) && (Local0 < 0x1F))
              {
                Local0 = 0x04
              }
              If ((Local0 >= 0x1F) && (Local0 < 0x25))
              {
                Local0 = 0x05
              }
              If ((Local0 >= 0x25) && (Local0 < 0x2B))
              {
                Local0 = 0x06
              }
              If ((Local0 >= 0x2B) && (Local0 < 0x31))
              {
                Local0 = 0x07
              }
              If ((Local0 >= 0x31) && (Local0 < 0x37))
              {
                Local0 = 0x08
              }
              If ((Local0 >= 0x37) && (Local0 < 0x3D))
              {
                Local0 = 0x09
              }
              If ((Local0 >= 0x3D) && (Local0 < 0x43))
              {
                Local0 = 0x0A
              }
              If ((Local0 >= 0x43) && (Local0 < 0x49))
              {
                Local0 = 0x0B
              }
              If ((Local0 >= 0x49) && (Local0 < 0x4F))
              {
                Local0 = 0x0C
              }
              If ((Local0 >= 0x4F) && (Local0 < 0x55))
              {
                Local0 = 0x0D
              }
              If ((Local0 >= 0x55) && (Local0 < 0x5B))
              {
                Local0 = 0x0E
              }
              If (Local0 >= 0x5B)
              {
                Local0 = 0x0F
              }
              If (Local0 == Zero) {}
              Else
              {
                Local0--
              }
              If (PWRS)
              {
                BRGA = Local0
              }
              Else
              {
                BRGD = Local0
              }
              ^^^^AMW0.INF0 = 0x03
              ^^^^AMW0.INF1 = Zero
              ^^^^AMW0.INF2 = 0xE005
              ^^^^AMW0.INF3 = Local0
              If (DMFG == Zero)
              {
                Notify (AMW0, 0xD0) // Hardware-Specific
              }
            }
          }
          Method (_Q82, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x82)
            Notify (LID0, 0x80) // Status Change
            If ((OSYS == 0x07D1) || (OSYS == 0x07D2))
            {
              PHSR (0x82)
            }
          }
          Method (_Q83, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x83)
            Acquire (MUT0, 0xFFFF)
            PWRS = ACIN /* \_SB_.PCI0.LPCB.EC0_.ACIN */
            Release (MUT0)
            Notify (ADP1, 0x80) // Status Change
            If ((OSYS == 0x07D1) || (OSYS == 0x07D2))
            {
              If (BRGA == Zero)
              {
                Local0 = 0x06
              }
              If (BRGA == One)
              {
                Local0 = 0x0C
              }
              If (BRGA == 0x02)
              {
                Local0 = 0x12
              }
              If (BRGA == 0x03)
              {
                Local0 = 0x18
              }
              If (BRGA == 0x04)
              {
                Local0 = 0x1E
              }
              If (BRGA == 0x05)
              {
                Local0 = 0x24
              }
              If (BRGA == 0x06)
              {
                Local0 = 0x2A
              }
              If (BRGA == 0x07)
              {
                Local0 = 0x30
              }
              If (BRGA == 0x08)
              {
                Local0 = 0x36
              }
              If (BRGA == 0x09)
              {
                Local0 = 0x3C
              }
              If (BRGA == 0x0A)
              {
                Local0 = 0x42
              }
              If (BRGA == 0x0B)
              {
                Local0 = 0x48
              }
              If (BRGA == 0x0C)
              {
                Local0 = 0x4E
              }
              If (BRGA == 0x0D)
              {
                Local0 = 0x54
              }
              If (BRGA == 0x0E)
              {
                Local0 = 0x5A
              }
              If (BRGA == 0x0F)
              {
                Local0 = 0x64
              }
              ^^^IGPU.AINT (One, Local0)
            }
            OCNT ()
          }
          Method (_Q84, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x84)
            Acquire (MUT0, 0xFFFF)
            PWRS = ACIN /* \_SB_.PCI0.LPCB.EC0_.ACIN */
            Release (MUT0)
            Notify (ADP1, 0x80) // Status Change
            If ((OSYS == 0x07D1) || (OSYS == 0x07D2))
            {
              If (BRGD == Zero)
              {
                Local0 = 0x06
              }
              If (BRGD == One)
              {
                Local0 = 0x0C
              }
              If (BRGD == 0x02)
              {
                Local0 = 0x12
              }
              If (BRGD == 0x03)
              {
                Local0 = 0x18
              }
              If (BRGD == 0x04)
              {
                Local0 = 0x1E
              }
              If (BRGD == 0x05)
              {
                Local0 = 0x24
              }
              If (BRGD == 0x06)
              {
                Local0 = 0x2A
              }
              If (BRGD == 0x07)
              {
                Local0 = 0x30
              }
              If (BRGD == 0x08)
              {
                Local0 = 0x36
              }
              If (BRGD == 0x09)
              {
                Local0 = 0x3C
              }
              If (BRGD == 0x0A)
              {
                Local0 = 0x42
              }
              If (BRGD == 0x0B)
              {
                Local0 = 0x48
              }
              If (BRGD == 0x0C)
              {
                Local0 = 0x4E
              }
              If (BRGD == 0x0D)
              {
                Local0 = 0x54
              }
              If (BRGD == 0x0E)
              {
                Local0 = 0x5A
              }
              If (BRGD == 0x0F)
              {
                Local0 = 0x64
              }
              ^^^IGPU.AINT (One, Local0)
            }
            OCNT ()
          }
          Method (_Q85, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x85)
            Acquire (MUT0, 0xFFFF)
            ^^^^BAT0.BTST ()
            Notify (BAT0, 0x80) // Status Change
            Sleep (0x32)
            If (^^^^BAT0.BTCH)
            {
              Notify (BAT0, 0x81) // Information Change
              ^^^^BAT0.BTCH = Zero
            }
            Release (MUT0)
          }
          Method (_Q86, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x86)
            Acquire (MUT0, 0xFFFF)
            ^^^^BAT0.BSTA = Zero
            Notify (BAT0, 0x80) // Status Change
            Sleep (0x32)
            Notify (BAT0, 0x81) // Information Change
            ^^^^BAT0.BTP = Zero
            Release (MUT0)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE00E
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_Q87, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x87)
          }
          Method (_Q88, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x88)
          }
          Method (_Q89, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x89)
          }
          Method (_O8A, 0, NotSerialized)
          {
            P8XH (Zero, 0x8A)
            Local0 = Zero
            Acquire (MUT0, 0xFFFF)
            Local0 = KBBL /* \_SB_.PCI0.LPCB.EC0_.KBBL */
            Release (MUT0)
            ^^^^AMW0.INF0 = 0x03
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE00C
            ^^^^AMW0.INF3 = Local0
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_O8C, 0, NotSerialized)
          {
            P8XH (Zero, 0x8C)
            Local0 = Zero
            Local1 = Zero
            Local2 = Zero
            Local3 = Zero
            WCA1 = 0xF2
            FOWM (0x11, 0x0B)
            Local0 = WFI1 /* \WFI1 */
            Local1 = WFI2 /* \WFI2 */
            Local2 = 0x0100
            Local3 = One
            If (WIFS)
            {
              ^^^^AMW0.INF0 = 0x06
              ^^^^AMW0.INF1 = Zero
              ^^^^AMW0.INF2 = 0xE008
              ^^^^AMW0.INF3 = Local0
              ^^^^AMW0.INF4 = Local1
              ^^^^AMW0.INF5 = Local2
              ^^^^AMW0.INF6 = Local3
              If (DMFG == Zero)
              {
                Notify (AMW0, 0xD0) // Hardware-Specific
              }
            }
          }
          Method (_Q8D, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x8D)
          }
          Method (_Q8E, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x8E)
            Notify (SLPB, 0x80) // Status Change
          }
          Method (_Q8F, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x8F)
            Notify (BAT0, 0x80) // Status Change
          }
          Method (_Q90, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x90)
            Notify (BAT0, 0x80) // Status Change
          }
          Method (_Q91, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x91)
            PHSR (0x91)
          }
          Method (_Q92, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x92)
            PHSR (0x92)
          }
          Method (_Q93, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x93)
            PHSR (0x93)
          }
          Method (_Q94, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x94)
            PHSR (0x94)
          }
          Method (_Q95, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x95)
            PHSR (0x95)
          }
          Method (_Q96, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x96)
            PHSR (0x96)
          }
          Method (_Q97, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x97)
            PHSR (0x97)
          }
          Method (_Q98, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x98)
            PHSR (0x98)
          }
          Name (\MY9A, Zero)
          Method (_Q9A, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x9A)
            Local0 = NOS0 /* \_SB_.PCI0.LPCB.EC0_.NOS0 */
            MY9A = Local0
            \_PR.CPU0._PPC = Local0
            Notify (\_PR.CPU0, 0x80) // Performance Capability Change
          }
          Method (_QA0, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA0)
          }
          Method (_QA1, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA1)
          }
          Method (_QA2, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA2)
          }
          Method (_QA3, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA3)
            If (OSYS <= 0x07D6)
            {
              If (IGDS)
              {
                If (QCKS)
                {
                  ^^^^AMW0.INF0 = 0x05
                  ^^^^AMW0.INF1 = Zero
                  ^^^^AMW0.INF2 = 0xE09B
                  ^^^^AMW0.INF3 = NDSS /* \NDSS */
                  ^^^^AMW0.INF4 = ADSD /* \ADSD */
                  ^^^^AMW0.INF5 = CADD /* \CADD */
                  If (DMFG == Zero)
                  {
                    Notify (AMW0, 0xD0) // Hardware-Specific
                  }
                }
                Else
                {
                  ^^^IGPU.GHDS (Zero)
                }
              }
            }
          }
          Method (_QA4, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, DDMB)
            If (IGDS)
            {
              If (One == DDMB)
              {
                ^^^IGPU.NADL = 0x0400
                ^^^IGPU.NDL2 = Zero
              }
              If (0x02 == DDMB)
              {
                ^^^IGPU.NADL = 0x0100
                ^^^IGPU.NDL2 = Zero
              }
              If (0x10 == DDMB)
              {
                ^^^IGPU.NADL = 0x0300
                ^^^IGPU.NDL2 = Zero
              }
              If (0x03 == DDMB)
              {
                ^^^IGPU.NADL = 0x0400
                ^^^IGPU.NDL2 = 0x0100
              }
              If (0x11 == DDMB)
              {
                ^^^IGPU.NADL = 0x0400
                ^^^IGPU.NDL2 = 0x0300
                ^^^IGPU.GHDS (Zero)
              }
              If (0x12 == DDMB)
              {
                ^^^IGPU.NADL = 0x0300
                ^^^IGPU.NDL2 = 0x0100
                ^^^IGPU.GHDS (Zero)
              }
              ^^^IGPU.GHDS (Zero)
            }
          }
          Method (_QA6, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA6)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE023
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QA7, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA7)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE0F7
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QA8, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA8)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE02E
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QA9, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xA9)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE030
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QAA, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xAA)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE026
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QAC, 0, NotSerialized) // _Qxx: EC Query
          {
            Sleep (0x32)
            P8XH (Zero, 0xAC)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE027
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_OAF, 0, NotSerialized)
          {
            P8XH (Zero, 0xAF)
            Notify (MBT, 0x80) // Status Change
          }
          Method (_QAD, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xAD)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE025
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QAE, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xAE)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE028
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QB0, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xB0)
            SSMP = 0xAC
            SBF0 = BSBF /* \BSBF */
          }
          Method (_QD0, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xD0)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE0F8
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QD1, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xD1)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE0F9
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QE0, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xE0)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0x3A
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QE1, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xE1)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE045
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QE3, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xE3)
            WCA3 = Zero
            WCA4 = Zero
            FOWM (0x11, 0x05)
            Acquire (MUT0, 0xFFFF)
            Local0 = ACIN /* \_SB_.PCI0.LPCB.EC0_.ACIN */
            Local1 = DADP /* \_SB_.PCI0.LPCB.EC0_.DADP */
            Local2 = ACTP /* \_SB_.PCI0.LPCB.EC0_.ACTP */
            ^^^^AMW0.INF0 = 0x06
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE00D
            ^^^^AMW0.INF3 = Zero
            ^^^^AMW0.INF4 = Zero
            ^^^^AMW0.INF5 = Zero
            ^^^^AMW0.INF6 = Zero
            If (BRID == Zero)
            {
              Local7 = 0x41
            }
            If (BRID == One)
            {
              Local7 = 0x5A
            }
            If (BEMQ == 0x02)
            {
              If (B0IN == One)
              {
                If (DNN0 != 0xFF)
                {
                  ^^^^AMW0.INF3 = 0x12
                  Notify (AMW0, 0xD0) // Hardware-Specific
                }
                ElseIf (B0PF == One)
                {
                  ^^^^AMW0.INF3 = 0x16
                  Notify (AMW0, 0xD0) // Hardware-Specific
                }
                ElseIf (B0TF == One)
                {
                  ^^^^AMW0.INF3 = 0x15
                  Notify (AMW0, 0xD0) // Hardware-Specific
                }
              }
            }
            If (BEMQ == One)
            {
              If (Local0 == One)
              {
                Local7 <<= 0x08
                If (Local2 == Zero)
                {
                  ^^^^AMW0.INF3 = One
                  ^^^^AMW0.INF5 = One
                  ^^^^AMW0.INF6 = Local7
                  Notify (AMW0, 0xD0) // Hardware-Specific
                }
                ElseIf (Local2 < Local7)
                {
                  If (Local2 == 0x2D)
                  {
                    ^^^^AMW0.INF3 = 0x05
                    ^^^^AMW0.INF5 = One
                    ^^^^AMW0.INF6 = Local7
                  }
                  If (Local2 == 0x41)
                  {
                    ^^^^AMW0.INF3 = 0x02
                    ^^^^AMW0.INF5 = 0x04
                    ^^^^AMW0.INF6 = Local7
                  }
                  Notify (AMW0, 0xD0) // Hardware-Specific
                }
              }
            }
            Release (MUT0)
          }
          Method (_QF1, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF1)
          }
          Method (_QF2, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF2)
          }
          Method (_QF3, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF3)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE007
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QF4, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF4)
          }
          Method (_QF5, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF5)
          }
          Method (_QF6, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF6)
          }
          Method (_QF7, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF7)
          }
          Method (_QF8, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF8)
            If (OSYS <= 0x07D6)
            {
              If (IGDS)
              {
                If (QCKS)
                {
                  UPST ()
                  ^^^^AMW0.INF0 = 0x05
                  ^^^^AMW0.INF1 = Zero
                  ^^^^AMW0.INF2 = 0xE01B
                  ^^^^AMW0.INF3 = NDSS /* \NDSS */
                  ^^^^AMW0.INF4 = ADSD /* \ADSD */
                  ^^^^AMW0.INF5 = CADD /* \CADD */
                  If (DMFG == Zero)
                  {
                    Notify (AMW0, 0xD0) // Hardware-Specific
                  }
                }
              }
              Else
              {
                ^^^IGPU.GHDS (Zero)
              }
              QA3E = One
            }
          }
          Name (TMPP, Zero)
          Name (CRTD, Zero)
          Name (LCDD, Zero)
          Name (HDMI, Zero)
          Method (CDEV, 1, NotSerialized)
          {
            Local0 = (Arg0 & 0x0F00)
            Local0 >>= 0x08
            Local0--
            Local1 = One
            Local1 <<= Local0
            Local2 = Zero
            If (One)
            {
              If (Local1 & One)
              {
                Local2 |= 0x02
              }
              If (Local1 & 0x04)
              {
                Local2 |= 0x10
              }
              If (Local1 & 0x08)
              {
                Local2 |= One
              }
              If (Local2 == 0x02)
              {
                CRTD = Arg0
              }
              ElseIf (Local2 == One)
              {
                LCDD = Arg0
              }
              ElseIf (Local2 == 0x10)
              {
                HDMI = Arg0
              }
            }
            Return (Local2)
          }
          Method (UPST, 0, NotSerialized)
          {
            Local0 = Zero
            If (^^^IGPU.CPDL != Zero)
            {
              Local0 |= CDEV (^^^IGPU.CPDL)
              TMPP++
            }
            If (^^^IGPU.CPL2 != Zero)
            {
              Local0 |= CDEV (^^^IGPU.CPL2)
              TMPP++
            }
            If (^^^IGPU.CPL3 != Zero)
            {
              Local0 |= CDEV (^^^IGPU.CPL3)
              TMPP++
            }
            If (^^^IGPU.CPL4 != Zero)
            {
              Local0 |= CDEV (^^^IGPU.CPL4)
              TMPP++
            }
            Local1 = Zero
            If (^^^IGPU.CADL != Zero)
            {
              Local1 |= CDEV (^^^IGPU.CADL)
            }
            If (^^^IGPU.CAL2 != Zero)
            {
              Local1 |= CDEV (^^^IGPU.CAL2)
            }
            If (^^^IGPU.CAL3 != Zero)
            {
              Local1 |= CDEV (^^^IGPU.CAL3)
            }
            If (^^^IGPU.CAL4 != Zero)
            {
              Local1 |= CDEV (^^^IGPU.CAL4)
            }
            NDSS = Local1
            If (One)
            {
              If (Local0 == 0x13)
              {
                If (NDSS == One)
                {
                  Local2 = 0x03
                }
                ElseIf (NDSS == 0x03)
                {
                  Local2 = 0x02
                }
                ElseIf (NDSS == 0x02)
                {
                  Local2 = 0x11
                }
                ElseIf (NDSS == 0x11)
                {
                  Local2 = 0x10
                }
                ElseIf (NDSS == 0x10)
                {
                  Local2 = 0x12
                }
                ElseIf (NDSS == 0x12)
                {
                  Local2 = One
                }
              }
              ElseIf (Local0 == 0x11)
              {
                If (NDSS == One)
                {
                  Local2 = 0x11
                }
                ElseIf (NDSS == 0x11)
                {
                  Local2 = 0x10
                }
                ElseIf (NDSS == 0x10)
                {
                  Local2 = One
                }
              }
              ElseIf (Local0 == 0x03)
              {
                If (NDSS == One)
                {
                  Local2 = 0x03
                }
                ElseIf (NDSS == 0x03)
                {
                  Local2 = 0x02
                }
                ElseIf (NDSS == 0x02)
                {
                  Local2 = One
                }
              }
            }
            CADD = Local0
            ADSD = Local1
            NDSS = Local2
            CDEV (^^^IGPU.DIDL)
            CDEV (^^^IGPU.DDL2)
            CDEV (^^^IGPU.DDL3)
            CDEV (^^^IGPU.DDL4)
          }
          Method (_QF9, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xF9)
          }
          Method (_QFA, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xFA)
            ^^^^AMW0.INF0 = 0x02
            ^^^^AMW0.INF1 = Zero
            ^^^^AMW0.INF2 = 0xE009
            If (DMFG == Zero)
            {
              Notify (AMW0, 0xD0) // Hardware-Specific
            }
          }
          Method (_QFB, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xFB)
          }
          Method (_QFC, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0xFC)
          }
          Method (_Q9F, 0, NotSerialized) // _Qxx: EC Query
          {
            P8XH (Zero, 0x9F)
            Local0 = Zero
            Local1 = Zero
            Local2 = Zero
            Local3 = Zero
            If (QCKS == Zero)
            {
              WCA1 = 0xF2
              FOWM (0x11, 0x0B)
            }
            Local0 = WFI1 /* \WFI1 */
            Local1 = WFI2 /* \WFI2 */
            Local2 = 0x0100
            Local3 = One
            If (WIFS)
            {
              ^^^^AMW0.INF0 = 0x06
              ^^^^AMW0.INF1 = Zero
              ^^^^AMW0.INF2 = 0xE008
              ^^^^AMW0.INF3 = Local0
              ^^^^AMW0.INF4 = Local1
              ^^^^AMW0.INF5 = Local2
              ^^^^AMW0.INF6 = Local3
              If (DMFG == Zero)
              {
                Notify (AMW0, 0xD0) // Hardware-Specific
              }
            }
          }
        }
        Scope (\_SB)
        {
          Device (PWRB)
          {
            Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID
          }
          Device (SLPB)
          {
            Name (_HID, EisaId ("PNP0C0E") /* Sleep Button Device */) // _HID: Hardware ID
          }
          Device (LID0)
          {
            Name (_HID, EisaId ("PNP0C0D") /* Lid Device */) // _HID: Hardware ID
            Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
            {
              0x0A,Â
              0x03
            })
            Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
            {
              If (Arg0)
              {
                Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
                ^^PCI0.LPCB.EC0.WKEV = 0x02
                Release (^^PCI0.LPCB.EC0.MUT0)
              }
              Else
              {
                Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
                ^^PCI0.LPCB.EC0.WKEV = Zero
                Release (^^PCI0.LPCB.EC0.MUT0)
              }
            }
            Method (_LID, 0, NotSerialized) // _LID: Lid Status
            {
              If (ECON == Zero)
              {
                LIDS = One
              }
              Else
              {
                Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
                Local0 = ^^PCI0.LPCB.EC0.LIDA /* \_SB_.PCI0.LPCB.EC0_.LIDA */
                Release (^^PCI0.LPCB.EC0.MUT0)
                LIDS = (Local0 ^ One)
              }
              ^^PCI0.IGPU.CLID = LIDS /* \LIDS */
              Return (LIDS) /* \LIDS */
            }
          }
          Device (ADP1)
          {
            Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID
            Method (_PSR, 0, NotSerialized) // _PSR: Power Source
            {
              If (ECON == One)
              {
                Notify (\_PR.CPU0, 0x80) // Performance Capability Change
                Sleep (0x64)
                Notify (\_PR.CPU0, 0x81) // C-State Change
              }
              Return (PWRS) /* \PWRS */
            }
            Method (_PCL, 0, NotSerialized) // _PCL: Power Consumer List
            {
              Return (_SB) /* \_SB_ */
            }
          }
          Device (BAT0)
          {
            Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID
            Name (_UID, Zero) // _UID: Unique ID
            Name (_PCL, Package (0x01) // _PCL: Power Consumer List
            {
              PCI0
            })
            Name (BTP, Zero)
            Name (BTCH, Zero)
            Name (BSTA, Zero)
            Method (_STA, 0, NotSerialized) // _STA: Status
            {
              If (ECON == Zero)
              {
                Return (0x0F)
              }
              ElseIf (BSTA)
              {
                Return (0x1F)
              }
              Else
              {
                Return (0x0F)
              }
            }
            Mutex (ECMU, 0x00)
            Name (PAK0, Package (0x0D)
            {
              One,Â
              0xFFFFFFFF,Â
              0xFFFFFFFF,Â
              Zero,Â
              0xFFFFFFFF,Â
              Zero,Â
              Zero,Â
              0x64,Â
              Zero,Â
              "BAT0",Â
              "123456789",Â
              "LiON",Â
              "PTL"
            })
            Method (BTST, 0, NotSerialized)
            {
              Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
              BSTA = ^^PCI0.LPCB.EC0.B0IN /* \_SB_.PCI0.LPCB.EC0_.B0IN */
              Release (^^PCI0.LPCB.EC0.MUT0)
              If (BSTA == One)
              {
                If (BTP == Zero)
                {
                  BTCH = One
                  BTP = One
                }
              }
              Else
              {
                BTP = Zero
              }
            }
            Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
            {
              Name (_T_2, Zero) // _T_x: Emitted by ASL Compiler
              Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler
              Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler
              Debug = "BIF0"
              Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
              PAK0 [One] = ^^PCI0.LPCB.EC0.DCP0 /* External reference */
              Local0 = ^^PCI0.LPCB.EC0.FCP0 /* External reference */
              PAK0 [0x02] = Local0
              PAK0 [0x04] = ^^PCI0.LPCB.EC0.DVT0 /* External reference */
              Local1 = ^^PCI0.LPCB.EC0.DNN0 /* \_SB_.PCI0.LPCB.EC0_.DNN0 */
              Local2 = ^^PCI0.LPCB.EC0.BSN0 /* External reference */
              Local3 = ^^PCI0.LPCB.EC0.BCN0 /* \_SB_.PCI0.LPCB.EC0_.BCN0 */
              Local4 = ^^PCI0.LPCB.EC0.MNN0 /* \_SB_.PCI0.LPCB.EC0_.MNN0 */
              Release (^^PCI0.LPCB.EC0.MUT0)
              PAK0 [0x05] = (Local0 / 0x0A)
              PAK0 [0x06] = Zero
              _T_0 = Local1
              If (_T_0 == Zero)
              {
                PAK0 [0x09] = "Unknow"
              }
              ElseIf (_T_0 == 0xFF)
              {
                PAK0 [0x09] = "Dell"
              }
              PAK0 [0x0A] = ITOS (ToBCD (Local2))
              _T_1 = Local3
              If (_T_1 == Zero)
              {
                PAK0 [0x0B] = "Unknow"
              }
              ElseIf (_T_1 == One)
              {
                PAK0 [0x0B] = "PBAC"
              }
              ElseIf (_T_1 == 0x02)
              {
                PAK0 [0x0B] = "LION"
              }
              ElseIf (_T_1 == 0x03)
              {
                PAK0 [0x0B] = "NICD"
              }
              ElseIf (_T_1 == 0x04)
              {
                PAK0 [0x0B] = "NIMH"
              }
              ElseIf (_T_1 == 0x05)
              {
                PAK0 [0x0B] = "NIZN"
              }
              ElseIf (_T_1 == 0x06)
              {
                PAK0 [0x0B] = "RAM"
              }
              ElseIf (_T_1 == 0x07)
              {
                PAK0 [0x0B] = "ZNAR"
              }
              ElseIf (_T_1 == 0x08)
              {
                PAK0 [0x0B] = "LIP"
              }
              _T_2 = Local4
              If (_T_2 == Zero)
              {
                PAK0 [0x0C] = "Unknow"
              }
              ElseIf (_T_2 == One)
              {
                PAK0 [0x0C] = "Dell"
              }
              ElseIf (_T_2 == 0x02)
              {
                PAK0 [0x0C] = "SONY"
              }
              ElseIf (_T_2 == 0x03)
              {
                PAK0 [0x0C] = "SANYO"
              }
              ElseIf (_T_2 == 0x04)
              {
                PAK0 [0x0C] = "PANASONIC"
              }
              ElseIf (_T_2 == 0x05)
              {
                PAK0 [0x0C] = "SONY_OLD"
              }
              ElseIf (_T_2 == 0x06)
              {
                PAK0 [0x0C] = "SDI"
              }
              ElseIf (_T_2 == 0x07)
              {
                PAK0 [0x0C] = "SIMPLO"
              }
              ElseIf (_T_2 == 0x08)
              {
                PAK0 [0x0C] = "MOTOROLA"
              }
              ElseIf (_T_2 == 0x09)
              {
                PAK0 [0x0C] = "LGC"
              }
              Return (PAK0) /* \_SB_.BAT0.PAK0 */
            }
            Method (ITOS, 1, NotSerialized)
            {
              Local0 = Buffer (0x09)
                {
                  /* 0000 */ 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0....... */
                  /* 0008 */ 0x00                       /* . */
                }
              Local7 = Buffer (0x11)
                {
                  "0123456789ABCDEF"
                }
              Local1 = 0x08
              Local2 = Zero
              Local3 = Zero
              While (Local1)
              {
                Local1--
                Local4 = ((Arg0 >> (Local1 << 0x02)) & 0x0F)
                If (Local4)
                {
                  Local3 = Ones
                }
                If (Local3)
                {
                  GBFE (Local7, Local4, RefOf (Local5))
                  PBFE (Local0, Local2, Local5)
                  Local2++
                }
              }
              Return (Local0)
            }
            Method (GBFE, 3, NotSerialized)
            {
              CreateByteField (Arg0, Arg1, TIDX)
              Arg2 = TIDX /* \_SB_.BAT0.GBFE.TIDX */
            }
            Method (PBFE, 3, NotSerialized)
            {
              CreateByteField (Arg0, Arg1, TIDX)
              TIDX = Arg2
            }
            Name (BFB0, Package (0x04)
            {
              Zero,Â
              0xFFFFFFFF,Â
              0x1034,Â
              0x2A30
            })
            Method (_BST, 0, NotSerialized) // _BST: Battery Status
            {
              If (MY9F == Zero)
              {
                Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
                Local0 = ^^PCI0.LPCB.EC0.B0DC /* \_SB_.PCI0.LPCB.EC0_.B0DC */
                Local1 = ^^PCI0.LPCB.EC0.B0IC /* \_SB_.PCI0.LPCB.EC0_.B0IC */
                Local1 <<= One
                Local0 += Local1
                Local1 = ^^PCI0.LPCB.EC0.B0CL /* \_SB_.PCI0.LPCB.EC0_.B0CL */
                Release (^^PCI0.LPCB.EC0.MUT0)
                Local1 <<= 0x02
                Local0 += Local1
                BFB0 [Zero] = Local0
                Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
                BFB0 [0x02] = ^^PCI0.LPCB.EC0.CAP0 /* External reference */
                BFB0 [0x03] = ^^PCI0.LPCB.EC0.VOT0 /* External reference */
                Release (^^PCI0.LPCB.EC0.MUT0)
                Acquire (^^PCI0.LPCB.EC0.MUT0, 0xFFFF)
                Local0 = ^^PCI0.LPCB.EC0.CRT0 /* External reference */
                Release (^^PCI0.LPCB.EC0.MUT0)
                If (Local0 == Zero)
                {
                  Local0++
                }
                ElseIf (PWRS)
                {
                  If (Local0 & 0x8000)
                  {
                    Local0 = Ones
                  }
                }
                ElseIf (Local0 & 0x8000)
                {
                  Local0 = (Zero - Local0)
                  Local0 &= 0xFFFF
                }
                Else
                {
                  Local0 = Ones
                }
                BFB0 [One] = Local0
              }
              Else
              {
                BFB0 [Zero] = Zero
                BFB0 [One] = 0xFFFFFFFF
                BFB0 [0x02] = 0x1034
                BFB0 [0x03] = 0x2A30
              }
              Return (BFB0) /* \_SB_.BAT0.BFB0 */
            }
          }
        }
        OperationRegion (PKBS, SystemIO, 0x60, 0x05)
        Field (PKBS, ByteAcc, Lock, Preserve)
        {
          PKBD,  8,Â
          Offset (0x02),Â
          Offset (0x03),Â
          Offset (0x04),Â
          PKBC,  8
        }
        Device (PS2K)
        {
          Name (_HID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */) // _HID: Hardware ID
          Method (_STA, 0, NotSerialized) // _STA: Status
          {
            If ((PKBD == 0xFF) & (PKBC == 0xFF))
            {
              Return (Zero)
            }
            Return (0x0F)
          }
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IO (Decode16,
              0x0060,       // Range Minimum
              0x0060,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IO (Decode16,
              0x0064,       // Range Minimum
              0x0064,       // Range Maximum
              0x01,        // Alignment
              0x01,        // Length
              )
            IRQ (Edge, ActiveHigh, Exclusive, )
              {1}
          })
          Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
          {
            StartDependentFn (0x00, 0x00)
            {
              FixedIO (
                0x0060,       // Address
                0x01,        // Length
                )
              FixedIO (
                0x0064,       // Address
                0x01,        // Length
                )
              IRQNoFlags ()
                {1}
            }
            EndDependentFn ()
          })
        }
        Device (PS2M)
        {
          Method (_HID, 0, NotSerialized) // _HID: Hardware ID
          {
            If (BRID == One)
            {
              Return (0xC5048C11)
            }
            Else
            {
              Return (0xD9048C11)
            }
          }
          Name (_CID, EisaId ("PNP0F13") /* PS/2 Mouse */) // _CID: Compatible ID
          Method (_STA, 0, NotSerialized) // _STA: Status
          {
            If ((PKBD == 0xFF) & (PKBC == 0xFF))
            {
              Return (Zero)
            }
            Return (0x0F)
          }
          Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
          {
            IRQ (Edge, ActiveHigh, Exclusive, )
              {12}
          })
          Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
          {
            StartDependentFn (0x00, 0x00)
            {
              IRQNoFlags ()
                {12}
            }
            EndDependentFn ()
          })
        }
      }
    }
  }
  Scope (_PR)
  {
    Processor (CPU0, 0x01, 0x00000410, 0x06) {}
    Processor (CPU1, 0x02, 0x00000410, 0x06) {}
    Processor (CPU2, 0x03, 0x00000410, 0x06) {}
    Processor (CPU3, 0x04, 0x00000410, 0x06) {}
    Processor (CPU4, 0x05, 0x00000410, 0x06) {}
    Processor (CPU5, 0x06, 0x00000410, 0x06) {}
    Processor (CPU6, 0x07, 0x00000410, 0x06) {}
    Processor (CPU7, 0x08, 0x00000410, 0x06) {}
  }
  Mutex (MUTX, 0x00)
  OperationRegion (PRT0, SystemIO, 0x80, 0x04)
  Field (PRT0, DWordAcc, Lock, Preserve)
  {
    P80H,  32
  }
  Method (P8XH, 2, Serialized)
  {
    If (Arg0 == Zero)
    {
      P80D = ((P80D & 0xFFFFFF00) | Arg1)
    }
    If (Arg0 == One)
    {
      P80D = ((P80D & 0xFFFF00FF) | (Arg1 << 0x08))
    }
    If (Arg0 == 0x02)
    {
      P80D = ((P80D & 0xFF00FFFF) | (Arg1 << 0x10))
    }
    If (Arg0 == 0x03)
    {
      P80D = ((P80D & 0x00FFFFFF) | (Arg1 << 0x18))
    }
    P80H = P80D /* \P80D */
  }
  OperationRegion (SPRT, SystemIO, 0xB2, 0x02)
  Field (SPRT, ByteAcc, Lock, Preserve)
  {
    SSMP,  8,Â
    SSMD,  8
  }
  Scope (_SB)
  {
    Method (PHSR, 1, Serialized)
    {
      SSMD = Arg0
      SSMP = 0x77
      Return (Zero)
    }
  }
  Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model
  {
    GPIC = Arg0
    PICM = Arg0
  }
  Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep
  {
    P80D = Zero
    P8XH (Zero, Arg0)
    MY9F = One
    If (Arg0 == 0x03)
    {
      If (DTSE && (TCNT > One))
      {
        TRAP (TRTD, 0x1E)
      }
    }
    If ((Arg0 == 0x03) || (Arg0 == 0x04))
    {
      If (Arg0 == 0x04)
      {
        Acquire (\_SB.PCI0.LPCB.EC0.MUT0, 0xFFFF)
        \_SB.PHSR (0xB2)
        Release (\_SB.PCI0.LPCB.EC0.MUT0)
      }
      SLPO = One
    }
  }
  Method (_WAK, 1, Serialized) // _WAK: Wake
  {
    P8XH (Zero, 0xAB)
    MY9F = Zero
    If (NEXP)
    {
      If (OSCC & 0x02)
      {
        \_SB.PCI0.NHPG ()
      }
      If (OSCC & 0x04)
      {
        \_SB.PCI0.NPME ()
      }
    }
    If ((Arg0 == 0x04) && (ECON == One))
    {
      Acquire (\_SB.PCI0.LPCB.EC0.MUT0, 0xFFFF)
      \_SB.PCI0.LPCB.EC0.ACOS = OSTY /* \OSTY */
      Release (\_SB.PCI0.LPCB.EC0.MUT0)
    }
    If ((Arg0 == 0x03) || (Arg0 == 0x04))
    {
      If (DTSE && (TCNT > One))
      {
        TRAP (TRTD, 0x14)
      }
      If (OSYS == 0x07D2)
      {
        If (CFGD & One)
        {
          If (\_PR.CPU0._PPC () > Zero)
          {
            \_PR.CPU0._PPC = (\_PR.CPU0._PPC () - One)
            PNOT ()
            \_PR.CPU0._PPC = (\_PR.CPU0._PPC () + One)
            PNOT ()
          }
          Else
          {
            \_PR.CPU0._PPC = (\_PR.CPU0._PPC () + One)
            PNOT ()
            \_PR.CPU0._PPC = (\_PR.CPU0._PPC () - One)
            PNOT ()
          }
        }
      }
      If (RP1D == Zero)
      {
        Notify (\_SB.PCI0.RP01, Zero) // Bus Check
      }
      If (RP2D == Zero)
      {
        Notify (\_SB.PCI0.RP02, Zero) // Bus Check
      }
      If (RP5D == Zero)
      {
        Notify (\_SB.PCI0.RP05, Zero) // Bus Check
      }
      If (RP6D == Zero)
      {
        Notify (\_SB.PCI0.RP06, Zero) // Bus Check
      }
      If (MY9A != Zero)
      {
        MY9A = Zero
        \_PR.CPU0._PPC = Zero
        Notify (\_PR.CPU0, 0x80) // Performance Capability Change
      }
      If (BRID == Zero)
      {
        SLPO = Zero
      }
    }
    Acquire (\_SB.PCI0.LPCB.EC0.MUT0, 0xFFFF)
    PWRS = \_SB.PCI0.LPCB.EC0.ACIN
    Release (\_SB.PCI0.LPCB.EC0.MUT0)
    Notify (\_SB.ADP1, 0x80) // Status Change
    Acquire (\_SB.PCI0.LPCB.EC0.MUT0, 0xFFFF)
    \_SB.BAT0.BTST ()
    Release (\_SB.PCI0.LPCB.EC0.MUT0)
    Notify (\_SB.BAT0, 0x80) // Status Change
    Return (Package (0x02)
    {
      Zero,Â
      Zero
    })
  }
  Method (GETB, 3, Serialized)
  {
    Local0 = (Arg0 * 0x08)
    Local1 = (Arg1 * 0x08)
    CreateField (Arg2, Local0, Local1, TBF3)
    Return (TBF3) /* \GETB.TBF3 */
  }
  Method (OCNT, 0, Serialized)
  {
    If (TCNT > One)
    {
      Notify (\_PR.CPU0, 0x81) // C-State Change
      If (PDC1 & 0x10)
      {
        Notify (\_PR.CPU1, 0x81) // C-State Change
      }
      If (PDC2 & 0x10)
      {
        Notify (\_PR.CPU2, 0x81) // C-State Change
      }
      If (PDC3 & 0x10)
      {
        Notify (\_PR.CPU3, 0x81) // C-State Change
      }
      If (PDC4 & 0x10)
      {
        Notify (\_PR.CPU4, 0x81) // C-State Change
      }
      If (PDC5 & 0x10)
      {
        Notify (\_PR.CPU5, 0x81) // C-State Change
      }
      If (PDC6 & 0x10)
      {
        Notify (\_PR.CPU6, 0x81) // C-State Change
      }
      If (PDC7 & 0x10)
      {
        Notify (\_PR.CPU7, 0x81) // C-State Change
      }
    }
    Else
    {
      Notify (\_PR.CPU0, 0x81) // C-State Change
    }
  }
  Method (PNOT, 0, Serialized)
  {
    If (TCNT > One)
    {
      If (PDC0 & 0x08)
      {
        Notify (\_PR.CPU0, 0x80) // Performance Capability Change
        If (PDC0 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU0, 0x81) // C-State Change
        }
      }
      If (PDC1 & 0x08)
      {
        Notify (\_PR.CPU1, 0x80) // Performance Capability Change
        If (PDC1 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU1, 0x81) // C-State Change
        }
      }
      If (PDC2 & 0x08)
      {
        Notify (\_PR.CPU2, 0x80) // Performance Capability Change
        If (PDC2 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU2, 0x81) // C-State Change
        }
      }
      If (PDC3 & 0x08)
      {
        Notify (\_PR.CPU3, 0x80) // Performance Capability Change
        If (PDC3 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU3, 0x81) // C-State Change
        }
      }
      If (PDC4 & 0x08)
      {
        Notify (\_PR.CPU4, 0x80) // Performance Capability Change
        If (PDC4 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU4, 0x81) // C-State Change
        }
      }
      If (PDC5 & 0x08)
      {
        Notify (\_PR.CPU5, 0x80) // Performance Capability Change
        If (PDC5 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU5, 0x81) // C-State Change
        }
      }
      If (PDC6 & 0x08)
      {
        Notify (\_PR.CPU6, 0x80) // Performance Capability Change
        If (PDC6 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU6, 0x81) // C-State Change
        }
      }
      If (PDC7 & 0x08)
      {
        Notify (\_PR.CPU7, 0x80) // Performance Capability Change
        If (PDC7 & 0x10)
        {
          Sleep (0x64)
          Notify (\_PR.CPU7, 0x81) // C-State Change
        }
      }
    }
    Else
    {
      Notify (\_PR.CPU0, 0x80) // Performance Capability Change
      Sleep (0x64)
      Notify (\_PR.CPU0, 0x81) // C-State Change
    }
  }
  Method (TRAP, 2, Serialized)
  {
    SMIF = Arg1
    If (Arg0 == TRTP)
    {
      TRP0 = Zero
    }
    If (Arg0 == TRTD)
    {
      DTSF = Arg1
      TRPD = Zero
      Return (DTSF) /* \DTSF */
    }
    If (Arg0 == TRTI)
    {
      TRPH = Zero
    }
    Return (SMIF) /* \SMIF */
  }
  Scope (_SB.PCI0)
  {
    Method (_INI, 0, NotSerialized) // _INI: Initialize
    {
      OSYS = 0x07D0
      If (CondRefOf (_OSI, Local0))
      {
        If (_OSI ("Linux"))
        {
          OSYS = 0x03E8
        }
        If (_OSI ("Darwin"))
        {
          OSYS = 0x2710
        }
        If (_OSI ("Windows 2001"))
        {
          OSYS = 0x07D1
        }
        If (_OSI ("Windows 2001 SP1"))
        {
          OSYS = 0x07D1
        }
        If (_OSI ("Windows 2001 SP2"))
        {
          OSYS = 0x07D2
        }
        If (_OSI ("Windows 2001.1"))
        {
          OSYS = 0x07D3
        }
        If (_OSI ("Windows 2006"))
        {
          OSYS = 0x07D6
        }
        If (_OSI ("Windows 2009"))
        {
          OSYS = 0x07D9
        }
        If (_OSI ("Windows 2012"))
        {
          OSYS = 0x07DC
        }
        If (_OSI ("Windows 2013"))
        {
          OSYS = 0x07DD
        }
      }
      If ((OSYS == 0x07D1) || (OSYS == 0x07D2))
      {
        PHSR (0xB5)
      }
    }
    Method (NHPG, 0, Serialized)
    {
      ^RP01.HPEX = Zero
      ^RP02.HPEX = Zero
      ^RP03.HPEX = Zero
      ^RP01.HPSX = One
      ^RP02.HPSX = One
      ^RP03.HPSX = One
    }
    Method (NPME, 0, Serialized)
    {
      ^RP01.PMEX = Zero
      ^RP02.PMEX = Zero
      ^RP03.PMEX = Zero
      ^RP05.PMEX = Zero
      ^RP06.PMEX = Zero
      ^RP01.PMSX = One
      ^RP02.PMSX = One
      ^RP03.PMSX = One
      ^RP05.PMSX = One
      ^RP06.PMSX = One
    }
  }
  Scope (\)
  {
    Name (PICM, Zero)
    Name (PRWP, Package (0x02)
    {
      Zero,Â
      Zero
    })
    Method (GPRW, 2, NotSerialized)
    {
      PRWP [Zero] = Arg0
      Local0 = (SS1 << One)
      Local0 |= (SS2 << 0x02)
      Local0 |= (SS3 << 0x03)
      Local0 |= (SS4 << 0x04)
      If ((One << Arg1) & Local0)
      {
        PRWP [One] = Arg1
      }
      Else
      {
        Local0 >>= One
        FindSetRightBit (Local0, PRWP [One])
      }
      Return (PRWP) /* \PRWP */
    }
  }
  Scope (_TZ)
  {
    Name (ETMD, One)
    Name (THLD, 0x78)
    ThermalZone (TZ00)
    {
      Name (PTMP, 0x0BB8)
      Method (_CRT, 0, Serialized) // _CRT: Critical Temperature
      {
        Return ((0x0AAC + (CRTT * 0x0A)))
      }
      Method (_TMP, 0, Serialized) // _TMP: Temperature
      {
        If (!ETMD)
        {
          Return (0x0BB8)
        }
        If (DTSE == 0x03)
        {
          Return ((0x0B10 + (CRTT * 0x0A)))
        }
        If (DTSE == One)
        {
          If (PKGA == One)
          {
            Local0 = PDTS /* \PDTS */
            Return ((0x0AAC + (Local0 * 0x0A)))
          }
          Local0 = DTS1 /* \DTS1 */
          If (DTS2 > Local0)
          {
            Local0 = DTS2 /* \DTS2 */
          }
          If (DTS3 > Local0)
          {
            Local0 = DTS3 /* \DTS3 */
          }
          If (DTS4 > Local0)
          {
            Local0 = DTS4 /* \DTS4 */
          }
          Return ((0x0AAC + (Local0 * 0x0A)))
        }
        Return (0x0BC2)
      }
    }
    ThermalZone (TZ01)
    {
      Name (PTMP, 0x0BB8)
      Method (_CRT, 0, Serialized) // _CRT: Critical Temperature
      {
        Return ((0x0AAC + (CRTT * 0x0A)))
      }
      Method (_TMP, 0, Serialized) // _TMP: Temperature
      {
        If (!ETMD)
        {
          Return (0x0BCC)
        }
        If (DTSE == 0x03)
        {
          Return ((0x0B10 + (CRTT * 0x0A)))
        }
        If (DTSE == One)
        {
          If (PKGA == One)
          {
            Local0 = PDTS /* \PDTS */
            Return ((0x0AAC + (Local0 * 0x0A)))
          }
          Local0 = DTS1 /* \DTS1 */
          If (DTS2 > Local0)
          {
            Local0 = DTS2 /* \DTS2 */
          }
          If (DTS3 > Local0)
          {
            Local0 = DTS3 /* \DTS3 */
          }
          If (DTS4 > Local0)
          {
            Local0 = DTS4 /* \DTS4 */
          }
          Return ((0x0AAC + (Local0 * 0x0A)))
        }
        Return (0x0BD6)
      }
      Method (_PSL, 0, Serialized) // _PSL: Passive List
      {
        If (TCNT == 0x08)
        {
          Return (Package (0x08)
          {
            \_PR.CPU0,Â
            \_PR.CPU1,Â
            \_PR.CPU2,Â
            \_PR.CPU3,Â
            \_PR.CPU4,Â
            \_PR.CPU5,Â
            \_PR.CPU6,Â
            \_PR.CPU7
          })
        }
        If (TCNT == 0x04)
        {
          Return (Package (0x04)
          {
            \_PR.CPU0,Â
            \_PR.CPU1,Â
            \_PR.CPU2,Â
            \_PR.CPU3
          })
        }
        If (TCNT == 0x02)
        {
          Return (Package (0x02)
          {
            \_PR.CPU0,Â
            \_PR.CPU1
          })
        }
        Return (Package (0x01)
        {
          \_PR.CPU0
        })
      }
      Method (_PSV, 0, Serialized) // _PSV: Passive Temperature
      {
        Return ((0x0AAC + (PSVT * 0x0A)))
      }
      Method (_TC1, 0, Serialized) // _TC1: Thermal Constant 1
      {
        Return (TC1V) /* \TC1V */
      }
      Method (_TC2, 0, Serialized) // _TC2: Thermal Constant 2
      {
        Return (TC2V) /* \TC2V */
      }
      Method (_TSP, 0, Serialized) // _TSP: Thermal Sampling Period
      {
        Return (TSPV) /* \TSPV */
      }
    }
  }
  Scope (_SB.PCI0)
  {
    Device (PDRC)
    {
      Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID
      Name (_UID, One) // _UID: Unique ID
      Name (BUF0, ResourceTemplate ()
      {
        Memory32Fixed (ReadWrite,
          0x00000000,     // Address Base
          0x00004000,     // Address Length
          _Y0F)
        Memory32Fixed (ReadWrite,
          0x00000000,     // Address Base
          0x00008000,     // Address Length
          _Y11)
        Memory32Fixed (ReadWrite,
          0x00000000,     // Address Base
          0x00001000,     // Address Length
          _Y12)
        Memory32Fixed (ReadWrite,
          0x00000000,     // Address Base
          0x00001000,     // Address Length
          _Y13)
        Memory32Fixed (ReadWrite,
          0x00000000,     // Address Base
          0x00000000,     // Address Length
          _Y14)
        Memory32Fixed (ReadWrite,
          0xFED20000,     // Address Base
          0x00020000,     // Address Length
          )
        Memory32Fixed (ReadOnly,
          0xFED90000,     // Address Base
          0x00004000,     // Address Length
          )
        Memory32Fixed (ReadWrite,
          0xFED45000,     // Address Base
          0x0004B000,     // Address Length
          )
        Memory32Fixed (ReadOnly,
          0xFF000000,     // Address Base
          0x01000000,     // Address Length
          )
        Memory32Fixed (ReadOnly,
          0xFEE00000,     // Address Base
          0x00100000,     // Address Length
          )
        Memory32Fixed (ReadWrite,
          0x00000000,     // Address Base
          0x00001000,     // Address Length
          _Y10)
      })
      Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
      {
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y0F._BAS, RBR0) // _BAS: Base Address
        RBR0 = (^^LPCB.RCBA << 0x0E)
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y10._BAS, TBR0) // _BAS: Base Address
        TBR0 = TBAB /* \TBAB */
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y10._LEN, TBLN) // _LEN: Length
        If (TBAB == Zero)
        {
          TBLN = Zero
        }
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y11._BAS, MBR0) // _BAS: Base Address
        MBR0 = (MHBR << 0x0F)
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y12._BAS, DBR0) // _BAS: Base Address
        DBR0 = (DIBR << 0x0C)
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y13._BAS, EBR0) // _BAS: Base Address
        EBR0 = (EPBR << 0x0C)
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y14._BAS, XBR0) // _BAS: Base Address
        XBR0 = (PXBR << 0x1A)
        CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y14._LEN, XSZ0) // _LEN: Length
        XSZ0 = (0x10000000 >> PXSZ) /* \_SB_.PCI0.PXSZ */
        Return (BUF0) /* \_SB_.PCI0.PDRC.BUF0 */
      }
    }
  }
  Method (BRTN, 1, Serialized)
  {
    If ((DID1 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD01, Arg0)
    }
    If ((DID2 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD02, Arg0)
    }
    If ((DID3 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD03, Arg0)
    }
    If ((DID4 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD04, Arg0)
    }
    If ((DID5 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD05, Arg0)
    }
    If ((DID6 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD06, Arg0)
    }
    If ((DID7 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD07, Arg0)
    }
    If ((DID8 & 0x0F00) == 0x0400)
    {
      Notify (\_SB.PCI0.IGPU.DD08, Arg0)
    }
  }
  Scope (_GPE)
  {
    Method (_L0B, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      Notify (\_SB.PCI0.P0P1, 0x02) // Device Wake
      Notify (\_SB.PCI0.RP03, 0x02) // Device Wake
    }
    Method (_L09, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      If (RP1D == Zero)
      {
        \_SB.PCI0.RP01.HPME ()
        Notify (\_SB.PCI0.RP01, 0x02) // Device Wake
      }
      If (RP2D == Zero)
      {
        \_SB.PCI0.RP02.HPME ()
        Notify (\_SB.PCI0.RP02, 0x02) // Device Wake
      }
      If (RP5D == Zero)
      {
        \_SB.PCI0.RP05.HPME ()
        Notify (\_SB.PCI0.RP05, 0x02) // Device Wake
      }
      If (RP6D == Zero)
      {
        \_SB.PCI0.RP06.HPME ()
        Notify (\_SB.PCI0.RP06, 0x02) // Device Wake
      }
      Notify (\_SB.PCI0.PEG0, 0x02) // Device Wake
      Notify (\_SB.PCI0.PEG0.PEGP, 0x02) // Device Wake
    }
    Method (_L0D, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      Notify (\_SB.PCI0.EHC1, 0x02) // Device Wake
      Notify (\_SB.PCI0.EHC2, 0x02) // Device Wake
      Notify (\_SB.PCI0.HDEF, 0x02) // Device Wake
    }
    Method (_L01, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      L01C += One
      P8XH (Zero, One)
      P8XH (One, L01C)
      If ((RP1D == Zero) && \_SB.PCI0.RP01.HPSX)
      {
        P8XH (Zero, 0x11)
        Sleep (0x64)
        If (\_SB.PCI0.RP01.PDCX)
        {
          \_SB.PCI0.RP01.PDCX = One
          \_SB.PCI0.RP01.HPSX = One
          If (!\_SB.PCI0.RP01.PDSX)
          {
            \_SB.PCI0.RP01.L0SE = Zero
          }
          Notify (\_SB.PCI0.RP01, Zero) // Bus Check
        }
        Else
        {
          \_SB.PCI0.RP01.HPSX = One
        }
      }
      If ((RP2D == Zero) && \_SB.PCI0.RP02.HPSX)
      {
        P8XH (Zero, 0x12)
        Sleep (0x64)
        If (\_SB.PCI0.RP02.PDCX)
        {
          \_SB.PCI0.RP02.PDCX = One
          \_SB.PCI0.RP02.HPSX = One
          If (!\_SB.PCI0.RP02.PDSX)
          {
            \_SB.PCI0.RP02.L0SE = Zero
          }
          Notify (\_SB.PCI0.RP02, Zero) // Bus Check
        }
        Else
        {
          \_SB.PCI0.RP02.HPSX = One
        }
      }
      If ((RP3D == Zero) && \_SB.PCI0.RP03.HPSX)
      {
        P8XH (Zero, 0x14)
        Sleep (0x64)
        If (\_SB.PCI0.RP03.PDCX)
        {
          \_SB.PCI0.RP03.PDCX = One
          \_SB.PCI0.RP03.HPSX = One
          If (!\_SB.PCI0.RP03.PDSX)
          {
            \_SB.PCI0.RP03.L0SE = Zero
          }
          Notify (\_SB.PCI0.RP03, Zero) // Bus Check
        }
        Else
        {
          \_SB.PCI0.RP03.HPSX = One
        }
      }
      If ((RP5D == Zero) && \_SB.PCI0.RP05.HPSX)
      {
        P8XH (Zero, 0x15)
        Sleep (0x64)
        If (\_SB.PCI0.RP05.PDCX)
        {
          \_SB.PCI0.RP05.PDCX = One
          \_SB.PCI0.RP05.HPSX = One
          If (!\_SB.PCI0.RP05.PDSX)
          {
            \_SB.PCI0.RP05.L0SE = Zero
          }
          Notify (\_SB.PCI0.RP05, Zero) // Bus Check
        }
        Else
        {
          \_SB.PCI0.RP05.HPSX = One
        }
      }
      If ((RP6D == Zero) && \_SB.PCI0.RP06.HPSX)
      {
        P8XH (Zero, 0x16)
        Sleep (0x64)
        If (\_SB.PCI0.RP06.PDCX)
        {
          \_SB.PCI0.RP06.PDCX = One
          \_SB.PCI0.RP06.HPSX = One
          If (!\_SB.PCI0.RP06.PDSX)
          {
            \_SB.PCI0.RP06.L0SE = Zero
          }
          Notify (\_SB.PCI0.RP06, Zero) // Bus Check
        }
        Else
        {
          \_SB.PCI0.RP06.HPSX = One
        }
      }
    }
    Method (_L02, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      GPEC = Zero
    }
    Method (_L06, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      If (\_SB.PCI0.IGPU.GSSE && !GSMI)
      {
        \_SB.PCI0.IGPU.GSCI ()
      }
    }
    Method (_L07, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      \_SB.PCI0.SBUS.HSTS = 0x20
    }
  }
  Scope (\)
  {
    OperationRegion (IO_T, SystemIO, 0x1004, 0x10)
    Field (IO_T, ByteAcc, NoLock, Preserve)
    {
      TRPI,  16,Â
      Offset (0x04),Â
      Offset (0x06),Â
      Offset (0x08),Â
      TRP0,  8,Â
      Offset (0x0A),Â
      Offset (0x0B),Â
      Offset (0x0C),Â
      Offset (0x0D),Â
      Offset (0x0E),Â
      Offset (0x0F),Â
      Offset (0x10)
    }
    OperationRegion (IO_D, SystemIO, 0x1000, 0x04)
    Field (IO_D, ByteAcc, NoLock, Preserve)
    {
      TRPD,  8
    }
    OperationRegion (IO_H, SystemIO, 0x1000, 0x04)
    Field (IO_H, ByteAcc, NoLock, Preserve)
    {
      TRPH,  8
    }
    OperationRegion (PMIO, SystemIO, PMBS, 0x80)
    Field (PMIO, ByteAcc, NoLock, Preserve)
    {
      Offset (0x20),Â
      Offset (0x22),Â
        ,  3,Â
      GPS3,  1,Â
      Offset (0x28),Â
      Offset (0x2A),Â
        ,  3,Â
      GPE3,  1,Â
      Offset (0x3C),Â
        ,  1,Â
      UPRW,  1,Â
      Offset (0x42),Â
        ,  1,Â
      GPEC,  1,Â
      Offset (0x64),Â
        ,  9,Â
      SCIS,  1,Â
      Offset (0x66)
    }
    OperationRegion (GPIO, SystemIO, GPBS, 0x64)
    Field (GPIO, ByteAcc, NoLock, Preserve)
    {
      GU00,  8,Â
      GU01,  8,Â
      GU02,  8,Â
      GU03,  8,Â
      GIO0,  8,Â
      GIO1,  8,Â
      GIO2,  8,Â
      GIO3,  8,Â
      Offset (0x0C),Â
      GL00,  8,Â
      GL01,  8,Â
      GL02,  8,Â
        ,  3,Â
      GP27,  1,Â
      GP28,  1,Â
      Offset (0x10),Â
      Offset (0x18),Â
      GB00,  8,Â
      GB01,  8,Â
      GB02,  8,Â
      GB03,  8,Â
      Offset (0x2C),Â
      GIV0,  8,Â
      GIV1,  8,Â
      GIV2,  8,Â
      GIV3,  8,Â
      GU04,  8,Â
      GU05,  8,Â
      GU06,  8,Â
      GU07,  8,Â
      GIO4,  8,Â
      GIO5,  8,Â
      GIO6,  8,Â
      GIO7,  8,Â
      GL04,  8,Â
      GL05,  8,Â
      GL06,  8,Â
      GL07,  8,Â
      Offset (0x40),Â
      GU08,  8,Â
      GU09,  8,Â
      GU0A,  8,Â
      GU0B,  8,Â
      GIO8,  8,Â
      GIO9,  8,Â
      GIOA,  8,Â
      GIOB,  8,Â
      GL08,  8,Â
      GL09,  8,Â
      GL0A,  8,Â
      GL0B,  8
    }
    OperationRegion (RCRB, SystemMemory, SRCB, 0x4000)
    Field (RCRB, DWordAcc, Lock, Preserve)
    {
      Offset (0x1000),Â
      Offset (0x3000),Â
      Offset (0x3404),Â
      HPAS,  2,Â
        ,  5,Â
      HPAE,  1,Â
      Offset (0x3418),Â
        ,  1,Â
        ,  1,Â
      SATD,  1,Â
      SMBD,  1,Â
      HDAD,  1,Â
      Offset (0x341A),Â
      RP1D,  1,Â
      RP2D,  1,Â
      RP3D,  1,Â
      RP4D,  1,Â
      RP5D,  1,Â
      RP6D,  1,Â
      RP7D,  1,Â
      RP8D,  1,Â
      Offset (0x359C),Â
      UP0D,  1,Â
      UP1D,  1,Â
      UP2D,  1,Â
      UP3D,  1,Â
      UP4D,  1,Â
      UP5D,  1,Â
      UP6D,  1,Â
      UP7D,  1,Â
      UP8D,  1,Â
      UP9D,  1,Â
      UPAD,  1,Â
      UPBD,  1,Â
      UPCD,  1,Â
      UPDD,  1,Â
        ,  1,Â
      Offset (0x359E)
    }
  }
  Scope (_SB.PCI0)
  {
    Device (EHC1)
    {
      Name (_ADR, 0x001D0000) // _ADR: Address
      OperationRegion (U1CS, PCI_Config, 0x62, 0x04)
      Field (U1CS, DWordAcc, NoLock, Preserve)
      {
          ,  1,Â
        E1EN,  8
      }
      Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
      {
        If (Arg0)
        {
          E1EN = Ones
        }
        Else
        {
          E1EN = Zero
        }
      }
      Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State
      {
        Return (0x02)
      }
      Method (_S4D, 0, NotSerialized) // _S4D: S4 Device State
      {
        Return (0x02)
      }
      Device (HUBN)
      {
        Name (_ADR, Zero) // _ADR: Address
        Device (PRT1)
        {
          Name (_ADR, One) // _ADR: Address
          Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
          {
            Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler
            Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler
            If (Arg0 == ToUUID ("a5fc708f-8775-4ba6-bd0c-ba90a1ec72f8"))
            {
              _T_0 = ToInteger (Arg2)
              If (_T_0 == Zero)
              {
                _T_1 = ToInteger (Arg1)
                If (_T_1 == One)
                {
                  Return (Buffer (One)
                  {
                     0x07                       /* . */
                  })
                }
                Else
                {
                  Return (Buffer (One)
                  {
                     0x00                       /* . */
                  })
                }
              }
              ElseIf (_T_0 == One)
              {
                Return (One)
              }
              ElseIf (_T_0 == 0x02)
              {
                Return (SBV1) /* \SBV1 */
              }
              Else
              {
                Return (Zero)
              }
            }
            Else
            {
              Return (Zero)
            }
          }
        }
        Device (PRT2)
        {
          Name (_ADR, 0x02) // _ADR: Address
          Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
          {
            Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler
            Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler
            If (Arg0 == ToUUID ("a5fc708f-8775-4ba6-bd0c-ba90a1ec72f8"))
            {
              _T_0 = ToInteger (Arg2)
              If (_T_0 == Zero)
              {
                _T_1 = ToInteger (Arg1)
                If (_T_1 == One)
                {
                  Return (Buffer (One)
                  {
                     0x07                       /* . */
                  })
                }
                Else
                {
                  Return (Buffer (One)
                  {
                     0x00                       /* . */
                  })
                }
              }
              ElseIf (_T_0 == One)
              {
                Return (One)
              }
              ElseIf (_T_0 == 0x02)
              {
                Return (SBV1) /* \SBV1 */
              }
              Else
              {
                Return (Zero)
              }
            }
            Else
            {
              Return (Zero)
            }
          }
        }
      }
      Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
      {
        If (USBK == One)
        {
          Return (Package (0x02)
          {
            0x0D,Â
            0x03
          })
        }
        Else
        {
          Return (Package (0x02)
          {
            0x0D,Â
            Zero
          })
        }
      }
      Device (RHUB)
      {
        Name (_ADR, Zero) // _ADR: Address
        Device (PRT1)
        {
          Name (_ADR, One) // _ADR: Address
          Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
          {
            Zero,Â
            0xFF,Â
            Zero,Â
            Zero
          })
          Device (PR15)
          {
            Name (_ADR, 0x05) // _ADR: Address
            Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
            {
              0xFF,Â
              0xFF,Â
              Zero,Â
              Zero
            })
            Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
            {
              ToPLD (
                PLD_Revision      = 0x1,
                PLD_IgnoreColor    = 0x1,
                PLD_Red        = 0x0,
                PLD_Green       = 0x0,
                PLD_Blue        = 0x0,
                PLD_Width       = 0x0,
                PLD_Height       = 0x0,
                PLD_UserVisible    = 0x0,
                PLD_Dock        = 0x0,
                PLD_Lid        = 0x0,
                PLD_Panel       = "UNKNOWN",
                PLD_VerticalPosition  = "UPPER",
                PLD_HorizontalPosition = "LEFT",
                PLD_Shape       = "UNKNOWN",
                PLD_GroupOrientation  = 0x0,
                PLD_GroupToken     = 0x0,
                PLD_GroupPosition   = 0x0,
                PLD_Bay        = 0x0,
                PLD_Ejectable     = 0x0,
                PLD_EjectRequired   = 0x0,
                PLD_CabinetNumber   = 0x0,
                PLD_CardCageNumber   = 0x0,
                PLD_Reference     = 0x0,
                PLD_Rotation      = 0x0,
                PLD_Order       = 0x0)
            })
          }
          Device (PR16)
          {
            Name (_ADR, 0x06) // _ADR: Address
            Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
            {
              0xFF,Â
              0xFF,Â
              Zero,Â
              Zero
            })
            Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
            {
              ToPLD (
                PLD_Revision      = 0x1,
                PLD_IgnoreColor    = 0x1,
                PLD_Red        = 0x0,
                PLD_Green       = 0x0,
                PLD_Blue        = 0x0,
                PLD_Width       = 0x0,
                PLD_Height       = 0x0,
                PLD_UserVisible    = 0x0,
                PLD_Dock        = 0x0,
                PLD_Lid        = 0x0,
                PLD_Panel       = "UNKNOWN",
                PLD_VerticalPosition  = "UPPER",
                PLD_HorizontalPosition = "LEFT",
                PLD_Shape       = "UNKNOWN",
                PLD_GroupOrientation  = 0x0,
                PLD_GroupToken     = 0x0,
                PLD_GroupPosition   = 0x0,
                PLD_Bay        = 0x0,
                PLD_Ejectable     = 0x0,
                PLD_EjectRequired   = 0x0,
                PLD_CabinetNumber   = 0x0,
                PLD_CardCageNumber   = 0x0,
                PLD_Reference     = 0x0,
                PLD_Rotation      = 0x0,
                PLD_Order       = 0x0)
            })
          }
        }
        Device (PRT2)
        {
          Name (_ADR, 0x02) // _ADR: Address
          Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
          {
            Zero,Â
            0xFF,Â
            Zero,Â
            Zero
          })
        }
      }
    }
    Device (EHC2)
    {
      Name (_ADR, 0x001A0000) // _ADR: Address
      OperationRegion (U1CS, PCI_Config, 0x62, 0x04)
      Field (U1CS, DWordAcc, NoLock, Preserve)
      {
          ,  1,Â
        E2EN,  6
      }
      Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
      {
        If (Arg0)
        {
          E2EN = Ones
        }
        Else
        {
          E2EN = Zero
        }
      }
      Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State
      {
        Return (0x02)
      }
      Method (_S4D, 0, NotSerialized) // _S4D: S4 Device State
      {
        Return (0x02)
      }
      Device (HUBN)
      {
        Name (_ADR, Zero) // _ADR: Address
        Device (PRT1)
        {
          Name (_ADR, One) // _ADR: Address
          Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
          {
            Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler
            Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler
            If (Arg0 == ToUUID ("a5fc708f-8775-4ba6-bd0c-ba90a1ec72f8"))
            {
              _T_0 = ToInteger (Arg2)
              If (_T_0 == Zero)
              {
                _T_1 = ToInteger (Arg1)
                If (_T_1 == One)
                {
                  Return (Buffer (One)
                  {
                     0x07                       /* . */
                  })
                }
                Else
                {
                  Return (Buffer (One)
                  {
                     0x00                       /* . */
                  })
                }
              }
              ElseIf (_T_0 == One)
              {
                Return (One)
              }
              ElseIf (_T_0 == 0x02)
              {
                Return (SBV1) /* \SBV1 */
              }
              Else
              {
                Return (Zero)
              }
            }
            Else
            {
              Return (Zero)
            }
          }
        }
        Device (PRT2)
        {
          Name (_ADR, 0x02) // _ADR: Address
          Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
          {
            Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler
            Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler
            If (Arg0 == ToUUID ("a5fc708f-8775-4ba6-bd0c-ba90a1ec72f8"))
            {
              _T_0 = ToInteger (Arg2)
              If (_T_0 == Zero)
              {
                _T_1 = ToInteger (Arg1)
                If (_T_1 == One)
                {
                  Return (Buffer (One)
                  {
                     0x07                       /* . */
                  })
                }
                Else
                {
                  Return (Buffer (One)
                  {
                     0x00                       /* . */
                  })
                }
              }
              ElseIf (_T_0 == One)
              {
                Return (One)
              }
              ElseIf (_T_0 == 0x02)
              {
                Return (SBV1) /* \SBV1 */
              }
              Else
              {
                Return (Zero)
              }
            }
            Else
            {
              Return (Zero)
            }
          }
        }
      }
      Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
      {
        If (USBK == One)
        {
          Return (Package (0x02)
          {
            0x0D,Â
            0x03
          })
        }
        Else
        {
          Return (Package (0x02)
          {
            0x0D,Â
            Zero
          })
        }
      }
      Device (RHUB)
      {
        Name (_ADR, Zero) // _ADR: Address
        Device (PRT1)
        {
          Name (_ADR, One) // _ADR: Address
          Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
          {
            Zero,Â
            0xFF,Â
            Zero,Â
            Zero
          })
          Device (PR11)
          {
            Name (_ADR, One) // _ADR: Address
            Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
            {
              Zero,Â
              0xFF,Â
              Zero,Â
              Zero
            })
            Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
            {
              ToPLD (
                PLD_Revision      = 0x1,
                PLD_IgnoreColor    = 0x1,
                PLD_Red        = 0x0,
                PLD_Green       = 0x0,
                PLD_Blue        = 0x0,
                PLD_Width       = 0x0,
                PLD_Height       = 0x0,
                PLD_UserVisible    = 0x0,
                PLD_Dock        = 0x0,
                PLD_Lid        = 0x0,
                PLD_Panel       = "UNKNOWN",
                PLD_VerticalPosition  = "UPPER",
                PLD_HorizontalPosition = "LEFT",
                PLD_Shape       = "UNKNOWN",
                PLD_GroupOrientation  = 0x0,
                PLD_GroupToken     = 0x0,
                PLD_GroupPosition   = 0x0,
                PLD_Bay        = 0x0,
                PLD_Ejectable     = 0x0,
                PLD_EjectRequired   = 0x0,
                PLD_CabinetNumber   = 0x0,
                PLD_CardCageNumber   = 0x0,
                PLD_Reference     = 0x0,
                PLD_Rotation      = 0x0,
                PLD_Order       = 0x0)
            })
          }
          Device (PR12)
          {
            Name (_ADR, 0x02) // _ADR: Address
            Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
            {
              Zero,Â
              0xFF,Â
              Zero,Â
              Zero
            })
            Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
            {
              ToPLD (
                PLD_Revision      = 0x1,
                PLD_IgnoreColor    = 0x1,
                PLD_Red        = 0x0,
                PLD_Green       = 0x0,
                PLD_Blue        = 0x0,
                PLD_Width       = 0x0,
                PLD_Height       = 0x0,
                PLD_UserVisible    = 0x0,
                PLD_Dock        = 0x0,
                PLD_Lid        = 0x0,
                PLD_Panel       = "UNKNOWN",
                PLD_VerticalPosition  = "UPPER",
                PLD_HorizontalPosition = "LEFT",
                PLD_Shape       = "UNKNOWN",
                PLD_GroupOrientation  = 0x0,
                PLD_GroupToken     = 0x0,
                PLD_GroupPosition   = 0x0,
                PLD_Bay        = 0x0,
                PLD_Ejectable     = 0x0,
                PLD_EjectRequired   = 0x0,
                PLD_CabinetNumber   = 0x0,
                PLD_CardCageNumber   = 0x0,
                PLD_Reference     = 0x0,
                PLD_Rotation      = 0x0,
                PLD_Order       = 0x0)
            })
          }
          Device (PR13)
          {
            Name (_ADR, 0x03) // _ADR: Address
            Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
            {
              Zero,Â
              0xFF,Â
              Zero,Â
              Zero
            })
            Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
            {
              ToPLD (
                PLD_Revision      = 0x1,
                PLD_IgnoreColor    = 0x1,
                PLD_Red        = 0x0,
                PLD_Green       = 0x0,
                PLD_Blue        = 0x0,
                PLD_Width       = 0x0,
                PLD_Height       = 0x0,
                PLD_UserVisible    = 0x0,
                PLD_Dock        = 0x0,
                PLD_Lid        = 0x0,
                PLD_Panel       = "UNKNOWN",
                PLD_VerticalPosition  = "UPPER",
                PLD_HorizontalPosition = "LEFT",
                PLD_Shape       = "UNKNOWN",
                PLD_GroupOrientation  = 0x0,
                PLD_GroupToken     = 0x0,
                PLD_GroupPosition   = 0x0,
                PLD_Bay        = 0x0,
                PLD_Ejectable     = 0x0,
                PLD_EjectRequired   = 0x0,
                PLD_CabinetNumber   = 0x0,
                PLD_CardCageNumber   = 0x0,
                PLD_Reference     = 0x0,
                PLD_Rotation      = 0x0,
                PLD_Order       = 0x0)
            })
          }
          Device (PR14)
          {
            Name (_ADR, 0x04) // _ADR: Address
            Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
            {
              Zero,Â
              0xFF,Â
              Zero,Â
              Zero
            })
            Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
            {
              ToPLD (
                PLD_Revision      = 0x1,
                PLD_IgnoreColor    = 0x1,
                PLD_Red        = 0x0,
                PLD_Green       = 0x0,
                PLD_Blue        = 0x0,
                PLD_Width       = 0x0,
                PLD_Height       = 0x0,
                PLD_UserVisible    = 0x0,
                PLD_Dock        = 0x0,
                PLD_Lid        = 0x0,
                PLD_Panel       = "UNKNOWN",
                PLD_VerticalPosition  = "UPPER",
                PLD_HorizontalPosition = "LEFT",
                PLD_Shape       = "UNKNOWN",
                PLD_GroupOrientation  = 0x0,
                PLD_GroupToken     = 0x0,
                PLD_GroupPosition   = 0x0,
                PLD_Bay        = 0x0,
                PLD_Ejectable     = 0x0,
                PLD_EjectRequired   = 0x0,
                PLD_CabinetNumber   = 0x0,
                PLD_CardCageNumber   = 0x0,
                PLD_Reference     = 0x0,
                PLD_Rotation      = 0x0,
                PLD_Order       = 0x0)
            })
          }
        }
        Device (PRT2)
        {
          Name (_ADR, 0x02) // _ADR: Address
          Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
          {
            Zero,Â
            0xFF,Â
            Zero,Â
            Zero
          })
        }
      }
    }
    Device (HDEF)
    {
      Name (_ADR, 0x001B0000) // _ADR: Address
      OperationRegion (HDAR, PCI_Config, 0x4C, 0x10)
      Field (HDAR, WordAcc, NoLock, Preserve)
      {
        DCKA,  1,Â
        Offset (0x01),Â
        DCKM,  1,Â
          ,  6,Â
        DCKS,  1,Â
        Offset (0x08),Â
          ,  15,Â
        PMES,  1
      }
    }
    Device (RP01)
    {
      Name (_ADR, 0x001C0000) // _ADR: Address
      OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
      Field (PXCS, AnyAcc, NoLock, Preserve)
      {
        Offset (0x10),Â
        L0SE,  1,Â
          ,  3,Â
        LDRP,  1,Â
        Offset (0x11),Â
        Offset (0x12),Â
          ,  13,Â
        LASX,  1,Â
        Offset (0x1A),Â
        ABPX,  1,Â
          ,  2,Â
        PDCX,  1,Â
          ,  2,Â
        PDSX,  1,Â
        Offset (0x1B),Â
        LSCX,  1,Â
        Offset (0x20),Â
        Offset (0x22),Â
        PSPX,  1,Â
        Offset (0x98),Â
          ,  30,Â
        HPEX,  1,Â
        PMEX,  1,Â
          ,  30,Â
        HPSX,  1,Â
        PMSX,  1
      }
      Device (PXSX)
      {
        Name (_ADR, Zero) // _ADR: Address
        Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
        {
          0x09,Â
          0x04
        })
      }
      Method (HPME, 0, Serialized)
      {
        If (PMSX)
        {
          Local0 = 0xC8
          While (Local0)
          {
            PMSX = One
            If (PMSX)
            {
              Local0--
            }
            Else
            {
              Local0 = Zero
            }
          }
          Notify (PXSX, 0x02) // Device Wake
        }
      }
      Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
      {
        Return (GPRW (0x09, 0x04))
      }
      Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
      {
        If (PICM)
        {
          Return (AR04 ())
        }
        Return (PR04 ())
      }
    }
    Device (RP02)
    {
      Name (_ADR, 0x001C0001) // _ADR: Address
      OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
      Field (PXCS, AnyAcc, NoLock, Preserve)
      {
        Offset (0x10),Â
        L0SE,  1,Â
          ,  3,Â
        LDRP,  1,Â
        Offset (0x11),Â
        Offset (0x12),Â
          ,  13,Â
        LASX,  1,Â
        Offset (0x1A),Â
        ABPX,  1,Â
          ,  2,Â
        PDCX,  1,Â
          ,  2,Â
        PDSX,  1,Â
        Offset (0x1B),Â
        LSCX,  1,Â
        Offset (0x20),Â
        Offset (0x22),Â
        PSPX,  1,Â
        Offset (0x98),Â
          ,  30,Â
        HPEX,  1,Â
        PMEX,  1,Â
          ,  30,Â
        HPSX,  1,Â
        PMSX,  1
      }
      Device (PXSX)
      {
        Name (_ADR, Zero) // _ADR: Address
        Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
        {
          0x09,Â
          0x04
        })
      }
      Method (HPME, 0, Serialized)
      {
        If (PMSX)
        {
          Local0 = 0xC8
          While (Local0)
          {
            PMSX = One
            If (PMSX)
            {
              Local0--
            }
            Else
            {
              Local0 = Zero
            }
          }
          Notify (PXSX, 0x02) // Device Wake
        }
      }
      Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
      {
        Return (GPRW (0x09, 0x04))
      }
      Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
      {
        If (PICM)
        {
          Return (AR05 ())
        }
        Return (PR05 ())
      }
    }
    Device (RP03)
    {
      Name (_ADR, 0x001C0002) // _ADR: Address
      OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
      Field (PXCS, AnyAcc, NoLock, Preserve)
      {
        Offset (0x10),Â
        L0SE,  1,Â
          ,  3,Â
        LDRP,  1,Â
        Offset (0x11),Â
        Offset (0x12),Â
          ,  13,Â
        LASX,  1,Â
        Offset (0x1A),Â
        ABPX,  1,Â
          ,  2,Â
        PDCX,  1,Â
          ,  2,Â
        PDSX,  1,Â
        Offset (0x1B),Â
        LSCX,  1,Â
        Offset (0x20),Â
        Offset (0x22),Â
        PSPX,  1,Â
        Offset (0x98),Â
          ,  30,Â
        HPEX,  1,Â
        PMEX,  1,Â
          ,  30,Â
        HPSX,  1,Â
        PMSX,  1
      }
      Device (PXSX)
      {
        Name (_ADR, Zero) // _ADR: Address
        Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
        {
          0x09,Â
          0x04
        })
      }
      Method (HPME, 0, Serialized)
      {
        If (PMSX)
        {
          Local0 = 0xC8
          While (Local0)
          {
            PMSX = One
            If (PMSX)
            {
              Local0--
            }
            Else
            {
              Local0 = Zero
            }
          }
          Notify (PXSX, 0x02) // Device Wake
        }
      }
      Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
      {
        If (USBK == One)
        {
          Return (GPRW (0x0B, 0x03))
        }
        Else
        {
          Return (GPRW (0x0B, Zero))
        }
      }
      Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
      {
        If (PICM)
        {
          Return (AR06 ())
        }
        Return (PR06 ())
      }
    }
    Device (RP05)
    {
      Name (_ADR, 0x001C0004) // _ADR: Address
      OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
      Field (PXCS, AnyAcc, NoLock, Preserve)
      {
        Offset (0x10),Â
        L0SE,  1,Â
          ,  3,Â
        LDRP,  1,Â
        Offset (0x11),Â
        Offset (0x12),Â
          ,  13,Â
        LASX,  1,Â
        Offset (0x1A),Â
        ABPX,  1,Â
          ,  2,Â
        PDCX,  1,Â
          ,  2,Â
        PDSX,  1,Â
        Offset (0x1B),Â
        LSCX,  1,Â
        Offset (0x20),Â
        Offset (0x22),Â
        PSPX,  1,Â
        Offset (0x98),Â
          ,  30,Â
        HPEX,  1,Â
        PMEX,  1,Â
          ,  30,Â
        HPSX,  1,Â
        PMSX,  1
      }
      Device (PXSX)
      {
        Name (_ADR, Zero) // _ADR: Address
        Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
        {
          0x09,Â
          0x04
        })
      }
      Method (HPME, 0, Serialized)
      {
        If (PMSX)
        {
          Local0 = 0xC8
          While (Local0)
          {
            PMSX = One
            If (PMSX)
            {
              Local0--
            }
            Else
            {
              Local0 = Zero
            }
          }
          Notify (PXSX, 0x02) // Device Wake
        }
      }
      Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
      {
        Return (GPRW (0x09, 0x04))
      }
      Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
      {
        If (PICM)
        {
          Return (AR08 ())
        }
        Return (PR08 ())
      }
    }
    Device (RP06)
    {
      Name (_ADR, 0x001C0005) // _ADR: Address
      OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
      Field (PXCS, AnyAcc, NoLock, Preserve)
      {
        Offset (0x10),Â
        L0SE,  1,Â
          ,  3,Â
        LDRP,  1,Â
        Offset (0x11),Â
        Offset (0x12),Â
          ,  13,Â
        LASX,  1,Â
        Offset (0x1A),Â
        ABPX,  1,Â
          ,  2,Â
        PDCX,  1,Â
          ,  2,Â
        PDSX,  1,Â
        Offset (0x1B),Â
        LSCX,  1,Â
        Offset (0x20),Â
        Offset (0x22),Â
        PSPX,  1,Â
        Offset (0x98),Â
          ,  30,Â
        HPEX,  1,Â
        PMEX,  1,Â
          ,  30,Â
        HPSX,  1,Â
        PMSX,  1
      }
      Device (PXSX)
      {
        Name (_ADR, Zero) // _ADR: Address
        Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
        {
          0x09,Â
          0x04
        })
      }
      Method (HPME, 0, Serialized)
      {
        If (PMSX)
        {
          Local0 = 0xC8
          While (Local0)
          {
            PMSX = One
            If (PMSX)
            {
              Local0--
            }
            Else
            {
              Local0 = Zero
            }
          }
          Notify (PXSX, 0x02) // Device Wake
        }
      }
      Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
      {
        Return (GPRW (0x09, 0x04))
      }
      Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
      {
        If (PICM)
        {
          Return (AR09 ())
        }
        Return (PR09 ())
      }
    }
    Device (SATA)
    {
      Name (_ADR, 0x001F0002) // _ADR: Address
    }
    Device (SSAT)
    {
      Name (_ADR, 0x001F0005) // _ADR: Address
    }
    Device (SBUS)
    {
      Name (_ADR, 0x001F0003) // _ADR: Address
      OperationRegion (SMBP, PCI_Config, 0x40, 0xC0)
      Field (SMBP, DWordAcc, NoLock, Preserve)
      {
          ,  2,Â
        I2CE,  1
      }
      OperationRegion (SMPB, PCI_Config, 0x20, 0x04)
      Field (SMPB, DWordAcc, NoLock, Preserve)
      {
          ,  5,Â
        SBAR,  11
      }
      OperationRegion (SMBI, SystemIO, (SBAR << 0x05), 0x10)
      Field (SMBI, ByteAcc, NoLock, Preserve)
      {
        HSTS,  8,Â
        Offset (0x02),Â
        HCON,  8,Â
        HCOM,  8,Â
        TXSA,  8,Â
        DAT0,  8,Â
        DAT1,  8,Â
        HBDR,  8,Â
        PECR,  8,Â
        RXSA,  8,Â
        SDAT,  16
      }
      Method (SSXB, 2, Serialized)
      {
        If (STRT ())
        {
          Return (Zero)
        }
        I2CE = Zero
        HSTS = 0xBF
        TXSA = Arg0
        HCOM = Arg1
        HCON = 0x48
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (One)
        }
        Return (Zero)
      }
      Method (SRXB, 1, Serialized)
      {
        If (STRT ())
        {
          Return (0xFFFF)
        }
        I2CE = Zero
        HSTS = 0xBF
        TXSA = (Arg0 | One)
        HCON = 0x44
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (DAT0) /* \_SB_.PCI0.SBUS.DAT0 */
        }
        Return (0xFFFF)
      }
      Method (SWRB, 3, Serialized)
      {
        If (STRT ())
        {
          Return (Zero)
        }
        I2CE = Zero
        HSTS = 0xBF
        TXSA = Arg0
        HCOM = Arg1
        DAT0 = Arg2
        HCON = 0x48
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (One)
        }
        Return (Zero)
      }
      Method (SRDB, 2, Serialized)
      {
        If (STRT ())
        {
          Return (0xFFFF)
        }
        I2CE = Zero
        HSTS = 0xBF
        TXSA = (Arg0 | One)
        HCOM = Arg1
        HCON = 0x48
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (DAT0) /* \_SB_.PCI0.SBUS.DAT0 */
        }
        Return (0xFFFF)
      }
      Method (SWRW, 3, Serialized)
      {
        If (STRT ())
        {
          Return (Zero)
        }
        I2CE = Zero
        HSTS = 0xBF
        TXSA = Arg0
        HCOM = Arg1
        DAT1 = (Arg2 & 0xFF)
        DAT0 = ((Arg2 >> 0x08) & 0xFF)
        HCON = 0x4C
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (One)
        }
        Return (Zero)
      }
      Method (SRDW, 2, Serialized)
      {
        If (STRT ())
        {
          Return (0xFFFF)
        }
        I2CE = Zero
        HSTS = 0xBF
        TXSA = (Arg0 | One)
        HCOM = Arg1
        HCON = 0x4C
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (((DAT0 << 0x08) | DAT1))
        }
        Return (0xFFFFFFFF)
      }
      Method (SBLW, 4, Serialized)
      {
        If (STRT ())
        {
          Return (Zero)
        }
        I2CE = Arg3
        HSTS = 0xBF
        TXSA = Arg0
        HCOM = Arg1
        DAT0 = SizeOf (Arg2)
        Local1 = Zero
        HBDR = DerefOf (Arg2 [Zero])
        HCON = 0x54
        While (SizeOf (Arg2) > Local1)
        {
          Local0 = 0x0FA0
          While (!(HSTS & 0x80) && Local0)
          {
            Local0--
            Stall (0x32)
          }
          If (!Local0)
          {
            KILL ()
            Return (Zero)
          }
          HSTS = 0x80
          Local1++
          If (SizeOf (Arg2) > Local1)
          {
            HBDR = DerefOf (Arg2 [Local1])
          }
        }
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (One)
        }
        Return (Zero)
      }
      Method (SBLR, 3, Serialized)
      {
        Name (TBUF, Buffer (0x0100) {})
        If (STRT ())
        {
          Return (Zero)
        }
        I2CE = Arg2
        HSTS = 0xBF
        TXSA = (Arg0 | One)
        HCOM = Arg1
        HCON = 0x54
        Local0 = 0x0FA0
        While (!(HSTS & 0x80) && Local0)
        {
          Local0--
          Stall (0x32)
        }
        If (!Local0)
        {
          KILL ()
          Return (Zero)
        }
        TBUF [Zero] = DAT0 /* \_SB_.PCI0.SBUS.DAT0 */
        HSTS = 0x80
        Local1 = One
        While (Local1 < DerefOf (TBUF [Zero]))
        {
          Local0 = 0x0FA0
          While (!(HSTS & 0x80) && Local0)
          {
            Local0--
            Stall (0x32)
          }
          If (!Local0)
          {
            KILL ()
            Return (Zero)
          }
          TBUF [Local1] = HBDR /* \_SB_.PCI0.SBUS.HBDR */
          HSTS = 0x80
          Local1++
        }
        If (COMP ())
        {
          HSTS |= 0xFF
          Return (TBUF) /* \_SB_.PCI0.SBUS.SBLR.TBUF */
        }
        Return (Zero)
      }
      Method (STRT, 0, Serialized)
      {
        Local0 = 0xC8
        While (Local0)
        {
          If (HSTS & 0x40)
          {
            Local0--
            Sleep (One)
            If (Local0 == Zero)
            {
              Return (One)
            }
          }
          Else
          {
            Local0 = Zero
          }
        }
        Local0 = 0x0FA0
        While (Local0)
        {
          If (HSTS & One)
          {
            Local0--
            Stall (0x32)
            If (Local0 == Zero)
            {
              KILL ()
            }
          }
          Else
          {
            Return (Zero)
          }
        }
        Return (One)
      }
      Method (COMP, 0, Serialized)
      {
        Local0 = 0x0FA0
        While (Local0)
        {
          If (HSTS & 0x02)
          {
            Return (One)
          }
          Else
          {
            Local0--
            Stall (0x32)
            If (Local0 == Zero)
            {
              KILL ()
            }
          }
        }
        Return (Zero)
      }
      Method (KILL, 0, Serialized)
      {
        HCON |= 0x02
        HSTS |= 0xFF
      }
    }
  }
  Scope (_SB.PCI0.SATA)
  {
    Device (PRT1)
    {
      Name (_ADR, 0x0001FFFF) // _ADR: Address
      Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method
      {
        Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler
        Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler
        If (Arg0 == ToUUID ("bdfaef30-aebb-11de-8a39-0800200c9a66"))
        {
          _T_0 = ToInteger (Arg2)
          If (_T_0 == Zero)
          {
            _T_1 = ToInteger (Arg1)
            If (_T_1 == One)
            {
              If (PFLV == FDTP)
              {
                Return (Buffer (One)
                {
                   0x00                       /* . */
                })
              }
              Return (Buffer (One)
              {
                 0x0F                       /* . */
              })
            }
            Else
            {
              Return (Buffer (One)
              {
                 0x00                       /* . */
              })
            }
          }
          ElseIf (_T_0 == One)
          {
            Return (One)
          }
          ElseIf (_T_0 == 0x02)
          {
            GPE3 = Zero
            GIO0 &= 0xF7
            GL00 |= 0x08
            GIV0 |= 0x08
            GL06 &= 0xFD
            Sleep (0xC8)
            GPS3 = One
            GPE3 = One
            GIO0 |= 0x08
            Return (One)
          }
          ElseIf (_T_0 == 0x03)
          {
            GPE3 = Zero
            GPS3 = One
            GL06 |= 0x02
            Return (One)
          }
          Else
          {
            Return (Zero)
          }
        }
        Else
        {
          Return (Zero)
        }
      }
    }
  }
  Scope (_GPE)
  {
    Method (_L13, 0, NotSerialized) // _Lxx: Level-Triggered GPE
    {
      If (PFLV == FDTP)
      {
        Return (Zero)
      }
      GPE3 = Zero
      GL06 |= 0x02
      Sleep (0x0320)
      Notify (\_SB.PCI0.SATA, 0x81) // Information Change
      Return (Zero)
    }
  }
  Scope (_SB.PCI0)
  {
    Device (PEG0)
    {
      Name (_ADR, 0x00010000) // _ADR: Address
      Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
      {
        0x09,Â
        0x04
      })
      Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
      {
        If (PICM)
        {
          Return (AR02 ())
        }
        Return (PR02 ())
      }
      Device (PEGP)
      {
        Name (_ADR, Zero) // _ADR: Address
        Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
        {
          0x09,Â
          0x04
        })
      }
    }
    Device (IGPU)
    {
      Name (_ADR, 0x00020000) // _ADR: Address
      Method (_STA, 0, NotSerialized) // _STA: Status
      {
        If (BRID == 0x02)
        {
          Return (Zero)
        }
        Else
        {
          Return (0x0F)
        }
      }
      Method (_INI, 0, NotSerialized) // _INI: Initialize
      {
        CLID = One
      }
      Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching
      {
        DSEN = (Arg0 & 0x07)
        If ((Arg0 & 0x03) == Zero)
        {
          If (CondRefOf (HDOS))
          {
            HDOS ()
          }
        }
      }
      Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices
      {
        If (CondRefOf (IDAB))
        {
          IDAB ()
        }
        Else
        {
          NDID = Zero
          If (DIDL != Zero)
          {
            DID1 = SDDL (DIDL)
          }
          If (DDL2 != Zero)
          {
            DID2 = SDDL (DDL2)
          }
          If (DDL3 != Zero)
          {
            DID3 = SDDL (DDL3)
          }
          If (DDL4 != Zero)
          {
            DID4 = SDDL (DDL4)
          }
          If (DDL5 != Zero)
          {
            DID5 = SDDL (DDL5)
          }
          If (DDL6 != Zero)
          {
            DID6 = SDDL (DDL6)
          }
          If (DDL7 != Zero)
          {
            DID7 = SDDL (DDL7)
          }
          If (DDL8 != Zero)
          {
            DID8 = SDDL (DDL8)
          }
        }
        If (NDID == One)
        {
          Name (TMP1, Package (0x01)
          {
            0xFFFFFFFF
          })
          TMP1 [Zero] = (0x00010000 | DID1)
          Return (TMP1) /* \_SB_.PCI0.IGPU._DOD.TMP1 */
        }
        If (NDID == 0x02)
        {
          Name (TMP2, Package (0x02)
          {
            0xFFFFFFFF,Â
            0xFFFFFFFF
          })
          TMP2 [Zero] = (0x00010000 | DID1)
          TMP2 [One] = (0x00010000 | DID2)
          Return (TMP2) /* \_SB_.PCI0.IGPU._DOD.TMP2 */
        }
        If (NDID == 0x03)
        {
          Name (TMP3, Package (0x03)
          {
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF
          })
          TMP3 [Zero] = (0x00010000 | DID1)
          TMP3 [One] = (0x00010000 | DID2)
          TMP3 [0x02] = (0x00010000 | DID3)
          Return (TMP3) /* \_SB_.PCI0.IGPU._DOD.TMP3 */
        }
        If (NDID == 0x04)
        {
          Name (TMP4, Package (0x04)
          {
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF
          })
          TMP4 [Zero] = (0x00010000 | DID1)
          TMP4 [One] = (0x00010000 | DID2)
          TMP4 [0x02] = (0x00010000 | DID3)
          TMP4 [0x03] = (0x00010000 | DID4)
          Return (TMP4) /* \_SB_.PCI0.IGPU._DOD.TMP4 */
        }
        If (NDID == 0x05)
        {
          Name (TMP5, Package (0x05)
          {
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF
          })
          TMP5 [Zero] = (0x00010000 | DID1)
          TMP5 [One] = (0x00010000 | DID2)
          TMP5 [0x02] = (0x00010000 | DID3)
          TMP5 [0x03] = (0x00010000 | DID4)
          TMP5 [0x04] = (0x00010000 | DID5)
          Return (TMP5) /* \_SB_.PCI0.IGPU._DOD.TMP5 */
        }
        If (NDID == 0x06)
        {
          Name (TMP6, Package (0x06)
          {
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF
          })
          TMP6 [Zero] = (0x00010000 | DID1)
          TMP6 [One] = (0x00010000 | DID2)
          TMP6 [0x02] = (0x00010000 | DID3)
          TMP6 [0x03] = (0x00010000 | DID4)
          TMP6 [0x04] = (0x00010000 | DID5)
          TMP6 [0x05] = (0x00010000 | DID6)
          Return (TMP6) /* \_SB_.PCI0.IGPU._DOD.TMP6 */
        }
        If (NDID == 0x07)
        {
          Name (TMP7, Package (0x07)
          {
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF
          })
          TMP7 [Zero] = (0x00010000 | DID1)
          TMP7 [One] = (0x00010000 | DID2)
          TMP7 [0x02] = (0x00010000 | DID3)
          TMP7 [0x03] = (0x00010000 | DID4)
          TMP7 [0x04] = (0x00010000 | DID5)
          TMP7 [0x05] = (0x00010000 | DID6)
          TMP7 [0x06] = (0x00010000 | DID7)
          Return (TMP7) /* \_SB_.PCI0.IGPU._DOD.TMP7 */
        }
        If (NDID == 0x08)
        {
          Name (TMP8, Package (0x08)
          {
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF,Â
            0xFFFFFFFF
          })
          TMP8 [Zero] = (0x00010000 | DID1)
          TMP8 [One] = (0x00010000 | DID2)
          TMP8 [0x02] = (0x00010000 | DID3)
          TMP8 [0x03] = (0x00010000 | DID4)
          TMP8 [0x04] = (0x00010000 | DID5)
          TMP8 [0x05] = (0x00010000 | DID6)
          TMP8 [0x06] = (0x00010000 | DID7)
          TMP8 [0x07] = (0x00010000 | DID8)
          Return (TMP8) /* \_SB_.PCI0.IGPU._DOD.TMP8 */
        }
        If (NDID == 0x09)
        {
          If (CondRefOf (HWID))
          {
            Return (HWID) /* External reference */
          }
        }
        Return (Package (0x01)
        {
          0x0400
        })
      }
      Device (DD01)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID1 == Zero)
          {
            Return (One)
          }
          Else
          {
            Return ((0xFFFF & DID1))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          Return (CDDS (DID1))
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD1) /* \NXD1 */
          }
          Return (NDDS (DID1))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
      }
      Device (DD02)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID2 == Zero)
          {
            Return (0x02)
          }
          Else
          {
            Return ((0xFFFF & DID2))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          If (LIDS == Zero)
          {
            Return (Zero)
          }
          Return (CDDS (DID2))
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD2) /* \NXD2 */
          }
          Return (NDDS (DID2))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
        Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels
        {
          Return (Package (0x12)
          {
            0x64,Â
            0x21,Â
            0x06,Â
            0x0C,Â
            0x12,Â
            0x18,Â
            0x1E,Â
            0x24,Â
            0x2A,Â
            0x30,Â
            0x36,Â
            0x3C,Â
            0x42,Â
            0x48,Â
            0x4E,Â
            0x54,Â
            0x5A,Â
            0x64
          })
        }
        Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method
        {
          If ((Arg0 >= Zero) && (Arg0 <= 0x64))
          {
            AINT (One, Arg0)
            BRTL = Arg0
          }
        }
        Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current
        {
          Return (BRTL) /* \BRTL */
        }
      }
      Device (DD03)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID3 == Zero)
          {
            Return (0x03)
          }
          Else
          {
            Return ((0xFFFF & DID3))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          If (DID3 == Zero)
          {
            Return (0x0B)
          }
          Else
          {
            Return (CDDS (DID3))
          }
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD3) /* \NXD3 */
          }
          Return (NDDS (DID3))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
      }
      Device (DD04)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID4 == Zero)
          {
            Return (0x04)
          }
          Else
          {
            Return ((0xFFFF & DID4))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          If (DID4 == Zero)
          {
            Return (0x0B)
          }
          Else
          {
            Return (CDDS (DID4))
          }
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD4) /* \NXD4 */
          }
          Return (NDDS (DID4))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
      }
      Device (DD05)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID5 == Zero)
          {
            Return (0x05)
          }
          Else
          {
            Return ((0xFFFF & DID5))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          If (DID5 == Zero)
          {
            Return (0x0B)
          }
          Else
          {
            Return (CDDS (DID5))
          }
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD5) /* \NXD5 */
          }
          Return (NDDS (DID5))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
      }
      Device (DD06)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID6 == Zero)
          {
            Return (0x06)
          }
          Else
          {
            Return ((0xFFFF & DID6))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          If (DID6 == Zero)
          {
            Return (0x0B)
          }
          Else
          {
            Return (CDDS (DID6))
          }
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD6) /* \NXD6 */
          }
          Return (NDDS (DID6))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
      }
      Device (DD07)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID7 == Zero)
          {
            Return (0x07)
          }
          Else
          {
            Return ((0xFFFF & DID7))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          If (DID7 == Zero)
          {
            Return (0x0B)
          }
          Else
          {
            Return (CDDS (DID7))
          }
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD7) /* \NXD7 */
          }
          Return (NDDS (DID7))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
      }
      Device (DD08)
      {
        Method (_ADR, 0, Serialized) // _ADR: Address
        {
          If (DID8 == Zero)
          {
            Return (0x08)
          }
          Else
          {
            Return ((0xFFFF & DID8))
          }
        }
        Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
        {
          If (DID8 == Zero)
          {
            Return (0x0B)
          }
          Else
          {
            Return (CDDS (DID8))
          }
        }
        Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
        {
          If (CondRefOf (SNXD))
          {
            Return (NXD8) /* \NXD8 */
          }
          Return (NDDS (DID8))
        }
        Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
        {
          If ((Arg0 & 0xC0000000) == 0xC0000000)
          {
            CSTE = NSTE /* \NSTE */
          }
        }
      }
      Method (SDDL, 1, NotSerialized)
      {
        NDID++
        Local0 = (Arg0 & 0x0F0F)
        Local1 = (0x80000000 | Local0)
        If (DIDL == Local0)
        {
          Return (Local1)
        }
        If (DDL2 == Local0)
        {
          Return (Local1)
        }
        If (DDL3 == Local0)
        {
          Return (Local1)
        }
        If (DDL4 == Local0)
        {
          Return (Local1)
        }
        If (DDL5 == Local0)
        {
          Return (Local1)
        }
        If (DDL6 == Local0)
        {
          Return (Local1)
        }
        If (DDL7 == Local0)
        {
          Return (Local1)
        }
        If (DDL8 == Local0)
        {
          Return (Local1)
        }
        Return (Zero)
      }
      Method (CDDS, 1, NotSerialized)
      {
        Local0 = (Arg0 & 0x0F0F)
        If (Zero == Local0)
        {
          Return (0x1D)
        }
        If (CADL == Local0)
        {
          Return (0x1F)
        }
        If (CAL2 == Local0)
        {
          Return (0x1F)
        }
        If (CAL3 == Local0)
        {
          Return (0x1F)
        }
        If (CAL4 == Local0)
        {
          Return (0x1F)
        }
        If (CAL5 == Local0)
        {
          Return (0x1F)
        }
        If (CAL6 == Local0)
        {
          Return (0x1F)
        }
        If (CAL7 == Local0)
        {
          Return (0x1F)
        }
        If (CAL8 == Local0)
        {
          Return (0x1F)
        }
        Return (0x1D)
      }
      Method (NDDS, 1, NotSerialized)
      {
        Local0 = (Arg0 & 0x0F0F)
        If (Zero == Local0)
        {
          Return (Zero)
        }
        If (NADL == Local0)
        {
          Return (One)
        }
        If (NDL2 == Local0)
        {
          Return (One)
        }
        If (NDL3 == Local0)
        {
          Return (One)
        }
        If (NDL4 == Local0)
        {
          Return (One)
        }
        If (NDL5 == Local0)
        {
          Return (One)
        }
        If (NDL6 == Local0)
        {
          Return (One)
        }
        If (NDL7 == Local0)
        {
          Return (One)
        }
        If (NDL8 == Local0)
        {
          Return (One)
        }
        Return (Zero)
      }
      Scope (^^PCI0)
      {
        OperationRegion (MCHP, PCI_Config, 0x40, 0xC0)
        Field (MCHP, AnyAcc, NoLock, Preserve)
        {
          Offset (0x60),Â
          TASM,  10,Â
          Offset (0x62)
        }
      }
      OperationRegion (IGDP, PCI_Config, 0x40, 0xC0)
      Field (IGDP, AnyAcc, NoLock, Preserve)
      {
        Offset (0x12),Â
          ,  1,Â
        GIVD,  1,Â
          ,  2,Â
        GUMA,  3,Â
        Offset (0x14),Â
          ,  4,Â
        GMFN,  1,Â
        Offset (0x18),Â
        Offset (0xA4),Â
        ASLE,  8,Â
        Offset (0xA8),Â
        GSSE,  1,Â
        GSSB,  14,Â
        GSES,  1,Â
        Offset (0xB0),Â
          ,  12,Â
        CDVL,  1,Â
        Offset (0xB2),Â
        Offset (0xB5),Â
        LBPC,  8,Â
        Offset (0xBC),Â
        ASLS,  32
      }
      OperationRegion (IGDM, SystemMemory, ASLB, 0x2000)
      Field (IGDM, AnyAcc, NoLock, Preserve)
      {
        SIGN,  128,Â
        SIZE,  32,Â
        OVER,  32,Â
        SVER,  256,Â
        VVER,  128,Â
        GVER,  128,Â
        MBOX,  32,Â
        DMOD,  32,Â
        Offset (0x100),Â
        DRDY,  32,Â
        CSTS,  32,Â
        CEVT,  32,Â
        Offset (0x120),Â
        DIDL,  32,Â
        DDL2,  32,Â
        DDL3,  32,Â
        DDL4,  32,Â
        DDL5,  32,Â
        DDL6,  32,Â
        DDL7,  32,Â
        DDL8,  32,Â
        CPDL,  32,Â
        CPL2,  32,Â
        CPL3,  32,Â
        CPL4,  32,Â
        CPL5,  32,Â
        CPL6,  32,Â
        CPL7,  32,Â
        CPL8,  32,Â
        CADL,  32,Â
        CAL2,  32,Â
        CAL3,  32,Â
        CAL4,  32,Â
        CAL5,  32,Â
        CAL6,  32,Â
        CAL7,  32,Â
        CAL8,  32,Â
        NADL,  32,Â
        NDL2,  32,Â
        NDL3,  32,Â
        NDL4,  32,Â
        NDL5,  32,Â
        NDL6,  32,Â
        NDL7,  32,Â
        NDL8,  32,Â
        ASLP,  32,Â
        TIDX,  32,Â
        CHPD,  32,Â
        CLID,  32,Â
        CDCK,  32,Â
        SXSW,  32,Â
        EVTS,  32,Â
        CNOT,  32,Â
        NRDY,  32,Â
        Offset (0x200),Â
        SCIE,  1,Â
        GEFC,  4,Â
        GXFC,  3,Â
        GESF,  8,Â
        Offset (0x204),Â
        PARM,  32,Â
        DSLP,  32,Â
        Offset (0x300),Â
        ARDY,  32,Â
        ASLC,  32,Â
        TCHE,  32,Â
        ALSI,  32,Â
        BCLP,  32,Â
        PFIT,  32,Â
        CBLV,  32,Â
        BCLM,  320,Â
        CPFM,  32,Â
        EPFM,  32,Â
        PLUT,  592,Â
        PFMB,  32,Â
        CCDV,  32,Â
        PCFT,  32,Â
        Offset (0x400),Â
        GVD1,  49152,Â
        PHED,  32,Â
        BDDC,  2048
      }
      Name (DBTB, Package (0x15)
      {
        Zero,Â
        0x07,Â
        0x38,Â
        0x01C0,Â
        0x0E00,Â
        0x3F,Â
        0x01C7,Â
        0x0E07,Â
        0x01F8,Â
        0x0E38,Â
        0x0FC0,Â
        Zero,Â
        Zero,Â
        Zero,Â
        Zero,Â
        Zero,Â
        0x7000,Â
        0x7007,Â
        0x7038,Â
        0x71C0,Â
        0x7E00
      })
      Name (CDCT, Package (0x05)
      {
        Package (0x02)
        {
          0xE4,Â
          0x0140
        },Â
        Package (0x02)
        {
          0xDE,Â
          0x014D
        },Â
        Package (0x02)
        {
          0xDE,Â
          0x014D
        },Â
        Package (0x02)
        {
          Zero,Â
          Zero
        },Â
        Package (0x02)
        {
          0xDE,Â
          0x014D
        }
      })
      Name (SUCC, One)
      Name (NVLD, 0x02)
      Name (CRIT, 0x04)
      Name (NCRT, 0x06)
      Method (GSCI, 0, Serialized)
      {
        Method (GBDA, 0, Serialized)
        {
          If (GESF == Zero)
          {
            PARM = 0x0679
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == One)
          {
            PARM = 0x0240
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x04)
          {
            PARM &= 0xEFFF0000
            PARM &= (DerefOf (DBTB [IBTT]) << 0x10)
            PARM |= IBTT /* \_SB_.PCI0.IGPU.PARM */
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x05)
          {
            PARM = IPSC /* \IPSC */
            PARM |= (IPAT << 0x08)
            PARM += 0x0100
            PARM |= (LIDS << 0x10)
            PARM += 0x00010000
            PARM |= (IBIA << 0x14)
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x06)
          {
            PARM = ITVF /* \ITVF */
            PARM |= (ITVM << 0x04)
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x07)
          {
            PARM = GIVD /* \_SB_.PCI0.IGPU.GIVD */
            PARM ^= One
            PARM |= (GMFN << One)
            PARM |= 0x1800
            PARM |= (IDMS << 0x11)
            PARM |= (DerefOf (DerefOf (CDCT [HVCO]) [CDVL]) <<Â
              0x15) /* \_SB_.PCI0.IGPU.PARM */
            GESF = One
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x0A)
          {
            PARM = Zero
            If (ISSC)
            {
              PARM |= 0x03
            }
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x0B)
          {
            PARM = KSV0 /* \KSV0 */
            GESF = KSV1 /* \KSV1 */
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          GESF = Zero
          Return (CRIT) /* \_SB_.PCI0.IGPU.CRIT */
        }
        Method (SBCB, 0, Serialized)
        {
          If (GESF == Zero)
          {
            PARM = Zero
            PARM = 0x000F87FD
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == One)
          {
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x03)
          {
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x04)
          {
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x05)
          {
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x06)
          {
            ITVF = (PARM & 0x0F)
            ITVM = ((PARM & 0xF0) >> 0x04)
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x07)
          {
            If (PARM == Zero)
            {
              Local0 = CLID /* \_SB_.PCI0.IGPU.CLID */
              If (0x80000000 & Local0)
              {
                CLID &= 0x0F
                GLID (CLID)
              }
            }
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x08)
          {
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x09)
          {
            IBTT = (PARM & 0xFF)
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x0A)
          {
            IPSC = (PARM & 0xFF)
            If ((PARM >> 0x08) & 0xFF)
            {
              IPAT = ((PARM >> 0x08) & 0xFF)
              IPAT--
            }
            IBIA = ((PARM >> 0x14) & 0x07)
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x0B)
          {
            IF1E = ((PARM >> One) & One)
            If (PARM & 0x0001E000)
            {
              IDMS = ((PARM >> 0x0D) & 0x0F)
            }
            Else
            {
              IDMS = ((PARM >> 0x11) & 0x0F)
            }
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x10)
          {
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x11)
          {
            PARM = (LIDS << 0x08)
            PARM += 0x0100
            GESF = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x12)
          {
            If (PARM & One)
            {
              If ((PARM >> One) == One)
              {
                ISSC = One
              }
              Else
              {
                GESF = Zero
                Return (CRIT) /* \_SB_.PCI0.IGPU.CRIT */
              }
            }
            Else
            {
              ISSC = Zero
            }
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x13)
          {
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          If (GESF == 0x14)
          {
            PAVP = (PARM & 0x0F)
            GESF = Zero
            PARM = Zero
            Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
          }
          GESF = Zero
          Return (SUCC) /* \_SB_.PCI0.IGPU.SUCC */
        }
        If (GEFC == 0x04)
        {
          GXFC = GBDA ()
        }
        If (GEFC == 0x06)
        {
          GXFC = SBCB ()
        }
        GEFC = Zero
        SCIS = One
        GSSE = Zero
        SCIE = Zero
        Return (Zero)
      }
      Method (PDRD, 0, NotSerialized)
      {
        If (!DRDY)
        {
          Sleep (ASLP)
        }
        Return (!DRDY)
      }
      Method (PSTS, 0, NotSerialized)
      {
        If (CSTS > 0x02)
        {
          Sleep (ASLP)
        }
        Return ((CSTS == 0x03))
      }
      Method (GNOT, 2, NotSerialized)
      {
        If (PDRD ())
        {
          Return (One)
        }
        CEVT = Arg0
        CSTS = 0x03
        If ((CHPD == Zero) && (Arg1 == Zero))
        {
          If ((OSYS > 0x07D0) || (OSYS < 0x07D6))
          {
            Notify (PCI0, Arg1)
          }
          Else
          {
            Notify (IGPU, Arg1)
          }
        }
        If (CondRefOf (HNOT))
        {
          HNOT (Arg0)
        }
        Else
        {
          Notify (IGPU, 0x80) // Status Change
        }
        Return (Zero)
      }
      Method (GHDS, 1, NotSerialized)
      {
        TIDX = Arg0
        Return (GNOT (One, Zero))
      }
      Method (GLID, 1, NotSerialized)
      {
        CLID = Arg0
        Return (GNOT (0x02, Zero))
      }
      Method (GDCK, 1, NotSerialized)
      {
        CDCK = Arg0
        Return (GNOT (0x04, Zero))
      }
      Method (PARD, 0, NotSerialized)
      {
        If (!ARDY)
        {
          Sleep (ASLP)
        }
        Return (!ARDY)
      }
      Method (AINT, 2, NotSerialized)
      {
        If (!(TCHE & (One << Arg0)))
        {
          Return (One)
        }
        If (PARD ())
        {
          Return (One)
        }
        If (Arg0 == 0x02)
        {
          If (CPFM)
          {
            Local0 = (CPFM & 0x0F)
            Local1 = (EPFM & 0x0F)
            If (Local0 == One)
            {
              If (Local1 & 0x06)
              {
                PFIT = 0x06
              }
              ElseIf (Local1 & 0x08)
              {
                PFIT = 0x08
              }
              Else
              {
                PFIT = One
              }
            }
            If (Local0 == 0x06)
            {
              If (Local1 & 0x08)
              {
                PFIT = 0x08
              }
              ElseIf (Local1 & One)
              {
                PFIT = One
              }
              Else
              {
                PFIT = 0x06
              }
            }
            If (Local0 == 0x08)
            {
              If (Local1 & One)
              {
                PFIT = One
              }
              ElseIf (Local1 & 0x06)
              {
                PFIT = 0x06
              }
              Else
              {
                PFIT = 0x08
              }
            }
          }
          Else
          {
            PFIT ^= 0x07
          }
          PFIT |= 0x80000000
          ASLC = 0x04
        }
        ElseIf (Arg0 == One)
        {
          BCLP = ((Arg1 * 0xFF) / 0x64)
          BCLP |= 0x80000000
          ASLC = 0x02
        }
        ElseIf (Arg0 == Zero)
        {
          ALSI = Arg1
          ASLC = One
        }
        Else
        {
          Return (One)
        }
        ASLE = One
        Return (Zero)
      }
      Method (SCIP, 0, NotSerialized)
      {
        If (OVER != Zero)
        {
          Return (!GSMI)
        }
        Return (Zero)
      }
    }
  }
  Scope (_SB.PCI0)
  {
    Device (A_CC)
    {
      Name (_HID, "SMO8800") // _HID: Hardware ID
      Method (_STA, 0, NotSerialized) // _STA: Status
      {
        Return (0x0F)
      }
      Name (_UID, One) // _UID: Unique ID
      Name (BUF2, ResourceTemplate ()
      {
        Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, ,, )
        {
          0x00000014,
        }
      })
      Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
      {
        Return (BUF2) /* \_SB_.PCI0.A_CC.BUF2 */
      }
      Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
      {
        Return (BUF2) /* \_SB_.PCI0.A_CC.BUF2 */
      }
    }
  }
  Scope (_SB.PCI0.SATA)
  {
    Device (PRT0)
    {
      Name (_ADR, 0xFFFF) // _ADR: Address
      Name (GTF0, Buffer (0x07)
      {
         0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00     /* ....... */
      })
      Method (_SDD, 1, NotSerialized) // _SDD: Set Device Data
      {
        CreateByteField (GTF0, Zero, FEAT)
        CreateByteField (GTF0, 0x06, CMMD)
        CreateWordField (Arg0, 0xEE, W119)
        CreateWordField (Arg0, 0xF0, W120)
        CreateWordField (Arg0, 0x0134, W154)
        CreateWordField (Arg0, 0x0138, W156)
        If (SizeOf (Arg0) == 0x0200)
        {
          If ((W154 == 0x1028) & ((W156 & 0x4000) == 0x4000))
          {
            If ((W156 & 0x8000) == Zero)
            {
              FEAT = 0x5A
              CMMD = 0xEF
            }
          }
          ElseIf ((W119 & 0x20) == 0x20)
          {
            If ((W120 & 0x20) == Zero)
            {
              FEAT = 0x41
              CMMD = 0xEF
            }
          }
          Else
          {
          }
        }
      }
      Method (_GTF, 0, NotSerialized) // _GTF: Get Task File
      {
        Return (GTF0) /* \_SB_.PCI0.SATA.PRT0.GTF0 */
      }
    }
  }
  Name (_S0, Package (0x04) // _S0_: S0 System State
  {
    Zero,Â
    Zero,Â
    Zero,Â
    Zero
  })
  If (SS3)
  {
    Name (_S3, Package (0x04) // _S3_: S3 System State
    {
      0x05,Â
      Zero,Â
      Zero,Â
      Zero
    })
  }
  If (SS4)
  {
    Name (_S4, Package (0x04) // _S4_: S4 System State
    {
      0x07,Â
      Zero,Â
      Zero,Â
      Zero
    })
  }
  Name (_S5, Package (0x04) // _S5_: S5 System State
  {
    0x07,Â
    Zero,Â
    Zero,Â
    Zero
  })
  Method (PTS, 1, NotSerialized)
  {
    If (Arg0) {}
  }
  Method (WAK, 1, NotSerialized)
  {
  }
}