text:
namespace Kvasir {
//Low leakage wakeup unit
    namespace LlwuPe1{    ///<LLWU Pin Enable 1 register
        using Addr = Register::Address<0x4007c000,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup Pin Enable For LLWU_P0
        enum class Wupe0Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,Wupe0Val> wupe0{};
        namespace Wupe0ValC{
            constexpr Register::FieldValue<decltype(wupe0)::Type,Wupe0Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe0)::Type,Wupe0Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe0)::Type,Wupe0Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe0)::Type,Wupe0Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P1
        enum class Wupe1Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,2),Register::ReadWriteAccess,Wupe1Val> wupe1{};
        namespace Wupe1ValC{
            constexpr Register::FieldValue<decltype(wupe1)::Type,Wupe1Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe1)::Type,Wupe1Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe1)::Type,Wupe1Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe1)::Type,Wupe1Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P2
        enum class Wupe2Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,4),Register::ReadWriteAccess,Wupe2Val> wupe2{};
        namespace Wupe2ValC{
            constexpr Register::FieldValue<decltype(wupe2)::Type,Wupe2Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe2)::Type,Wupe2Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe2)::Type,Wupe2Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe2)::Type,Wupe2Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P3
        enum class Wupe3Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,6),Register::ReadWriteAccess,Wupe3Val> wupe3{};
        namespace Wupe3ValC{
            constexpr Register::FieldValue<decltype(wupe3)::Type,Wupe3Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe3)::Type,Wupe3Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe3)::Type,Wupe3Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe3)::Type,Wupe3Val::v11> v11{};
        }
    }
    namespace LlwuPe2{    ///<LLWU Pin Enable 2 register
        using Addr = Register::Address<0x4007c001,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup Pin Enable For LLWU_P4
        enum class Wupe4Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,Wupe4Val> wupe4{};
        namespace Wupe4ValC{
            constexpr Register::FieldValue<decltype(wupe4)::Type,Wupe4Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe4)::Type,Wupe4Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe4)::Type,Wupe4Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe4)::Type,Wupe4Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P5
        enum class Wupe5Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,2),Register::ReadWriteAccess,Wupe5Val> wupe5{};
        namespace Wupe5ValC{
            constexpr Register::FieldValue<decltype(wupe5)::Type,Wupe5Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe5)::Type,Wupe5Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe5)::Type,Wupe5Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe5)::Type,Wupe5Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P6
        enum class Wupe6Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,4),Register::ReadWriteAccess,Wupe6Val> wupe6{};
        namespace Wupe6ValC{
            constexpr Register::FieldValue<decltype(wupe6)::Type,Wupe6Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe6)::Type,Wupe6Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe6)::Type,Wupe6Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe6)::Type,Wupe6Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P7
        enum class Wupe7Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,6),Register::ReadWriteAccess,Wupe7Val> wupe7{};
        namespace Wupe7ValC{
            constexpr Register::FieldValue<decltype(wupe7)::Type,Wupe7Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe7)::Type,Wupe7Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe7)::Type,Wupe7Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe7)::Type,Wupe7Val::v11> v11{};
        }
    }
    namespace LlwuPe3{    ///<LLWU Pin Enable 3 register
        using Addr = Register::Address<0x4007c002,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup Pin Enable For LLWU_P8
        enum class Wupe8Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,Wupe8Val> wupe8{};
        namespace Wupe8ValC{
            constexpr Register::FieldValue<decltype(wupe8)::Type,Wupe8Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe8)::Type,Wupe8Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe8)::Type,Wupe8Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe8)::Type,Wupe8Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P9
        enum class Wupe9Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,2),Register::ReadWriteAccess,Wupe9Val> wupe9{};
        namespace Wupe9ValC{
            constexpr Register::FieldValue<decltype(wupe9)::Type,Wupe9Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe9)::Type,Wupe9Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe9)::Type,Wupe9Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe9)::Type,Wupe9Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P10
        enum class Wupe10Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,4),Register::ReadWriteAccess,Wupe10Val> wupe10{};
        namespace Wupe10ValC{
            constexpr Register::FieldValue<decltype(wupe10)::Type,Wupe10Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe10)::Type,Wupe10Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe10)::Type,Wupe10Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe10)::Type,Wupe10Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P11
        enum class Wupe11Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,6),Register::ReadWriteAccess,Wupe11Val> wupe11{};
        namespace Wupe11ValC{
            constexpr Register::FieldValue<decltype(wupe11)::Type,Wupe11Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe11)::Type,Wupe11Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe11)::Type,Wupe11Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe11)::Type,Wupe11Val::v11> v11{};
        }
    }
    namespace LlwuPe4{    ///<LLWU Pin Enable 4 register
        using Addr = Register::Address<0x4007c003,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup Pin Enable For LLWU_P12
        enum class Wupe12Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,Wupe12Val> wupe12{};
        namespace Wupe12ValC{
            constexpr Register::FieldValue<decltype(wupe12)::Type,Wupe12Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe12)::Type,Wupe12Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe12)::Type,Wupe12Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe12)::Type,Wupe12Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P13
        enum class Wupe13Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,2),Register::ReadWriteAccess,Wupe13Val> wupe13{};
        namespace Wupe13ValC{
            constexpr Register::FieldValue<decltype(wupe13)::Type,Wupe13Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe13)::Type,Wupe13Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe13)::Type,Wupe13Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe13)::Type,Wupe13Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P14
        enum class Wupe14Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,4),Register::ReadWriteAccess,Wupe14Val> wupe14{};
        namespace Wupe14ValC{
            constexpr Register::FieldValue<decltype(wupe14)::Type,Wupe14Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe14)::Type,Wupe14Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe14)::Type,Wupe14Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe14)::Type,Wupe14Val::v11> v11{};
        }
        ///Wakeup Pin Enable For LLWU_P15
        enum class Wupe15Val {
            v00=0x00000000,     ///<External input pin disabled as wakeup input
            v01=0x00000001,     ///<External input pin enabled with rising edge detection
            v10=0x00000002,     ///<External input pin enabled with falling edge detection
            v11=0x00000003,     ///<External input pin enabled with any change detection
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,6),Register::ReadWriteAccess,Wupe15Val> wupe15{};
        namespace Wupe15ValC{
            constexpr Register::FieldValue<decltype(wupe15)::Type,Wupe15Val::v00> v00{};
            constexpr Register::FieldValue<decltype(wupe15)::Type,Wupe15Val::v01> v01{};
            constexpr Register::FieldValue<decltype(wupe15)::Type,Wupe15Val::v10> v10{};
            constexpr Register::FieldValue<decltype(wupe15)::Type,Wupe15Val::v11> v11{};
        }
    }
    namespace LlwuMe{    ///<LLWU Module Enable register
        using Addr = Register::Address<0x4007c004,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup Module Enable For Module 0
        enum class Wume0Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,Wume0Val> wume0{};
        namespace Wume0ValC{
            constexpr Register::FieldValue<decltype(wume0)::Type,Wume0Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume0)::Type,Wume0Val::v1> v1{};
        }
        ///Wakeup Module Enable for Module 1
        enum class Wume1Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,Wume1Val> wume1{};
        namespace Wume1ValC{
            constexpr Register::FieldValue<decltype(wume1)::Type,Wume1Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume1)::Type,Wume1Val::v1> v1{};
        }
        ///Wakeup Module Enable For Module 2
        enum class Wume2Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,Wume2Val> wume2{};
        namespace Wume2ValC{
            constexpr Register::FieldValue<decltype(wume2)::Type,Wume2Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume2)::Type,Wume2Val::v1> v1{};
        }
        ///Wakeup Module Enable For Module 3
        enum class Wume3Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,Wume3Val> wume3{};
        namespace Wume3ValC{
            constexpr Register::FieldValue<decltype(wume3)::Type,Wume3Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume3)::Type,Wume3Val::v1> v1{};
        }
        ///Wakeup Module Enable For Module 4
        enum class Wume4Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,Wume4Val> wume4{};
        namespace Wume4ValC{
            constexpr Register::FieldValue<decltype(wume4)::Type,Wume4Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume4)::Type,Wume4Val::v1> v1{};
        }
        ///Wakeup Module Enable For Module 5
        enum class Wume5Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,Wume5Val> wume5{};
        namespace Wume5ValC{
            constexpr Register::FieldValue<decltype(wume5)::Type,Wume5Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume5)::Type,Wume5Val::v1> v1{};
        }
        ///Wakeup Module Enable For Module 6
        enum class Wume6Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,Wume6Val> wume6{};
        namespace Wume6ValC{
            constexpr Register::FieldValue<decltype(wume6)::Type,Wume6Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume6)::Type,Wume6Val::v1> v1{};
        }
        ///Wakeup Module Enable For Module 7
        enum class Wume7Val {
            v0=0x00000000,     ///<Internal module flag not used as wakeup source
            v1=0x00000001,     ///<Internal module flag used as wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,Wume7Val> wume7{};
        namespace Wume7ValC{
            constexpr Register::FieldValue<decltype(wume7)::Type,Wume7Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wume7)::Type,Wume7Val::v1> v1{};
        }
    }
    namespace LlwuF1{    ///<LLWU Flag 1 register
        using Addr = Register::Address<0x4007c005,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup Flag For LLWU_P0
        enum class Wuf0Val {
            v0=0x00000000,     ///<LLWU_P0 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P0 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,Wuf0Val> wuf0{};
        namespace Wuf0ValC{
            constexpr Register::FieldValue<decltype(wuf0)::Type,Wuf0Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf0)::Type,Wuf0Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P1
        enum class Wuf1Val {
            v0=0x00000000,     ///<LLWU_P1 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P1 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,Wuf1Val> wuf1{};
        namespace Wuf1ValC{
            constexpr Register::FieldValue<decltype(wuf1)::Type,Wuf1Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf1)::Type,Wuf1Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P2
        enum class Wuf2Val {
            v0=0x00000000,     ///<LLWU_P2 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P2 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,Wuf2Val> wuf2{};
        namespace Wuf2ValC{
            constexpr Register::FieldValue<decltype(wuf2)::Type,Wuf2Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf2)::Type,Wuf2Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P3
        enum class Wuf3Val {
            v0=0x00000000,     ///<LLWU_P3 input was not a wake-up source
            v1=0x00000001,     ///<LLWU_P3 input was a wake-up source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,Wuf3Val> wuf3{};
        namespace Wuf3ValC{
            constexpr Register::FieldValue<decltype(wuf3)::Type,Wuf3Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf3)::Type,Wuf3Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P4
        enum class Wuf4Val {
            v0=0x00000000,     ///<LLWU_P4 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P4 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,Wuf4Val> wuf4{};
        namespace Wuf4ValC{
            constexpr Register::FieldValue<decltype(wuf4)::Type,Wuf4Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf4)::Type,Wuf4Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P5
        enum class Wuf5Val {
            v0=0x00000000,     ///<LLWU_P5 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P5 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,Wuf5Val> wuf5{};
        namespace Wuf5ValC{
            constexpr Register::FieldValue<decltype(wuf5)::Type,Wuf5Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf5)::Type,Wuf5Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P6
        enum class Wuf6Val {
            v0=0x00000000,     ///<LLWU_P6 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P6 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,Wuf6Val> wuf6{};
        namespace Wuf6ValC{
            constexpr Register::FieldValue<decltype(wuf6)::Type,Wuf6Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf6)::Type,Wuf6Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P7
        enum class Wuf7Val {
            v0=0x00000000,     ///<LLWU_P7 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P7 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,Wuf7Val> wuf7{};
        namespace Wuf7ValC{
            constexpr Register::FieldValue<decltype(wuf7)::Type,Wuf7Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf7)::Type,Wuf7Val::v1> v1{};
        }
    }
    namespace LlwuF2{    ///<LLWU Flag 2 register
        using Addr = Register::Address<0x4007c006,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup Flag For LLWU_P8
        enum class Wuf8Val {
            v0=0x00000000,     ///<LLWU_P8 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P8 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,Wuf8Val> wuf8{};
        namespace Wuf8ValC{
            constexpr Register::FieldValue<decltype(wuf8)::Type,Wuf8Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf8)::Type,Wuf8Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P9
        enum class Wuf9Val {
            v0=0x00000000,     ///<LLWU_P9 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P9 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,Wuf9Val> wuf9{};
        namespace Wuf9ValC{
            constexpr Register::FieldValue<decltype(wuf9)::Type,Wuf9Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf9)::Type,Wuf9Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P10
        enum class Wuf10Val {
            v0=0x00000000,     ///<LLWU_P10 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P10 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,Wuf10Val> wuf10{};
        namespace Wuf10ValC{
            constexpr Register::FieldValue<decltype(wuf10)::Type,Wuf10Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf10)::Type,Wuf10Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P11
        enum class Wuf11Val {
            v0=0x00000000,     ///<LLWU_P11 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P11 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,Wuf11Val> wuf11{};
        namespace Wuf11ValC{
            constexpr Register::FieldValue<decltype(wuf11)::Type,Wuf11Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf11)::Type,Wuf11Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P12
        enum class Wuf12Val {
            v0=0x00000000,     ///<LLWU_P12 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P12 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,Wuf12Val> wuf12{};
        namespace Wuf12ValC{
            constexpr Register::FieldValue<decltype(wuf12)::Type,Wuf12Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf12)::Type,Wuf12Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P13
        enum class Wuf13Val {
            v0=0x00000000,     ///<LLWU_P13 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P13 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,Wuf13Val> wuf13{};
        namespace Wuf13ValC{
            constexpr Register::FieldValue<decltype(wuf13)::Type,Wuf13Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf13)::Type,Wuf13Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P14
        enum class Wuf14Val {
            v0=0x00000000,     ///<LLWU_P14 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P14 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,Wuf14Val> wuf14{};
        namespace Wuf14ValC{
            constexpr Register::FieldValue<decltype(wuf14)::Type,Wuf14Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf14)::Type,Wuf14Val::v1> v1{};
        }
        ///Wakeup Flag For LLWU_P15
        enum class Wuf15Val {
            v0=0x00000000,     ///<LLWU_P15 input was not a wakeup source
            v1=0x00000001,     ///<LLWU_P15 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,Wuf15Val> wuf15{};
        namespace Wuf15ValC{
            constexpr Register::FieldValue<decltype(wuf15)::Type,Wuf15Val::v0> v0{};
            constexpr Register::FieldValue<decltype(wuf15)::Type,Wuf15Val::v1> v1{};
        }
    }
    namespace LlwuF3{    ///<LLWU Flag 3 register
        using Addr = Register::Address<0x4007c007,0xffffff00,0x00000000,unsigned char>;
        ///Wakeup flag For module 0
        enum class Mwuf0Val {
            v0=0x00000000,     ///<Module 0 input was not a wakeup source
            v1=0x00000001,     ///<Module 0 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf0Val> mwuf0{};
        namespace Mwuf0ValC{
            constexpr Register::FieldValue<decltype(mwuf0)::Type,Mwuf0Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf0)::Type,Mwuf0Val::v1> v1{};
        }
        ///Wakeup flag For module 1
        enum class Mwuf1Val {
            v0=0x00000000,     ///<Module 1 input was not a wakeup source
            v1=0x00000001,     ///<Module 1 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf1Val> mwuf1{};
        namespace Mwuf1ValC{
            constexpr Register::FieldValue<decltype(mwuf1)::Type,Mwuf1Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf1)::Type,Mwuf1Val::v1> v1{};
        }
        ///Wakeup flag For module 2
        enum class Mwuf2Val {
            v0=0x00000000,     ///<Module 2 input was not a wakeup source
            v1=0x00000001,     ///<Module 2 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf2Val> mwuf2{};
        namespace Mwuf2ValC{
            constexpr Register::FieldValue<decltype(mwuf2)::Type,Mwuf2Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf2)::Type,Mwuf2Val::v1> v1{};
        }
        ///Wakeup flag For module 3
        enum class Mwuf3Val {
            v0=0x00000000,     ///<Module 3 input was not a wakeup source
            v1=0x00000001,     ///<Module 3 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf3Val> mwuf3{};
        namespace Mwuf3ValC{
            constexpr Register::FieldValue<decltype(mwuf3)::Type,Mwuf3Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf3)::Type,Mwuf3Val::v1> v1{};
        }
        ///Wakeup flag For module 4
        enum class Mwuf4Val {
            v0=0x00000000,     ///<Module 4 input was not a wakeup source
            v1=0x00000001,     ///<Module 4 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf4Val> mwuf4{};
        namespace Mwuf4ValC{
            constexpr Register::FieldValue<decltype(mwuf4)::Type,Mwuf4Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf4)::Type,Mwuf4Val::v1> v1{};
        }
        ///Wakeup flag For module 5
        enum class Mwuf5Val {
            v0=0x00000000,     ///<Module 5 input was not a wakeup source
            v1=0x00000001,     ///<Module 5 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf5Val> mwuf5{};
        namespace Mwuf5ValC{
            constexpr Register::FieldValue<decltype(mwuf5)::Type,Mwuf5Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf5)::Type,Mwuf5Val::v1> v1{};
        }
        ///Wakeup flag For module 6
        enum class Mwuf6Val {
            v0=0x00000000,     ///<Module 6 input was not a wakeup source
            v1=0x00000001,     ///<Module 6 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf6Val> mwuf6{};
        namespace Mwuf6ValC{
            constexpr Register::FieldValue<decltype(mwuf6)::Type,Mwuf6Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf6)::Type,Mwuf6Val::v1> v1{};
        }
        ///Wakeup flag For module 7
        enum class Mwuf7Val {
            v0=0x00000000,     ///<Module 7 input was not a wakeup source
            v1=0x00000001,     ///<Module 7 input was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Mwuf7Val> mwuf7{};
        namespace Mwuf7ValC{
            constexpr Register::FieldValue<decltype(mwuf7)::Type,Mwuf7Val::v0> v0{};
            constexpr Register::FieldValue<decltype(mwuf7)::Type,Mwuf7Val::v1> v1{};
        }
    }
    namespace LlwuFilt1{    ///<LLWU Pin Filter 1 register
        using Addr = Register::Address<0x4007c008,0xffffff10,0x00000000,unsigned char>;
        ///Filter Pin Select
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,0),Register::ReadWriteAccess,unsigned> filtsel{};
        ///Digital Filter On External Pin
        enum class FilteVal {
            v00=0x00000000,     ///<Filter disabled
            v01=0x00000001,     ///<Filter posedge detect enabled
            v10=0x00000002,     ///<Filter negedge detect enabled
            v11=0x00000003,     ///<Filter any edge detect enabled
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,5),Register::ReadWriteAccess,FilteVal> filte{};
        namespace FilteValC{
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v00> v00{};
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v01> v01{};
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v10> v10{};
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v11> v11{};
        }
        ///Filter Detect Flag
        enum class FiltfVal {
            v0=0x00000000,     ///<Pin Filter 1 was not a wakeup source
            v1=0x00000001,     ///<Pin Filter 1 was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,FiltfVal> filtf{};
        namespace FiltfValC{
            constexpr Register::FieldValue<decltype(filtf)::Type,FiltfVal::v0> v0{};
            constexpr Register::FieldValue<decltype(filtf)::Type,FiltfVal::v1> v1{};
        }
    }
    namespace LlwuFilt2{    ///<LLWU Pin Filter 2 register
        using Addr = Register::Address<0x4007c009,0xffffff10,0x00000000,unsigned char>;
        ///Filter Pin Select
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,0),Register::ReadWriteAccess,unsigned> filtsel{};
        ///Digital Filter On External Pin
        enum class FilteVal {
            v00=0x00000000,     ///<Filter disabled
            v01=0x00000001,     ///<Filter posedge detect enabled
            v10=0x00000002,     ///<Filter negedge detect enabled
            v11=0x00000003,     ///<Filter any edge detect enabled
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,5),Register::ReadWriteAccess,FilteVal> filte{};
        namespace FilteValC{
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v00> v00{};
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v01> v01{};
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v10> v10{};
            constexpr Register::FieldValue<decltype(filte)::Type,FilteVal::v11> v11{};
        }
        ///Filter Detect Flag
        enum class FiltfVal {
            v0=0x00000000,     ///<Pin Filter 2 was not a wakeup source
            v1=0x00000001,     ///<Pin Filter 2 was a wakeup source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,FiltfVal> filtf{};
        namespace FiltfValC{
            constexpr Register::FieldValue<decltype(filtf)::Type,FiltfVal::v0> v0{};
            constexpr Register::FieldValue<decltype(filtf)::Type,FiltfVal::v1> v1{};
        }
    }
    namespace LlwuRst{    ///<LLWU Reset Enable register
        using Addr = Register::Address<0x4007c00a,0xfffffffc,0x00000000,unsigned char>;
        ///Digital Filter On RESET Pin
        enum class RstfiltVal {
            v0=0x00000000,     ///<Filter not enabled
            v1=0x00000001,     ///<Filter enabled
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,RstfiltVal> rstfilt{};
        namespace RstfiltValC{
            constexpr Register::FieldValue<decltype(rstfilt)::Type,RstfiltVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rstfilt)::Type,RstfiltVal::v1> v1{};
        }
        ///Low-Leakage Mode RESET Enable
        enum class LlrsteVal {
            v0=0x00000000,     ///<RESET pin not enabled as a leakage mode exit source
            v1=0x00000001,     ///<RESET pin enabled as a low leakage mode exit source
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,LlrsteVal> llrste{};
        namespace LlrsteValC{
            constexpr Register::FieldValue<decltype(llrste)::Type,LlrsteVal::v0> v0{};
            constexpr Register::FieldValue<decltype(llrste)::Type,LlrsteVal::v1> v1{};
        }
    }
}


text:
package org.locationtech.geowave.core.index;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import org.locationtech.geowave.core.index.ByteArrayRange.MergeOperation;

public class QueryRanges {

  private final Collection<SinglePartitionQueryRanges> partitionRanges;
  private List<ByteArrayRange> compositeQueryRanges;

  public QueryRanges() {
    // this implies an infinite range
    partitionRanges = null;
  }

  public QueryRanges(final byte[][] partitionKeys, final QueryRanges queryRanges) {
    if ((queryRanges == null)
        || (queryRanges.partitionRanges == null)
        || queryRanges.partitionRanges.isEmpty()) {
      partitionRanges = fromPartitionKeys(partitionKeys);
    } else if ((partitionKeys == null) || (partitionKeys.length == 0)) {
      partitionRanges = queryRanges.partitionRanges;
    } else {
      partitionRanges = new ArrayList<>(partitionKeys.length * queryRanges.partitionRanges.size());
      for (final byte[] partitionKey : partitionKeys) {
        for (final SinglePartitionQueryRanges sortKeyRange : queryRanges.partitionRanges) {
          byte[] newPartitionKey;
          if (partitionKey == null) {
            newPartitionKey = sortKeyRange.getPartitionKey();
          } else if (sortKeyRange.getPartitionKey() == null) {
            newPartitionKey = partitionKey;
          } else {
            newPartitionKey =
                ByteArrayUtils.combineArrays(partitionKey, sortKeyRange.getPartitionKey());
          }
          partitionRanges.add(
              new SinglePartitionQueryRanges(newPartitionKey, sortKeyRange.getSortKeyRanges()));
        }
      }
    }
  }

  public QueryRanges(final List<QueryRanges> queryRangesList) {
    // group by partition
    final Map<ByteArray, Collection<ByteArrayRange>> sortRangesPerPartition = new HashMap<>();
    for (final QueryRanges qr : queryRangesList) {
      for (final SinglePartitionQueryRanges r : qr.getPartitionQueryRanges()) {
        final Collection<ByteArrayRange> ranges =
            sortRangesPerPartition.get(new ByteArray(r.getPartitionKey()));
        if (ranges == null) {
          sortRangesPerPartition.put(
              new ByteArray(r.getPartitionKey()),
              new ArrayList<>(r.getSortKeyRanges()));
        } else {
          ranges.addAll(r.getSortKeyRanges());
        }
      }
    }
    partitionRanges = new ArrayList<>(sortRangesPerPartition.size());
    for (final Entry<ByteArray, Collection<ByteArrayRange>> e : sortRangesPerPartition.entrySet()) {
      Collection<ByteArrayRange> mergedRanges;
      if (e.getValue() != null) {
        mergedRanges = ByteArrayRange.mergeIntersections(e.getValue(), MergeOperation.UNION);
      } else {
        mergedRanges = null;
      }
      partitionRanges.add(new SinglePartitionQueryRanges(e.getKey().getBytes(), mergedRanges));
    }
  }

  public QueryRanges(final Collection<SinglePartitionQueryRanges> partitionRanges) {
    this.partitionRanges = partitionRanges;
  }

  public QueryRanges(final ByteArrayRange singleSortKeyRange) {
    partitionRanges = Collections.singletonList(new SinglePartitionQueryRanges(singleSortKeyRange));
  }

  public QueryRanges(final byte[][] partitionKeys) {
    partitionRanges = fromPartitionKeys(partitionKeys);
  }

  private static Collection<SinglePartitionQueryRanges> fromPartitionKeys(
      final byte[][] partitionKeys) {
    if (partitionKeys == null) {
      return null;
    }
    return Arrays.stream(partitionKeys).map(input -> new SinglePartitionQueryRanges(input)).collect(
        Collectors.toList());
  }

  public Collection<SinglePartitionQueryRanges> getPartitionQueryRanges() {
    return partitionRanges;
  }

  public List<ByteArrayRange> getCompositeQueryRanges() {
    if (partitionRanges == null) {
      return null;
    }
    if (compositeQueryRanges != null) {
      return compositeQueryRanges;
    }
    if (partitionRanges.isEmpty()) {
      compositeQueryRanges = new ArrayList<>();
      return compositeQueryRanges;
    }
    final List<ByteArrayRange> internalQueryRanges = new ArrayList<>();
    for (final SinglePartitionQueryRanges partition : partitionRanges) {
      if ((partition.getSortKeyRanges() == null) || partition.getSortKeyRanges().isEmpty()) {
        internalQueryRanges.add(
            new ByteArrayRange(partition.getPartitionKey(), partition.getPartitionKey()));
      } else if (partition.getPartitionKey() == null) {
        internalQueryRanges.addAll(partition.getSortKeyRanges());
      } else {
        for (final ByteArrayRange sortKeyRange : partition.getSortKeyRanges()) {
          internalQueryRanges.add(
              new ByteArrayRange(
                  ByteArrayUtils.combineArrays(
                      partition.getPartitionKey(),
                      sortKeyRange.getStart()),
                  ByteArrayUtils.combineArrays(partition.getPartitionKey(), sortKeyRange.getEnd()),
                  sortKeyRange.singleValue));
        }
      }
    }

    compositeQueryRanges = internalQueryRanges;
    return compositeQueryRanges;
  }

  public boolean isMultiRange() {
    if (compositeQueryRanges != null) {
      return compositeQueryRanges.size() >= 2;
    }
    if (partitionRanges.isEmpty()) {
      return false;
    }
    if (partitionRanges.size() > 1) {
      return true;
    }
    final SinglePartitionQueryRanges partition = partitionRanges.iterator().next();
    if ((partition.getSortKeyRanges() != null) && (partition.getSortKeyRanges().size() <= 1)) {
      return false;
    }
    return true;
  }
}

redpajama_set_name: RedPajamaGithub


text:
package io.gank.view;

import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.LinearLayout;

import io.gank.R;

/**
 * Created by Administrator on 2015/8/16.
 */
public class UpRefreshRecyclerView extends RecyclerView {

    private View mFooterView;
    private boolean isLoading = false;
    private UpRefreshListener mUpRefreshListener;
    private LinearLayout llFooterContent;
    private LayoutManager mLayoutManager;

    public UpRefreshRecyclerView(Context context) {
        this(context, null);
    }

    public UpRefreshRecyclerView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public UpRefreshRecyclerView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }

    private void init(Context context) {
        mFooterView = LayoutInflater.from(context).inflate(R.layout.listview_footer, null);
        llFooterContent = (LinearLayout) mFooterView.findViewById(R.id.ll_footer_content);
        this.addOnScrollListener(new MyOnScrollListener());
        updateFooterHeight(0);
    }

    public void setUpRefreshListener(UpRefreshListener listener) {
        mUpRefreshListener = listener;
    }

    public void onRefreshFinish() {
        postDelayed(new Runnable() {
            @Override
            public void run() {
                isLoading = false;
                updateFooterHeight(0);
            }
        }, 1000);

    }

    class MyOnScrollListener extends OnScrollListener {
        @Override
        public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
            super.onScrollStateChanged(recyclerView, newState);
        }

        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            super.onScrolled(recyclerView, dx, dy);
            mLayoutManager = recyclerView.getLayoutManager();
            int visibleItemCount = 0;
            int[] firstVisibleItems = {0, 0};
            int[] lastVisibleItems = {0, 0};
            if (mLayoutManager instanceof StaggeredGridLayoutManager) {
                firstVisibleItems = ((StaggeredGridLayoutManager) mLayoutManager).findFirstVisibleItemPositions(null);
                lastVisibleItems = ((StaggeredGridLayoutManager) mLayoutManager).findLastVisibleItemPositions(null);

                visibleItemCount = (lastVisibleItems[1] - firstVisibleItems[0]) + 1;

            }
            int totalItemCount = getAdapter().getItemCount();

            if (totalItemCount > visibleItemCount) {
                int lastItemId = Math.max(lastVisibleItems[0], lastVisibleItems[1]); // 获取当前屏幕最后Item的ID
                if ((lastItemId + 1) == totalItemCount) { // 达到数据的最后一条记录
                    if (!isLoading) {
                        isLoading = true;
                        if (totalItemCount > 0) {
                            mUpRefreshListener.onUpRefresh();
                        }
                    }
                }
            }
        }
    }

    public void updateFooterHeight(int headerHeight) {
        llFooterContent.getLayoutParams().height = headerHeight;
        llFooterContent.requestLayout();
    }

    public interface UpRefreshListener {
        void onUpRefresh();
    }
}


text:
- multi-task configuration support added
- coffeescript support fixed
- fixed issue with projectRoot defaulting to entire project when it was not specified in the config, the projectRoot will now default to being empty and not adding the entire project folder if it is not specified in the task configuration
- added growl option to configuration
- added fix so the task fails if Jasmine tests fail


text:
a,abbr,acronym,address,applet,article,aside,audio,b,blockquote,big,body,center,canvas,caption,cite,code,command,datalist,dd,del,details,dfn,dl,div,dt,em,embed,fieldset,figcaption,figure,font,footer,form,h1,h2,h3,h4,h5,h6,header,hgroup,html,i,iframe,img,ins,kbd,keygen,label,legend,li,meter,nav,object,ol,output,p,pre,progress,q,s,samp,section,small,span,source,strike,strong,sub,sup,table,tbody,tfoot,thead,th,tr,tdvideo,tt,u,ul,var{background:transparent;border:0 none;font-size:100%;margin:0;padding:0;border:0;outline:0;vertical-align:top;}ol,ul{list-style:none;}blockquote,q{quotes:none;}table,table td{padding:0;border:none;}img{vertical-align:top;}embed{vertical-align:top;}a{outline:0!important;;}/*html, body {
	height:100%;
	min-height:100%;
*/}
ul, ol {
	margin: 0;
	padding: 0;
}
a:focus {
	outline: none;
}
/*form element*/
/*body{	font: 13px/1.6 Arial, Helvetica, sans-serif;color: #7a7a7a;margin: 0;padding: 0;-webkit-text-size-adjust:none;}
label, input, button, select, textarea {
	font-weight: normal;
	font-size: 12px;
	line-height: 20px;
}
html {
	width: 100%;
}*/
a, a:visited, a:active, a:link, a:focus {
	cursor: pointer;
	text-decoration: none;
	color: #333;
	outline: none;
}
a:hover {
	text-decoration: none;
	color: #a9a9a9;
}
/* ************************************************************************************************
	FORM
************************************************************************************************ */
form {
	margin: 0 0 0px 0;
	padding: 0;
}
/*input[type="text"], input[type="password"], input[type="date"], input[type="datetime"], input[type="email"], input[type="number"], input[type="search"], input[type="tel"], input[type="time"], input[type="url"], textarea {
	background-color: white;
	font-family: inherit;
	border: 1px solid #cccccc;
	-webkit-border-radius: 0px;
	-moz-border-radius: 0px;
	-ms-border-radius: 0px;
	-o-border-radius: 0px;
	border-radius: 0px;
	-webkit-box-shadow: none;
	-moz-box-shadow: none;
	box-shadow: none;
	-webkit-appearance: none;
	color: rgba(0, 0, 0, 0.75);
	font-size: 14px;
	margin: 0 0 0px 0;
	padding: 6px;
	height: 32px;
	width: 100%;
	-webkit-transition: all 0.15s linear;
	-moz-transition: all 0.15s linear;
	-o-transition: all 0.15s linear;
	transition: all 0.15s linear;
	outline: none;
}*/
input[type="text"].oversize, input[type="password"].oversize, input[type="date"].oversize, input[type="datetime"].oversize, input[type="email"].oversize, input[type="number"].oversize, input[type="search"].oversize, input[type="tel"].oversize, input[type="time"].oversize, input[type="url"].oversize, textarea.oversize {
	font-size: 17px;
	padding: 4px 6px;
}
input[type="text"]:focus, input[type="password"]:focus, input[type="date"]:focus, input[type="datetime"]:focus, input[type="email"]:focus, input[type="number"]:focus, input[type="search"]:focus, input[type="tel"]:focus, input[type="time"]:focus, input[type="url"]:focus, textarea:focus {
	background: #fefefe;
	outline: none !important;
	border-color: #999;
	box-shadow: none;
}
input[type="text"][disabled], input[type="password"][disabled], input[type="date"][disabled], input[type="datetime"][disabled], input[type="email"][disabled], input[type="number"][disabled], input[type="search"][disabled], input[type="tel"][disabled], input[type="time"][disabled], input[type="url"][disabled], textarea[disabled] {
	background-color: #ddd;
	box-shadow: none;
}
textarea {
	height: auto;
	resize: none;
}
select, select:focus, select:focus {
	width: 100%;
	outline: none;
}
select {
	background: #FFFFFF;
	border-color: #cccccc #cccccc #cccccc #cccccc;
	border-radius: 0px 0px 0px 0px;
	border-style: solid;
	border-width: 1px;
	height: auto;
	padding: 6px 6px 6px 2px;
	width: auto;
}
/*label {
	font-size: 12px;
	display: inline-block;
	color: #333333;
	margin-bottom: 5px;
	cursor: default;
	font-weight:bold;
}
*/input, textarea, select {
	-webkit-box-sizing: border-box;
	-moz-box-sizing: border-box;
	box-sizing: border-box;
	width: 100%;
}
input:before, textarea:before, select:before, input:after, textarea:after, select:after {
	-webkit-box-sizing: border-box;
	-moz-box-sizing: border-box;
	box-sizing: border-box;
}
input, textarea, select, .uneditable-input {
	margin-bottom: 0;
}
.radio input[type="radio"], .checkbox input[type="checkbox"] {
	float: left;
	margin-left: 0px;
}
input[type="radio"], input[type="checkbox"] {
	line-height: normal;
	margin: 4px 0 0;
}
.checkbox label, .radio label {
	display: inline-block;
}
input[type="file"]:focus, input[type="radio"]:focus, input[type="checkbox"]:focus {
	outline: 0 none;
}

table th, table td {
	vertical-align: middle;
}
table td { border:none;}
table th {
	white-space: nowrap;
	background: #fbfbfb;
}
table tfoot td {
	color: #333;
	text-align: right;
	white-space: nowrap;
}
/*table {

	border-spacing: 0;
	margin-bottom: 20px;
	vertical-align: middle;
	padding:0;

	width: 100%;
}*/
/*table tbody{ border:none;}*/
table th {
	border: 1px solid #ccc;
	color: #333333;
	font-size: 13px;
	font-weight: bold;
	padding: 10px;
	text-align: left;
	vertical-align: middle;
	text-transform: none;

}
table td {

	padding: 10px;
}

/* ************************************************************************************************
	FORGOT PASSWORD
************************************************************************************************ */

.pass_forgot .contentInfoText{ margin-bottom:20px;}
.pass_forgot table{ margin-bottom:0;}
.pass_forgot .contentInfoText td{ padding:12px 0 0 0;}
.contentPadd.pass_forgot h3{ margin-bottom:10px;}
.pass_forgot td span.labb{ display:block; font-weight:bold; margin-bottom:5px; color:#333;}
.pass_forgot input{ margin-bottom:20px; width:350px;}
.buttonset1{ border:1px solid #399b49; display:inline-block;}
.buttonset1:hover{border:1px solid #258033;}
.buttonset1 button{ border:1px solid #73ca77; background:#43b355;}
.buttonset1:hover button{border:1px solid #75d47a; background:#3aa04c;}
.buttonset1:hover button .ui-button-text{ color:#fff;}
.buttonset1 button .ui-button-text{ font-size:15px; font-weight:bold; color:#fff; position:relative; padding:10px 40px 10px 15px;text-shadow: 1px 1px 1px #1f8931;}
.buttonset1 button .ui-button-text:before {
    content: "\f054";
    font-family: FontAwesome;
    font-style: normal;
    font-weight: normal;
    text-decoration: inherit;
    color: #fff;
    font-size:20px;
    position: absolute;
	display:inline-block;
	vertical-align:-2px;
	right:12px;
	top:11px;
}

.buttonset1 a{ border:1px solid #73ca77; background:#43b355;}
.buttonset1:hover a{border:1px solid #75d47a; background:#3aa04c;}
.buttonset1:hover a .ui-button-text{ color:#fff;}
.buttonset1 a .ui-button-text{ font-size:15px; font-weight:bold; color:#fff; position:relative; padding:5px 40px 7px 15px;text-shadow: 1px 1px 1px #1f8931;}
.buttonset1 a .ui-button-text:before {
    content: "\f054";
    font-family: FontAwesome;
    font-style: normal;
    font-weight: normal;
    text-decoration: inherit;
    color: #fff;
    font-size:20px;
    position: absolute;
	display:inline-block;
	vertical-align:-2px;
	right:12px;
	top:7px;
}

.buttonset2{ border:1px solid #666666; border-bottom:1px solid #292929; display:inline-block;}
.buttonset2:hover{border:1px solid #666666; border-bottom:1px solid #666666;border-top:1px solid #303030;border-left:1px solid #303030;}
.buttonset2 a{ border:1px solid #8b8a8a; background:#6c6c6c;}
.buttonset2:hover a{border:1px solid #8a8a8a; background:#575757;}
.buttonset2:hover a .ui-button-text{ color:#fff;}
.buttonset2 a .ui-button-text{ font-size:13px; font-weight:bold; color:#fff; position:relative; padding:5px 15px 7px 30px;text-shadow: 1px 1px 1px #474747;}
.buttonset2 a .ui-button-text:before {
    content: "\f053";
    font-family: FontAwesome;
    font-style: normal;
    font-weight: normal;
    text-decoration: inherit;
    color: #fff;
    font-size:14px;
    position: absolute;
	display:inline-block;
	vertical-align:-2px;
	left:10px;
	top:7px;
}

/* ************************************************************************************************
	CREATE ACCOUNT
************************************************************************************************ */
.create_account h3 .inputRequirement{ float:right; padding-right:0;}
.create_account .contentPadd h3{ padding-right:0; margin-bottom:0;}
.create_account table{ margin-bottom:0;}
.create_account .contentInfoText{ padding-bottom:12px; margin-bottom:20px;}
.create_account td{ padding:0; width:100%; display:block;}
.table_lable{ display:block; padding-bottom:5px; font-weight:bold; color:#333;}
.create_account .radio input{ float:none; margin-top:-4px; margin-right:5px;}
.create_account .radio input + input{ margin-left:20px;}
.create_account .fieldValue input.input{ width:430px;}
.create_account .fieldValue select.input{ width:430px;}
.create_account .fieldValue select{ width:430px;}

/* ************************************************************************************************
	CREATE ACCOUNT
************************************************************************************************ */
.create_account_success .box_infornation{ padding-bottom:20px;}
.create_account_success .contentPadd.txtPage{ padding:5px 20px 20px 20px; border:1px solid #d6d4d4; background:#fbfbfb;}
.create_account_success .img_box { margin-right:20px;}

/* ************************************************************************************************
	CREATE ACCOUNT
************************************************************************************************ */

.account_main .contentPadd h3{ margin-bottom:12px;}
.account_main .contentInfoText{ padding-bottom:0;}
.account_main i{ font-size:20px;vertical-align:-1px; margin-right:7px;}

.account_main a [class^="icon-"],
.account_main a [class*=" icon-"]	{display: inline;}

.account_main .accountLinkList li{ margin-bottom:10px;}
.account_main .accountLinkList li a{ color:#333;}
.account_main .accountLinkList li a:hover{ color:#999;}

/* ************************************************************************************************
	CREATE ACCOUNT
************************************************************************************************ */
.account_notif br{ display:none;}
.account_notif td strong{ margin-right:10px;}
.btn_wrapp{ padding-top:20px; width:100%; overflow:hidden;}
.contentInfoText  .input_tabll{ padding:0;}
.contentInfoText  .input_tabll input{ margin-top:-2px;}

/* ************************************************************************************************
	ACCOUNT NEWSLETTER
************************************************************************************************ */
.account_newsletter table{ margin-bottom:0;}

/* ************************************************************************************************
	ACCOUNT PASSWORD
************************************************************************************************ */
.account_password .contentPadd h3{ padding-right:0;}
.account_password h3 .inputRequirement{ float:right; padding-right:0;}
.account_password .contentInfoText td{ padding:0 0 12px 0;}
.account_password table{ margin-bottom:0;}
.account_password .contentInfoText{ padding-bottom:12px;}

/* ************************************************************************************************
	ACCOUNT EDIT
************************************************************************************************ */
.account_edit{}
.account_edit .contentPadd h3{ padding-right:0;}
.account_edit h3 .inputRequirement{ float:right; padding-right:0;}

.account_edit table{ margin-bottom:0;}
.account_edit .contentInfoText{ padding-bottom:12px; margin-bottom:20px;}
.account_edit td{ padding:0; width:100%; display:block;}
.account_edit .radio input{ float:none; margin-top:-4px; margin-right:5px;}
.account_edit .radio input + input{ margin-left:20px;}
.account_edit .fieldValue input.input{ width:430px;}
.account_edit .fieldValue select.input{ width:430px;}
.account_edit .fieldValue select{ width:430px;}

/* ************************************************************************************************
address_book
************************************************************************************************ */

.contentaddress { background:#fff; padding:20px; border:1px solid #d6d4d4; margin-bottom:20px;}
.contentaddressbr br{ display:none; }
.address_book .contentInfoText { margin-bottom:20px;}
.address_book .infoString{ margin-bottom:0;}

/* ************************************************************************************************
.address_book_details
************************************************************************************************ */
.address_book_details{}
.contentPadd .address_book_details  h3{ padding-right:0;}
.address_book_details h3 .inputRequirement{ float:right; padding-right:0;}

.address_book_details table{ margin-bottom:0;}
.address_book_details .contentInfoText{ padding-bottom:12px; margin-bottom:20px;}
.address_book_details td{ padding:0; width:100%; display:block;}
.address_book_details .radio input{ float:none; margin-top:-4px; margin-right:5px;}
.address_book_details .radio input + input{ margin-left:20px;}
.address_book_details .fieldValue input.input{ width:430px;}
.address_book_details .fieldValue select.input{ width:430px;}
.address_book_details .fieldValue select{ width:430px;}
.input_ex input{ margin-top:0; margin-right:7px;}
.address_book_details .btn_wrapp{ padding-top:0;}
.address_block{ padding:20px; background:#fff; border:1px solid #d6d4d4; margin-bottom:20px;}
.address_block:last-child{ margin-bottom:0;}
.checkout_shipping_address .address_block:last-child{ margin-bottom:20px;}
.address_block .ui-button-text-icon-primary .ui-button-text,.address_block .ui-button-text-icons .ui-button-text { padding:7px 10px 7px 10px;}
.block_extra_delete{padding:20px; background:#fff; border:1px solid #d6d4d4; margin-top:20px;}
.delete_padd .buttonset1 a .ui-button-text:before{   content: "\f00d";top: 6px;}

.shipping_block table  tr td{ padding-left:0;}
.shipping_block table{ margin-bottom:0;}
.shipping_block table strong{ color:#333;}
.contentInfoText.shipping_block { padding-top:20px; margin-bottom:20px;}

/* ************************************************************************************************
.address_book_details
************************************************************************************************ */
.contentPadd .checkout_new_address_2  h3{ padding-right:0;}
.checkout_new_address_2 h3 .inputRequirement{ float:right; padding-right:0;}

.checkout_new_address_2 table{ margin-bottom:0;}
.checkout_new_address_2 .contentInfoText{ padding-bottom:12px; margin-bottom:20px;}
.checkout_new_address_2 td{ padding:0; width:100%; display:block;}
.checkout_new_address_2 .radio input{ float:none; margin-top:-4px; margin-right:5px;}
.checkout_new_address_2 .radio input + input{ margin-left:20px;}
.checkout_new_address_2 .fieldValue input.input{ width:430px;}
.checkout_new_address_2 .fieldValue select.input{ width:430px;}
.checkout_new_address_2 .fieldValue select{ width:430px;}

.adress_even .address_block:last-child{ margin-bottom:0}
.adress_even table{ margin-bottom:0;}
.adress_even input{ margin-top:0}

.prods_content.cart .name_padd{ background:none; padding:0px 10px 12px 10px;}
/*.bg_body  {height:100%;height:100%;height:auto !important;min-height:100%;}
.wrapper{ border:1px solid #e5e5e5; border-width:1px 1px 0 1px;
-webkit-box-shadow: 0 0 5px 3px #ececec;
}
.wrapper > div{}
*/.wrapper > div.cont{ float:none; overflow:hidden; padding:10px 0 0 0; background:#fff; width:1028px; margin:0 auto;
box-shadow:0 0 20px #e9e9e9;-moz-box-shadow:0 0 20px #e9e9e9;-webkit-box-shadow:0 0 20px #e9e9e9; position:relative;}
.index_page .wrapper{}
/*.row_1{margin:0px auto;width:100%; float:left;}*/
.row_1.bg{}
.row_1.extra{margin-bottom:0px;}
.cart_products_options{ margin-right:10px;}
.row_2{font-size:1em;padding: 0px 0px 0px 0px; width:100%; float:left; z-index:77;}
.index_page .row_2{}
/*.row_3{ padding-bottom:35px;width:100%; float:left;}
*/.row_4{font-size:1em;padding:0px 0px 0px 0px; margin:0px auto; overflow:hidden; width:100%; float:left; }
.foot_inner{margin:0 auto; position:relative;}
.row_4 > div{}
.index_page .row_4{ padding-bottom:10px;}
/*.row_5{padding:0px 0px 0px 0px; position:relative;) repeat-x 0 100%; border-top:1px solid #e3e3e3; width:100%; float:left;}*/
.row_8{padding:0px 0px 0px 0px; position:relative;) repeat-x 0 100%; border-top:1px solid #e3e3e3; width:100%; float:left; min-height:38px;
			background:url("../images/extra_bg_footer.png") repeat-x 0 0 #000;}
.wrapp{padding:0 0px 0 0px; width:auto;}
.row_6{}
/*#bodyWrapper  { padding-bottom: 0px;}*/
/*#bodyWrapper .wrapper {margin:0px auto 0px auto; padding:0px 0px 0px 0;overflow:hidden; position:relative; width:1247px; background:#fff;}
*//*#bodyContent{padding:0px 0px 0px 0px;}*/
#bodyWrapper > br{line-height:25px;}

/*#columnLeft{padding:0px 0px 10px 0px;}*/
#columnRight{padding:0px 0px 0px 0px;}
#columnLeft > div{padding:0px 0px 0px 0px;}
#columnRight > div{padding:0px 0px 0px 0px;}
/*.contentContainer{margin-bottom:10px; padding:0px 0px 0px 0px;}*/
/*.contentContainer.last{margin-bottom:0px; padding-bottom:0px}*/
/*.contentContainer.page_un{padding-top:0px;}*/
.contentContainer.page_un.first	.contentPadd{background:#fff;}

/*.box_cms{background:#fff;padding:20px; margin-top:10px;}*/
.page_specials .prods_content{background:#fff;}
.page_specials .prods_content .row.row3.last .prods_padd{ padding-bottom:20px;}

.contentContainer.page_cart{ padding:10px 0; background:#fff;}
.contentContainer.page_reviews{}
/*.contentContainer.page_new_product{}*/
.contentContainer.page_cart .buttonSet > div{ margin-right:10px;}
.contentPadd{overflow: hidden;}
.contentPadd.txtPage{padding:10px 0px 10px 0px;}
.contentPadd.sub{padding:5px 0px 5px 0px;}
.contentPadd.prods_info_page{padding:0px 0px 0px 11px; margin-bottom: 10px;}
.contentContainer.page_un .contentPadd{padding:0 0 0px 0px;}
.contentContainer.page_un .contentPadd.last	{}
/*.contentContainer.page_new_product .contentPadd,*/
/*.contentContainer.page_specials .contentPadd,*/
/*.contentContainer.page_listing .contentPadd{padding:10px 0 0px 0px;}*/
/*.contentContainer.page_reviews .contentPadd{padding:10px 0px 10px 0px;}*/
.contentContainer.page_reviews.page_listing .contentPadd{}
.contentContainer.page_cart .contentPadd{padding:0px 0px 10px 0px;}
.contentContainer.loginPage .contentPadd{padding:0px 0px 40px 0px;}
.contentInfoText{padding:5px 20px 20px 20px;margin: 0px 0px 10px 0px; background:#fff;}
/*.contentInfoText.extra{padding: 10px 10px 20px 10px;}*/
.contentInfoText .infoBoxHeading{padding:1px 0px 10px 0px;margin: 0px 0px 0px 0px;background:none; border:0px; font-weight:bold;}
.contentInfoText td{ padding-top:10px; padding-bottom:10px;}
.contentContainer span.contentText{padding:0px 9px 0px 9px; border:0px solid #000; overflow:hidden;}
.contentInfoText.marg-top{margin: 0px 0px 0px 0px;width: 100%;}
.contentInfoText .contentInfoText_wrap{padding:0 0 10px 0;}
/*.contentInfoBlock{padding:20px 0px 12px 0px; background:#fff; margin-bottom:5px;}*/
.contentInfoBlock.last{padding:20px 20px 10px 20px; margin: 0px 0px 0px 0px; }
.contentContainer.page_un .contentText{padding: 18px 27px 0px 27px;}
.contentPadd.r_view{display:none;}
/*.row_table{list-style:none;margin:5px 0px 0px 0px;padding: 0px 0px 0px 0px; display:inline-block; float:right; }*/
/*.row_table li{float:right; display:inline-block; margin-left:5px; cursor:pointer; width:24px; height:21px;}*/
.row_table li.first{background: url("../images/icons/row.png") no-repeat scroll 0 0 transparent;	}
.row_table li.last{background: url("../images/icons/table.png") no-repeat scroll 0 0 transparent;	}
/*.row_table li.act,*/
/*.row_table li:hover{background-position:0 -21px;}*/
.prods_info_mad,.contentInfoText .prods_info{ margin:0 4px 0 4px; padding-top:10px;}
.prods_info_mad	{ padding:10px;}

.contentContainer.page_listing .prods_content.prods_table{background:#fff;overflow: hidden;}
/* ***********************   HEADER_AND_LOGO   ************************************************************** */
/*#header{position:relative;padding: 0px 0px 0px 0px;min-height:297px;margin:0 -1px;}*/
/*.logo{display:inline-block;width:241px; height:66px; position:absolute; left:40px; top:108px; z-index:9;}
.logo img{margin:0px 0px 0px 0px;}
*/

/* ************************************************************************************* */
.currencies	label,
/*.languages	label{color:#fff; padding:3px 0px 0px 5px;font-size:11px; font-weight:100;font-family: 'Open Sans', sans-serif; text-transform:uppercase;}
*/.currencies	select,
.languages	select{color:#fff;width:48px;/* border:1px solid #dedddd;*/padding:1px;background:#fff;font-size:11px}
.manufacturers	label{padding-top:2px;}
/*.languages	label{display:none;}*/
/*.languages img{margin: 2px 0px 0px 0px; float:left;}*/
/*.languages a{color:#010101; font-weight:normal;display:block; padding:0px; float:left; margin:0 0 0 6px; text-transform: lowercase;}
*/.languages a:hover{ color:#fff;}
.languages .languages_img{margin: 0px 6px 0px 0px; display:none;}
.languages a img{ float:left;}
.box_languages ul { border: 1px solid #191919; background: #fff;}
.box_social_bookmarks{overflow:hidden;margin:0px 0px 0px 0px;display:inline-block;width:284px;}
.box_social_bookmarks label			{color:#8f8e8e;font-weight:normal; margin-right:5px;margin-top:0px;float:right;}
.box_social_bookmarks div			{float:right;display:inline-block; float:right; color:#8f8e8e;}
.box_social_bookmarks div a			{color:#fff; font-weight:bold;}
.box_social_bookmarks div a:hover	{color:#8c5e56;}

/* ************************************************************************************* */
.custom_select .select.jqTransformHidden{display: none;}
.custom_select .jqTransformSelectWrapper{background: url("../images/cur-arrow.gif") no-repeat  right 12px; float: left;cursor:pointer;overflow: hidden;padding: 0; width:82px!important;}
.custom_select .jqTransformSelectWrapper div span{float: left; padding:4px 19px 5px 7px;font-weight:normal; }
.custom_select .jqTransformSelectWrapper div span{color: #fff;width:81px !important;font-size:11px; font-weight:200;font-family: 'Open Sans', sans-serif; text-transform:uppercase;}
.custom_select ul{; background:#fff; margin: 33px 0 0 0px;  padding:0px 0 1px 0;height: auto !important;  overflow:hidden;border-radius:2px;font-size:11px; font-weight:200;font-family: 'Open Sans', sans-serif;color:#4a650e}
.custom_select ul li:first-child{ border:none;}
.custom_select ul li{border-top: 0px solid #dad6ca;}
.custom_select ul li a{color: #4a650e;text-decoration: none; padding: 1px 5px 0px 8px; display:block; position:relative;font-weight:normal;}
.custom_select ul li a:hover{color:#d1d7b9;}
.custom_select ul li a:before {
    content: "\f105";
    font-family: FontAwesome;
    font-style: normal;
    font-weight: normal;
    text-decoration: inherit;
    font-size:11px;
    position: absolute;
    top:2px;
    left: 7px;
	display:none;
}

/* ********************************  HEADER_SHOPINGCART_BLOCK   *************************************** */
/*.box_header_cart i{ float:left; font-size:14px; color:#707070; display:inline-block; vertical-align:-4px; margin-right:12px;
display:none;}
*//*.box_header_cart{top:119px; right:280px;z-index:9; background: url("../images/header_cart.png") no-repeat  0px 0px; padding:9px 0px 0px 38px;font-family: 'Open Sans', sans-serif;letter-spacing:.06em;position: absolute;}
*//*.box_header_cart:hover{background-position:0px -30px;}*/
/*.box_header_cart a.cart_l{  border-radius:3px; min-width:165px;font-size:13px;}*/
/*.box_header_cart a label{padding:0px 0 0px 0px;display:inline-block; margin:0px 0px 0px 0px; color:#707070; font-weight:700;font-size:13px; display:none;}
*//*.box_header_cart a.cart_l:hover{cursor:pointer;}
*//*.box_header_cart a.cart_l:hover span,
.box_header_cart a.cart_l:hover label{cursor:pointer;}*/
/*.box_header_cart a.cart_l:hover i{ color:#060606;}*/
/*.box_header_cart a.cart_l span span{ font-size:13px; font-weight:700; color:#707070;}
.box_header_cart a.cart_l span,
.box_header_cart a.cart_l span strong{  font-weight:500; color:#707070;font-size:13px;}
*//*.box_header_cart a.cart_l:hover span { color:#060606;}*/
/*.box_header_cart a.cart_l span  span { display: none;}*/
/* ********************************   HEADER_SEARCH_BLOCK   ******************************************** */
#box_search button span{display:block; float:right; padding:0; width:28px; height:30px; border:none; text-indent:-9999px;  }
#box_search button{background: url("../images/btn-search.png") no-repeat  0px 0px;margin-left:0px; float:left;}
#box_search button:hover{
	background-position:0 -30px;
}
#box_search button:hover span{}

/*.search {position:absolute; top:118px; right:39px;z-index:1;border: 1px solid #ededed;}*/

.search label{  display:none;}
.search .go{color:#82938b;padding:3px 7px 1px 13px; border:none;font-size:12px; height:30px; width:185px; background:transparent;}
.search .input-width { float:left;display: block;}
.search .advanced a{color:#fff;}
.search .advanced a:hover{}
.search .go:focus{ border-top:0px solid #e1e1e1;}

/* **********************************   HEADER_BREADCRUMB   ********************************************* */

/*.breadcrumb					{padding:0px 0px 15px 15px;margin:0px 0px 10px 0px;color: #858585; background:#fff;}
.breadcrumb i{ margin-left:5px; margin-right:5px; display: inline-block; vertical-align:0px;}
.breadcrumb a 				{color: #858585;font-weight:normal; text-decoration:none;display:inline-block;}
.breadcrumb a:hover 		{color: #191919; text-decoration:none;}
.breadcrumb a.last 			{color: #191919;}
.breadcrumb a.last:hover	{color: #858585;}

*//* ********************************     HEADER_USER_MENU   ************************************************ */

/*.box_header_user_menu			{padding: 0px 0px 0 0px;margin: 0px 0px 0px 0px;float:left;}
*//*.user_menu 						{padding:0px 0px 0px 0px;margin:0px 0 0px 0px; list-style:none; position:absolute;top:9px; left:38px;z-index: 100; }*/
/*.user_menu li:first-child a	{padding-left:;;margin:0;margin-right:-2px;}
.user_menu li					{float:left; display:inline-block; white-space:nowrap;}
.user_menu li:first-child		{background:none;}
.user_menu li a 				{color:#fff;font-size:13px; font-weight:100;font-family: 'Open Sans', sans-serif;
					display:inline-block;
					text-decoration:none;
					padding: 0px 0px 0px 0px;
					margin:0px 0 0px 30px;
*/					/*text-transform:uppercase;
					letter-spacing:.008em;
}
.user_menu li b					{color:#d9e2bf;display:inline-block;padding: 0px;}
.user_menu li a:hover,
.user_menu li.act a				{color:#d1d7b3;}		*/

/* ********************************   FOOTER BLOCK    ***************************************************** */
.footer{padding:0px 0px 0px 0px; left:0px;}
.footer p{font-size:13px;color:#fff;margin:0px;overflow:hidden;display:block;padding:10px 0px 8px 0px;clear:both;width:100%;text-indent: 20px; text-transform:uppercase;
margin-bottom: -37px;}
.footer p > a{color:#fff;font-weight:normal;}
.footer p > a:hover{color:#d1d7b3;}
.footer p b{color:#fff; font-weight:normal;}
.footer p b	a{color:#fff;}
.footer p b	a:hover{color:#d1d7b3;}
#bodyContent .box_wrapper_title{}
/* *********************************   HEADER_TOP_MENU    **************************************************** */
/*.boxes_menu{ position:absolute; left:0; top:208px; width:100%; }
.menu{padding:0px 0px 0px 0px; margin:0 38px;overflow:hidden; border:1px solid #e5e5e5; background:none;}
.menu ul{padding: 0px 0px 0px 0px;list-style:none; margin:0px 0px 0 0px; width:auto; display:inline-block; }
.menu li{float:left;padding:0 33px 0 34px;margin:0 0px 0 0px;background: url("../images/bg_menu.gif") no-repeat  0px 50%;}
.menu li a{font-size:15px; color:#a7a7a7;font-weight:500; font-family: 'Open Sans', sans-serif;
		display:inline-block;
		padding:18px 1px 18px 1px;
		text-transform:uppercase;
		text-shadow: 0px 0px 1px #616161;}
.menu li:first-child {}
.menu li a i{ font-size:20px;}
.menu li.mouseclick a,
.menu li.act a,
.menu li a:hover{color:#000;}
*//*.menu li.first{background:none; padding:0 35px 0 48px}*/
.de .menu li {padding:0 35px 0 35px;}
.es .menu li {padding:0 32px 0 32px;}
.ru .menu li {padding:0 20px 0 20px;}
.en .lang_0,
.ru .lang_1,
.de .lang_2,
.es .lang_3{color:#888;}

*//* ************************************************************************************* */
.banner_header				{display:inline-block;margin: 39px 8px 157px 0px; float:right;}

/* ********************************** BOX POSITION *************************************************** */
.box_header_phone,
.box_header_cart,
.box_currencies,
.box_currencies{/*top:7px; right:191px;*/}
/*.box_languages{top:9px; right:42px; width:auto; position: absolute; z-index: 101;}
*/.welcome,
.customer_greeting{background:#90c322; border:1px solid #e1d5d5; overflow:hidden; color:#fff; font-style:italic;margin: 0px 0px 20px 0px;padding: 12px 20px 14px 18px;}
.customer_greeting{ padding-top:19px;}
.welcome strong,
.customer_greeting strong{font-size:1.917em; font-weight:normal; display:inline-block; margin-right:10px; margin-top:-2px; float:left;}
.container_{width:990px; margin:0 auto;}
.grid_{display:inline; margin:auto;}
.row_1 .grid_,
.row_2 .grid_,
.row_5 .grid_{float:none;}
/*.for_smart_browsers{border-bottom:0px solid #e4e4e4;}*/

/*.extra_line	{
	position: absolute;
	top:0;
	left:0;
	width: 100%;
	height:40px;
	background: url("../images/bodyWrapper.png") repeat-x 0 0;
}
*/


text:
@implementation NBTpk

- (NBTpk *)initWithJsonDictionary:(NSDictionary*)dic{
    if(self = [super init]){
        _tpkid=[dic getStringValueForKey:@"tpkid" defaultValue:@""];
        _name=[dic getStringValueForKey:@"name" defaultValue:@""];
        _type=[dic getStringValueForKey:@"type" defaultValue:@""];
        _content=[dic getStringValueForKey:@"content" defaultValue:@""];
        _updatetime=[dic getStringValueForKey:@"updatetime" defaultValue:@""];
        _tpkname=[dic getStringValueForKey:@"tpkname" defaultValue:@""];
        _url=[dic getStringValueForKey:@"url" defaultValue:@""];
        _news=[dic getStringValueForKey:@"news" defaultValue:@""];
    }
    return self;
}

+ (NBTpk *)tpkWithJsonDictionary:(NSDictionary*)dic{
    return [[NBTpk alloc ] initWithJsonDictionary:dic];
}

@end


text:
@interface MenuHeaderCell : UICollectionViewCell
{
    UIImageView *img_icon;
}

@end


text:
<?php

namespace app\models;

use Yii;

/**
 * This is the model class for table "{{%answer}}".
 *
 * @property integer $id
 * @property integer $userId
 * @property integer $answerId
 * @property integer $wasSee
 *
 * @property Comment $answer
 * @property User $user
 *
 *@property integer count_group
 */
class Answer extends \yii\db\ActiveRecord
{
    const STATUS_UNREAD=0;
    const STATUS_READ=1;

    /**
     * @inheritdoc
     */
    public static function tableName()
    {
        return '{{%answer}}';
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        return [
            [['userId', 'answerId'], 'required'],
            [['userId', 'answerId', 'wasSee'], 'integer']
        ];
    }

    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id' => 'ID',
            'userId' => 'User ID',
            'answerId' => 'Answer ID',
            'wasSee' => 'Was See',
        ];
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getAnswer()
    {
        return $this->hasOne(Comment::className(), ['id' => 'answerId']);
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getUser()
    {
        return $this->hasOne(User::className(), ['id' => 'userId']);
    }
}


text:
using Digipost.Api.Client.Tests.Utilities;
using Xunit;

namespace Digipost.Api.Client.Archive.Tests.Smoke
{
    public class ArchiveSmokeTests
    {
        public ArchiveSmokeTests()
        {
            _t = new ArchiveSmokeTestsHelper(SenderUtility.GetSender(TestEnvironment.Qa));
        }

        private readonly ArchiveSmokeTestsHelper _t;

        [Fact(Skip = "SmokeTest")]
        public void ArchiveDocuments_read_and_delete()
        {
            _t.ArchiveAFile(ArchiveSmokeTestsHelper.ArchiveName)
                .Get_Archive(ArchiveSmokeTestsHelper.ArchiveName)
                .Get_All_Documents()
                .Get_Documents()
                .Get_DocumentsByReferenceId()
                .Delete_All_Documents();
        }

        [Fact(Skip = "SmokeTest")]
        public void ArchiveADocumentWithAttributes()
        {
            _t.ArchiveAFile()
                .Get_Default_Archive()
                .Get_All_DocumentsWithAttributes()
                .Update_attritbutesOnFirst();
        }
    }
}


text:
var isPublic = typeof window != "undefined";

/**
 * System configuration for Angular 2 samples
 * Adjust as necessary for your application needs.
 */
(function (global) {
    System.config({
        paths: {
            // paths serve as alias
            'npm:': (isPublic) ? '/' : 'node_modules/'
        },
        meta: {
            'typescript': {
                "exports": "ts"
        }},
        // map tells the System loader where to look for things
        map: {
            // our app is within the app folder
            app: 'client',
            // angular bundles
            '@angular/core':                     'npm:@angular/core/bundles/core.umd.js',
            '@angular/common':                   'npm:@angular/common/bundles/common.umd.js',
            '@angular/compiler':                 'npm:@angular/compiler/bundles/compiler.umd.js',
            '@angular/platform-browser':         'npm:@angular/platform-browser/bundles/platform-browser.umd.js',
            '@angular/platform-browser-dynamic': 'npm:@angular/platform-browser-dynamic/bundles/platform-browser-dynamic.umd.js',
            '@angular/http':                     'npm:@angular/http/bundles/http.umd.js',
            '@angular/router':                   'npm:@angular/router/bundles/router.umd.js',
            '@angular/forms':                    'npm:@angular/forms/bundles/forms.umd.js',
            'angular2-jwt':                      'npm:angular2-jwt/angular2-jwt.js',
            'js-base64':                         'npm:js-base64/base64.js',
            'ng-semantic':                       'npm:ng-semantic',
            'ng2-charts':                        'npm:ng2-charts',
            'ng2-charts/ng2-charts' :            'npm:ng2-charts/ng2-charts.ts',
            'socket.io' :                        'npm:socket.io/lib/socket.js',
            'socket.io-client' :                 'npm:socket.io-client/socket.io.js',
            'angular-highcharts' :               'npm:angular-highcharts/dist/angular-highcharts.umd.js',
            'traceur' :                          'npm:traceur/bin/traceur.js',
            'highcharts' :                       'npm:highcharts/highcharts.js',
            'rxjs' :                             'npm:rxjs',
            'buffer':                            '@empty'
        },
        // packages tells the System loader how to load when no filename and/or no extension
        packages: {
            app: {
                main: './main.js',
                defaultExtension: 'js'
            },
            rxjs: {
                defaultExtension: 'js'
            },
            'angular2-in-memory-web-api': {
                main: './index.js',
                defaultExtension: 'js'
            },
            'ng-semantic': {
                main: 'ng-semantic',
                defaultExtension: 'js'
            },
            'angular2-highcharts': {
                main: './index.js',
                defaultExtension: 'js'
            }
        }
    });
})(this);


text:
__scriptpath=$(cd "$(dirname "$0")"; pwd -P)

# We do not want to run the first-time experience.
export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1

# Don't resolve runtime, shared framework, or SDK from other locations to ensure build determinism
export DOTNET_MULTILEVEL_LOOKUP=0

# Source the init-tools.sh script rather than execute in order to preserve ulimit values in child-processes. https://github.com/dotnet/corefx/issues/19152
. $__scriptpath/init-tools.sh

__toolRuntime=$__scriptpath/Tools
__dotnet=$__toolRuntime/dotnetcli/dotnet

cd $__scriptpath
$__dotnet $__toolRuntime/run.exe $__scriptpath/config.json $*
exit $?