Device (BAT1)
        {
            Name (_HID, EisaId ("PNP0C0A"))  // _HID: Hardware ID
            Name (_UID, One)  // _UID: Unique ID
            Name (_PCL, Package (0x01)  // _PCL: Power Consumer List
            {
                _SB
            })
            Name (BMDL, Zero)
            Name (BASC, One)
            Name (BFFW, Zero)
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                Return (Zero)
            }

            Method (_BIF, 0, NotSerialized)  // _BIF: Battery Information
            {
                Return (BIFX (Zero))
            }

            Method (_BIX, 0, NotSerialized)  // _BIX: Battery Information Extended
            {
                Return (BIFX (One))
            }

            Method (BIFX, 1, Serialized)
            {
                Name (STAX, Package (0x14)
                {
                    Zero, 
                    One, 
                    0x1770, 
                    0x1770, 
                    One, 
                    0x2A30, 
                    0x0258, 
                    0xB4, 
                    Zero, 
                    Zero, 
                    Zero, 
                    Zero, 
                    Zero, 
                    Zero, 
                    0x0108, 
                    0x0EC4, 
                    "PABAS0241231", 
                    "41167", 
                    "Li-Ion", 
                    "LENOVO "
                })
                Name (STAF, Package (0x0D)
                {
                    One, 
                    0x1770, 
                    0x1770, 
                    One, 
                    0x2A30, 
                    0x0258, 
                    0xB4, 
                    0x0108, 
                    0x0EC4, 
                    "PABAS0241231", 
                    "41167", 
                    "Li-Ion", 
                    "LENOVO "
                })
                If (ECOK ())
                {
                    If (LEqual (^^EC0.BAM0, Zero))
                    {
                        Store (0x0A, BASC)
                    }

                    Store (^^EC0.BAM0, Index (STAX, One))
                    Store (^^EC0.BDN0, Local0)
                    Store (Local0, BMDL)
                    Store (Multiply (^^EC0.BDC0, BASC), Index (STAX, 0x02))
                    Sleep (Zero)
                    Store (^^EC0.BDV0, Index (STAX, 0x05))
                    Sleep (Zero)
                    If (LEqual (BFFW, One))
                    {
                        Store (^^EC0.BFCB, Local2)
                    }
                    Else
                    {
                        Store (^^EC0.BFC0, Local2)
                    }

                    Store (Multiply (Local2, BASC), Local2)
                    Sleep (Zero)
                    Store (Local2, Index (STAX, 0x03))
                    Divide (Local2, 0x64, Local0, Local1)
                    Multiply (Local1, 0x0A, Local1)
                    Store (Local1, Index (STAX, 0x06))
                    Divide (Local2, 0x64, Local0, Local1)
                    Multiply (Local1, 0x03, Local1)
                    Store (Local1, Index (STAX, 0x07))
                    Store (DerefOf (Index (STAX, One)), Index (STAF, Zero))
                    Store (DerefOf (Index (STAX, 0x02)), Index (STAF, One))
                    Store (DerefOf (Index (STAX, 0x03)), Index (STAF, 0x02))
                    Store (DerefOf (Index (STAX, 0x04)), Index (STAF, 0x03))
                    Store (DerefOf (Index (STAX, 0x05)), Index (STAF, 0x04))
                    Store (DerefOf (Index (STAX, 0x06)), Index (STAF, 0x05))
                    Store (DerefOf (Index (STAX, 0x07)), Index (STAF, 0x06))
                    Store (DerefOf (Index (STAX, 0x0E)), Index (STAF, 0x07))
                    Store (DerefOf (Index (STAX, 0x0F)), Index (STAF, 0x08))
                    Store (DerefOf (Index (STAX, 0x10)), Index (STAF, 0x09))
                    Store (DerefOf (Index (STAX, 0x11)), Index (STAF, 0x0A))
                    Store (DerefOf (Index (STAX, 0x12)), Index (STAF, 0x0B))
                    Store (DerefOf (Index (STAX, 0x13)), Index (STAF, 0x0C))
                    If (LEqual (Arg0, One))
                    {
                        Return (STAX)
                    }
                    Else
                    {
                        Return (STAF)
                    }
                }

                Return (Zero)
            }

            Method (_BST, 0, Serialized)  // _BST: Battery Status
            {
                Name (PBST, Package (0x04)
                {
                    Zero, 
                    Ones, 
                    Ones, 
                    0x1770
                })
                If (ECOK ())
                {
                    Store (^^EC0.BST0, Index (PBST, Zero))
                    Sleep (Zero)
                    Store (^^EC0.BAC0, Local4)
                    If (LEqual (^^EC0.ADPT, Zero))
                    {
                        Subtract (0xFFFF, Local4, Local4)
                    }

                    Multiply (Local4, 0x0A, Local5)
                    If (LEqual (^^EC0.BAM0, Zero))
                    {
                        Divide (Multiply (Local4, ^^EC0.BPV0), 0x03E8, , Local4)
                    }

                    Store (Local5, Local4)
                    Store (Local4, Index (PBST, One))
                    Sleep (Zero)
                    If (LEqual (BFFW, One))
                    {
                        Multiply (^^EC0.BFCB, BASC, Local4)
                        Multiply (^^EC0.GAU0, Local4, Local2)
                        Divide (Local2, 0x64, Local4, Local2)
                        Store (Local2, Index (PBST, 0x02))
                        Sleep (Zero)
                    }
                    Else
                    {
                        Store (Multiply (^^EC0.BRC0, BASC), Index (PBST, 0x02))
                        Sleep (Zero)
                    }

                    Store (^^EC0.BPV0, Index (PBST, 0x03))
                    Sleep (Zero)
                    If (LNotEqual (^^EC0.BDN0, BMDL))
                    {
                        Notify (BAT1, 0x81)
                    }
                }

                Return (PBST)
            }

            Method (_BTP, 1, NotSerialized)  // _BTP: Battery Trip Point
            {
                Divide (Arg0, BASC, , Local0)
                Store (Local0, ^^EC0.BTPB)
            }
        }